TON: fix http server port mapping (#2120)

* fix: TON http server port mapping

* chore: resolve conflict

* chore: changeset

Author: jadepark-dev

book/src/framework/components/blockchains/ton.md

@@ -30,23 +30,27 @@ More info on parameters can be found here <https://github.com/neodix42/mylocalto
 
 ## Network Configuration
 
-The framework provides seamless access to the TON network configuration by embedding the config URL directly in the node URLs. The `ExternalHTTPUrl` and `InternalHTTPUrl` include the full path to `localhost.global.config.json`, which can be used directly with `liteclient.GetConfigFromUrl()` without additional URL formatting.
+The framework provides direct access to TON liteserver connections through pre-formatted liteserver URLs. The `ExternalHTTPUrl` and `InternalHTTPUrl` contain ready-to-use liteserver connection strings in the format `liteserver://publickey@host:port`, eliminating the need to fetch and parse separate configuration files.
 
 ## Default Ports
 
-The TON implementation exposes essential services:
+The TON implementation exposes essential services through port mapping:
 
-* TON Simple HTTP Server: Port 8000
-* TON Lite Server: Port derived from base port + 100
+* **TON Simple HTTP Server**: External dynamic port → Internal port 8000
+* **TON Lite Server**: External dynamic port → Internal dynamic port (base + 100 offset)
 
-> Note: `tonutils-go` library is used for TON blockchain interactions, which requires a TON Lite Server connection. The framework embeds the config URL directly in the node URLs for convenient access to the global configuration file needed by `tonutils-go`.
+The framework automatically handles port mapping and provides ready-to-use liteserver connection URLs.
+
+> Note: `tonutils-go` library is used for TON blockchain interactions, which requires a TON Lite Server connection. The framework provides direct liteserver:// URLs that can be used immediately without additional configuration parsing.
 
 ## Usage
 
 ```go
 package examples
 
 import (
+  "context"
+  "fmt"
   "strings"
   "testing"
 
@@ -63,6 +67,34 @@ type CfgTon struct {
   BlockchainA *blockchain.Input `toml:"blockchain_a" validate:"required"`
 }
 
+// getConnectionPoolFromLiteserverURL parses a liteserver:// URL and creates a connection pool
+func getConnectionPoolFromLiteserverURL(ctx context.Context, liteserverURL string) (*liteclient.ConnectionPool, error) {
+  // Parse the liteserver URL, expected format: liteserver://publickey@host:port
+  if !strings.HasPrefix(liteserverURL, "liteserver://") {
+    return nil, fmt.Errorf("invalid liteserver URL format: expected liteserver:// prefix")
+  }
+
+  // Remove the liteserver:// prefix
+  urlPart := strings.TrimPrefix(liteserverURL, "liteserver://")
+
+  // Split by @ to separate publickey and host:port
+  parts := strings.Split(urlPart, "@")
+  if len(parts) != 2 {
+    return nil, fmt.Errorf("invalid liteserver URL format: expected publickey@host:port")
+  }
+
+  publicKey := parts[0]
+  hostPort := parts[1]
+
+  connectionPool := liteclient.NewConnectionPool()
+  err := connectionPool.AddConnection(ctx, hostPort, publicKey)
+  if err != nil {
+    return nil, fmt.Errorf("failed to add liteserver connection: %w", err)
+  }
+
+  return connectionPool, nil
+}
+
 func TestTonSmoke(t *testing.T) {
   in, err := framework.Load[CfgTon](t)
   require.NoError(t, err)
@@ -75,19 +107,14 @@ func TestTonSmoke(t *testing.T) {
   var client ton.APIClientWrapped
 
   t.Run("setup:connect", func(t *testing.T) {
-    // Create a connection pool
-    connectionPool := liteclient.NewConnectionPool()
-    
-    // Get the network configuration directly from the embedded config URL
-    // The ExternalHTTPUrl already includes the full path to localhost.global.config.json
-    cfg, cferr := liteclient.GetConfigFromUrl(t.Context(), bc.Nodes[0].ExternalHTTPUrl)
-    require.NoError(t, cferr, "Failed to get config from URL")
-    
-    // Add connections from the config
-    caerr := connectionPool.AddConnectionsFromConfig(t.Context(), cfg)
-    require.NoError(t, caerr, "Failed to add connections from config")
-    
-    // Create an API client with retry functionality
+    // bc.Nodes[0].ExternalHTTPUrl now contains: "liteserver://publickey@host:port"
+    liteserverURL := bc.Nodes[0].ExternalHTTPUrl
+
+    // Create connection pool from liteserver URL
+    connectionPool, err := getConnectionPoolFromLiteserverURL(t.Context(), liteserverURL)
+    require.NoError(t, err, "Failed to create connection pool from liteserver URL")
+
+    // Create API client
     client = ton.NewAPIClient(connectionPool).WithRetry()
 
     t.Run("setup:faucet", func(t *testing.T) {

framework/.changeset/v0.10.23.md

@@ -0,0 +1 @@
+- Fixes TON port mappping, update examples and docs

framework/components/blockchain/ton.go

@@ -2,10 +2,7 @@ package blockchain
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
-	"net/http"
-	"net/url"
 	"strconv"
 	"time"
 
@@ -18,85 +15,28 @@ import (
 )
 
 const (
-	DefaultTonSimpleServerPort = "8000"
 	// NOTE: Prefunded high-load wallet from MyLocalTon pre-funded wallet, that can send up to 254 messages per 1 external message
 	// https://docs.ton.org/v3/documentation/smart-contracts/contracts-specs/highload-wallet#highload-wallet-v2
 	DefaultTonHlWalletAddress  = "-1:5ee77ced0b7ae6ef88ab3f4350d8872c64667ffbe76073455215d3cdfab3294b"
 	DefaultTonHlWalletMnemonic = "twenty unfair stay entry during please water april fabric morning length lumber style tomorrow melody similar forum width ride render void rather custom coin"
-
-	liteServerPortOffset = 100 // internal, arbitrary offset for lite server port
+	// internals
+	defaultTonHTTPServerPort   = "8000"
+	defaultLiteServerPort      = "40000"
+	defaultLiteServerPublicKey = "E7XwFSQzNkcRepUC23J2nRpASXpnsEKmyyHYV4u/FZY="
+	liteServerPortOffset       = 100 // arbitrary offset for lite server port
 )
 
-// TON config structures (e.g.: ton-blockchain.github.io/testnet-global.config.json)
-type tonLiteServer struct {
-	IP   int64 `json:"ip"`
-	Port int   `json:"port"`
-	ID   struct {
-		Key  string `json:"key"`
-		Type string `json:"@type"`
-	} `json:"id"`
-}
-
-type tonConfig struct {
-	LiteServers []tonLiteServer `json:"liteservers"`
-}
-
-// convert int64 IP to string format (matches https://github.com/xssnick/tonutils-go/liteclient/connection.go/intToIP4)
-func intToIP4(ip int64) string {
-	uip := uint32(ip) //nolint:gosec // IP conversion is safe for TON format
-	return fmt.Sprintf("%d.%d.%d.%d",
-		(uip>>24)&0xFF,
-		(uip>>16)&0xFF,
-		(uip>>8)&0xFF,
-		uip&0xFF)
-}
-
-// fetch and parse TON config to generate liteserver URLs
-func fetchTonConfig(configURL string) ([]string, error) {
-	parsedURL, err := url.Parse(configURL)
-	if err != nil {
-		return nil, fmt.Errorf("invalid config URL: %w", err)
-	}
-	if parsedURL.Scheme != "http" && parsedURL.Scheme != "https" {
-		return nil, fmt.Errorf("invalid URL scheme: %s", parsedURL.Scheme)
-	}
-
-	resp, err := http.Get(configURL) //nolint:gosec // URL is validated above
-	if err != nil {
-		return nil, fmt.Errorf("failed to fetch config: %w", err)
-	}
-	defer resp.Body.Close()
-	defer resp.Body.Close()
-
-	var config tonConfig
-	if err := json.NewDecoder(resp.Body).Decode(&config); err != nil {
-		return nil, fmt.Errorf("failed to decode config: %w", err)
-	}
-
-	var liteServerURLs []string
-	for _, ls := range config.LiteServers {
-		ipStr := intToIP4(ls.IP)
-		url := fmt.Sprintf("liteserver://%s@%s:%d", ls.ID.Key, ipStr, ls.Port)
-		liteServerURLs = append(liteServerURLs, url)
-	}
-
-	return liteServerURLs, nil
-}
-
 type portMapping struct {
-	SimpleServer string
-	LiteServer   string
-	DHTServer    string
-	Console      string
-	ValidatorUDP string
+	HTTPServer string
+	LiteServer string
 }
 
 func defaultTon(in *Input) {
 	if in.Image == "" {
 		in.Image = "ghcr.io/neodix42/mylocalton-docker:latest"
 	}
 	if in.Port == "" {
-		in.Port = DefaultTonSimpleServerPort
+		in.Port = defaultTonHTTPServerPort
 	}
 }
 
@@ -109,8 +49,8 @@ func newTon(in *Input) (*Output, error) {
 	}
 
 	ports := &portMapping{
-		SimpleServer: in.Port,
-		LiteServer:   strconv.Itoa(base + liteServerPortOffset),
+		HTTPServer: in.Port,
+		LiteServer: strconv.Itoa(base + liteServerPortOffset),
 	}
 
 	ctx := context.Background()
@@ -125,12 +65,14 @@ func newTon(in *Input) (*Output, error) {
 	networkName := network.Name
 
 	baseEnv := map[string]string{
-		"GENESIS":                        "true",
-		"NAME":                           "genesis",
-		"LITE_PORT":                      ports.LiteServer,
-		"CUSTOM_PARAMETERS":              "--state-ttl 315360000 --archive-ttl 315360000",
+		"GENESIS": "true",
+		"NAME":    "genesis",
+
 		"EMBEDDED_FILE_HTTP_SERVER":      "true",
-		"EMBEDDED_FILE_HTTP_SERVER_PORT": in.Port,
+		"EMBEDDED_FILE_HTTP_SERVER_PORT": defaultTonHTTPServerPort,
+		"LITE_PORT":                      defaultLiteServerPort,
+
+		"CUSTOM_PARAMETERS": "--state-ttl 315360000 --archive-ttl 315360000",
 	}
 
 	// merge with additional environment variables from input
@@ -146,8 +88,8 @@ func newTon(in *Input) (*Output, error) {
 		AlwaysPullImage: in.PullImage,
 		Name:            framework.DefaultTCName("ton-genesis"),
 		ExposedPorts: []string{
-			fmt.Sprintf("%s:%s/tcp", ports.SimpleServer, DefaultTonSimpleServerPort),
-			fmt.Sprintf("%s:%s/tcp", ports.LiteServer, ports.LiteServer),
+			fmt.Sprintf("%s:%s/tcp", ports.HTTPServer, defaultTonHTTPServerPort),
+			fmt.Sprintf("%s:%s/tcp", ports.LiteServer, defaultLiteServerPort),
 			"40003/udp",
 			"40002/tcp",
 			"40001/udp",
@@ -158,8 +100,8 @@ func newTon(in *Input) (*Output, error) {
 		Env:            finalEnv,
 		WaitingFor: wait.ForExec([]string{
 			"/usr/local/bin/lite-client",
-			"-a", fmt.Sprintf("127.0.0.1:%s", ports.LiteServer),
-			"-b", "E7XwFSQzNkcRepUC23J2nRpASXpnsEKmyyHYV4u/FZY=",
+			"-a", fmt.Sprintf("127.0.0.1:%s", defaultLiteServerPort),
+			"-b", defaultLiteServerPublicKey,
 			"-t", "3", "-c", "last",
 		}).WithStartupTimeout(2 * time.Minute),
 		Mounts: testcontainers.ContainerMounts{
@@ -185,23 +127,16 @@ func newTon(in *Input) (*Output, error) {
 		return nil, err
 	}
 
-	name, err := c.Name(ctx)
+	host, err := c.Host(ctx)
 	if err != nil {
 		return nil, err
 	}
 
-	// fetch config and generate liteserver URLs from actual config
-	configURL := fmt.Sprintf("http://localhost:%s/localhost.global.config.json", ports.SimpleServer)
-
-	liteServerURLs, err := fetchTonConfig(configURL)
+	name, err := c.Name(ctx)
 	if err != nil {
 		return nil, err
 	}
 
-	if len(liteServerURLs) == 0 {
-		return nil, fmt.Errorf("no liteservers found in config")
-	}
-
 	return &Output{
 		UseCache:      true,
 		ChainID:       in.ChainID,
@@ -211,8 +146,8 @@ func newTon(in *Input) (*Output, error) {
 		Container:     c,
 		Nodes: []*Node{{
 			// URLs now contain liteserver://publickey@host:port
-			ExternalHTTPUrl: liteServerURLs[0],
-			InternalHTTPUrl: liteServerURLs[0],
+			ExternalHTTPUrl: fmt.Sprintf("liteserver://%s@%s:%s", defaultLiteServerPublicKey, host, ports.LiteServer),
+			InternalHTTPUrl: fmt.Sprintf("liteserver://%s@%s:%s", defaultLiteServerPublicKey, name, ports.LiteServer),
 		}},
 	}, nil
 }

framework/examples/myproject/smoke_ton.toml

@@ -1,6 +1,6 @@
 [blockchain_a]
   type = "ton"
   image = "ghcr.io/neodix42/mylocalton-docker:v3.7"
-  port = "8000"
+  port = "9000"
 
   [blockchain_a.custom_env]