Merge pull request #333 from xssnick/dev-v1-11

1.13

Author: xssnick

.github/workflows/go.yml

@@ -18,7 +18,7 @@ jobs:
     - name: Set up Go
       uses: actions/setup-go@v3
       with:
-        go-version: 1.18
+        go-version: 1.23
 
     - name: Build
       run: go build -v ./...

README.md

@@ -4,7 +4,7 @@
 
 [![Based on TON][ton-svg]][ton]
 [![Telegram Channel][tgc-svg]][tg-channel]
-![Coverage](https://img.shields.io/badge/Coverage-73.2%25-brightgreen)
+![Coverage](https://img.shields.io/badge/Coverage-69.5%25-yellow)
 
 Golang library for interacting with TON blockchain.
 
@@ -68,7 +68,7 @@ You could also join our **[Telegram channel](https://t.me/tonutilsnews)** and **
 
 ### Connection
 You can use liteservers from TON configs:
-* Mainnet public servers - `https://ton.org/global.config.json`
+* Mainnet public servers - `https://ton-blockchain.github.io/global.config.json`
 * Testnet public servers - `https://ton-blockchain.github.io/testnet-global.config.json`
 
 from liteservers section, you need to convert int to ip and take port and key.

adnl/adnl.go

@@ -74,6 +74,7 @@ type ADNL struct {
 	ourAddresses unsafe.Pointer
 
 	activeQueries map[string]chan tl.Serializable
+	activePings   map[int64]chan MessagePong
 
 	customMessageHandler unsafe.Pointer // CustomMessageHandler
 	queryHandler         unsafe.Pointer // QueryHandler
@@ -98,6 +99,7 @@ func (g *Gateway) initADNL() *ADNL {
 		closerCtx:     closerCtx,
 		closeFn:       closeFn,
 		msgParts:      make(map[string]*partitionedMessage, 128),
+		activePings:   make(map[int64]chan MessagePong),
 		activeQueries: map[string]chan tl.Serializable{},
 	}
 }
@@ -220,7 +222,16 @@ func (a *ADNL) processPacket(packet *PacketContent, fromChannel bool) (err error
 func (a *ADNL) processMessage(message any) error {
 	switch ms := message.(type) {
 	case MessagePong:
-		// TODO: record
+		a.mx.RLock()
+		ch := a.activePings[ms.Value]
+		a.mx.RUnlock()
+
+		if ch != nil {
+			select {
+			case ch <- ms:
+			default:
+			}
+		}
 	case MessagePing:
 		buf, err := a.buildRequest(MessagePong{Value: ms.Value})
 		if err != nil {
@@ -294,7 +305,7 @@ func (a *ADNL) processMessage(message any) error {
 			return fmt.Errorf("failed to setup channel: %w", err)
 		}
 	case MessagePart:
-		msgID := hex.EncodeToString(ms.Hash)
+		msgID := string(ms.Hash)
 
 		a.mx.Lock()
 		p, ok := a.msgParts[msgID]
@@ -306,11 +317,17 @@ func (a *ADNL) processMessage(message any) error {
 
 			if len(a.msgParts) > 100 {
 				// cleanup old stuck messages
+				tm := time.Now().Add(-7 * time.Second)
 				for s, pt := range a.msgParts {
-					if time.Since(pt.startedAt) > 10*time.Second {
+					if tm.After(pt.startedAt) {
 						delete(a.msgParts, s)
 					}
 				}
+
+				if len(a.msgParts) > 16*1024 {
+					a.mx.Unlock()
+					return fmt.Errorf("too many incomplete messages")
+				}
 			}
 
 			p = newPartitionedMessage(ms.TotalSize)
@@ -441,6 +458,47 @@ reSplit:
 	return nil
 }
 
+func (a *ADNL) Ping(ctx context.Context) (time.Duration, error) {
+	val := time.Now().UnixNano()
+	req, err := a.buildRequest(MessagePing{
+		Value: val,
+	})
+	if err != nil {
+		return 0, err
+	}
+
+	ch := make(chan MessagePong, 1)
+	a.mx.Lock()
+	a.activePings[val] = ch
+	a.mx.Unlock()
+
+	defer func() {
+		a.mx.Lock()
+		delete(a.activePings, val)
+		a.mx.Unlock()
+	}()
+
+	for {
+		try, cancel := context.WithTimeout(ctx, 1*time.Second)
+
+		if err = a.send(req); err != nil {
+			cancel()
+			return 0, fmt.Errorf("failed to send ping packet: %w", err)
+		}
+
+		select {
+		case <-ctx.Done():
+			cancel()
+			return 0, ctx.Err()
+		case <-ch:
+			cancel()
+			return time.Since(time.Unix(0, val)), nil
+		case <-try.Done():
+			continue
+		}
+	}
+}
+
 func (a *ADNL) Query(ctx context.Context, req, result tl.Serializable) error {
 	q, err := createQueryMessage(req)
 	if err != nil {

adnl/channel.go

@@ -74,7 +74,7 @@ func (c *Channel) setup(theirKey ed25519.PublicKey) (err error) {
 	}
 
 	// if serverID < ourID, swap keys. if same -> copy enc key
-	if eq := new(big.Int).SetBytes(theirID).Cmp(new(big.Int).SetBytes(ourID)); eq == -1 {
+	if eq := new(big.Int).SetBytes(theirID).Cmp(new(big.Int).SetBytes(ourID)); eq < 0 {
 		c.encKey, c.decKey = c.decKey, c.encKey
 	} else if eq == 0 {
 		c.encKey = c.decKey

adnl/conn.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"log"
 	"net"
 	"sync"
 	"time"
@@ -90,7 +89,7 @@ func (s *SyncConn) writer() {
 					return
 				}
 				// should not happen, but if will we want to see
-				log.Println("[CONN] Write error:", err.Error())
+				Logger("[CONN] Write error:", err.Error())
 			}
 		case <-s.closerCtx.Done():
 			return

adnl/dht/bucket.go

@@ -1,6 +1,7 @@
 package dht
 
 import (
+	"bytes"
 	"sort"
 	"sync"
 )
@@ -39,13 +40,26 @@ func (b *Bucket) getNode(id string) *dhtNode {
 	return nil
 }
 
+func (b *Bucket) findNode(id []byte) *dhtNode {
+	b.mx.RLock()
+	defer b.mx.RUnlock()
+
+	for _, n := range b.nodes {
+		if n != nil && bytes.Equal(n.adnlId, id) {
+			return n
+		}
+	}
+
+	return nil
+}
+
 func (b *Bucket) addNode(node *dhtNode) {
 	b.mx.Lock()
 	defer b.mx.Unlock()
 	defer b.sortAndFilter()
 
 	for i, n := range b.nodes {
-		if n != nil && n.id() == node.id() {
+		if n != nil && bytes.Equal(n.adnlId, node.adnlId) {
 			b.nodes[i] = node
 			return
 		}