Use dc indexes accordingly

mtglib/internal/obfuscated2/handshake_frame.go

 import "encoding/binary"
 
 const (
+	DefaultDC = 2
+
 	handshakeFrameLen = 64
 
 	handshakeFrameLenKey            = 32
 
 	switch {
 	case idx > 0:
-		return int(idx) - 1
+		return int(idx)
 	case idx < 0:
-		return -int(idx + 1)
+		return -int(idx)
 	default:
-		return 0
+		return DefaultDC
 	}
 }
 

mtglib/internal/obfuscated2/handshake_frame_internal_test.go

 	suite.Equal("zyjgwaWXlTP6qjVMUP2scQbqdUtspmyH1Hen+2Ess8w", suite.Encode(hf.key()))
 	suite.Equal("z0SZMW/b9fMaokYQe6PbOg", suite.Encode(hf.iv()))
 	suite.Equal("H5lBgQ", suite.Encode(hf.connectionType()))
-	suite.EqualValues(2093, hf.dc())
+	suite.EqualValues(2094, hf.dc())
 
 	inverted := hf.invert()
 	suite.Equal("OtujexBGohrz9dtvMZlEz8yzLGH7p3fUh2ymbEt16gY", suite.Encode(inverted.key()))
 	suite.Equal("caz9UEw1qvozlZelweAozw", suite.Encode(inverted.iv()))
 	suite.Equal("H5lBgQ", suite.Encode(inverted.connectionType()))
-	suite.EqualValues(2093, inverted.dc())
+	suite.EqualValues(2094, inverted.dc())
 }
 
 func TestHandshakeFrame(t *testing.T) {

mtglib/internal/obfuscated2/testdata/client-handshake-snapshot-4529d55776e2d427.json

 {
   "secret": "NnoYmu4Y+jHBkAVO/UqOlQ",
   "frame": "gDcXwaMY4RwlR+nJw+ILDr123UJHHjjE/U5pF4m/Y04AmH7lEpEL6UYRnIYDbDlOHSDxc1ToziPvNlJJh8RMow",
-  "dc": 1,
+  "dc": 2,
   "encrypted": {
     "text": "AQIDBAUGBwgJCg",
     "cipher": "wZV3TR39l9nRoQ"

mtglib/internal/obfuscated2/testdata/client-handshake-snapshot-585c944d672f60a2.json

 {
   "secret": "NnoYmu4Y+jHBkAVO/UqOlQ",
   "frame": "M2WyxeiwIQB+ZOFxNzSNHtu9OdESkfxv3JkKFimCxUoYA3BD/Ql9nXB/OIonCKLUKCcS0VzZ2P6/+5oQ9GI8YA",
-  "dc": 1,
+  "dc": 2,
   "encrypted": {
     "text": "AQIDBAUGBwgJCg",
     "cipher": "tzAwrCz00odERg"

mtglib/internal/telegram/telegram.go

 }
 
 func (t Telegram) Dial(ctx context.Context, dc int) (net.Conn, error) {
-	if dc < 0 || dc > 4 {
+	if dc <= 0 || dc > 5 {
 		return nil, fmt.Errorf("do not know how to dial to %d", dc)
 	}
 
 	var addresses []tgAddr
 
 	if t.preferIP == preferIPOnlyIPv6 {
-		addresses = []tgAddr{v6Addresses[dc]}
+		addresses = []tgAddr{v6Addresses[dc-1]}
 	} else {
-		addresses = append(addresses, v4Addresses[dc]...)
+		addresses = append(addresses, v4Addresses[dc-1]...)
 		rand.Shuffle(len(addresses), func(i, j int) {
 			addresses[i], addresses[j] = addresses[j], addresses[i]
 		})
 
 	switch t.preferIP {
 	case preferIPPreferIPv4:
-		addresses = append(addresses, v6Addresses[dc])
+		addresses = append(addresses, v6Addresses[dc-1])
 	case preferIPPreferIPv6:
-		addresses = append([]tgAddr{v6Addresses[dc]}, addresses...)
+		addresses = append([]tgAddr{v6Addresses[dc-1]}, addresses...)
 	case preferIPOnlyIPv4, preferIPOnlyIPv6:
 	}
 

mtglib/internal/telegram/telegram_internal_test.go

 func (suite *TelegramTestSuite) TestUnknownDC() {
 	testData := []int{
 		-1,
-		5,
+        0,
+		6,
 		100,
 	}
 
 func (suite *TelegramTestSuite) TestDialToCorrectIPs() {
 	testData := map[int][]tgAddr{}
 
-	for i := 0; i < 5; i++ {
+	for i := 1; i <= 5; i++ {
 		testData[i] = []tgAddr{}
-		testData[i] = append(testData[i], v4Addresses[i]...)
-		testData[i] = append(testData[i], v6Addresses[i])
+		testData[i] = append(testData[i], v4Addresses[i-1]...)
+		testData[i] = append(testData[i], v6Addresses[i-1])
 	}
 
 	for i, v := range testData {
 			}
 
 			tg, _ := New(suite.dialerMock, name)
-			_, err := tg.Dial(context.Background(), 0)
+			_, err := tg.Dial(context.Background(), 1)
 
 			assert.True(t, errors.Is(err, io.EOF))
 		})
 
 			tg, _ := New(suite.dialerMock, name)
 
-			res, err := tg.Dial(context.Background(), 0)
+			res, err := tg.Dial(context.Background(), 1)
 			assert.NoError(t, err)
 			assert.Equal(t, conn, res)
 		})