Extend cldf timelock converter logic for TON

chain/ton/provider/ctf_provider.go

@@ -13,7 +13,6 @@ import (
 	"github.com/avast/retry-go/v4"
 	"github.com/testcontainers/testcontainers-go"
 
-	"github.com/xssnick/tonutils-go/address"
 	"github.com/xssnick/tonutils-go/tlb"
 	"github.com/xssnick/tonutils-go/ton"
 	"github.com/xssnick/tonutils-go/ton/wallet"
@@ -34,6 +33,9 @@ const (
 
 	// supportedTONImageRepository is the only supported Docker image repository for TON localnet.
 	supportedTONImageRepository = "ghcr.io/neodix42/mylocalton-docker"
+
+	// defaultTxTONAmount is the default amount of TON to use for transactions.
+	defaultTxTONAmount = "0.1"
 )
 
 // CTFChainProviderConfig holds the configuration to initialize the CTFChainProvider.
@@ -122,18 +124,15 @@ func (p *CTFChainProvider) Initialize(ctx context.Context) (chain.BlockChain, er
 		return nil, fmt.Errorf("failed to create wallet: %w", err)
 	}
 
-	// airdrop the deployer wallet
-	ferr := fundTonWallets(ctx, nodeClient, []*address.Address{tonWallet.Address()}, []tlb.Coins{tlb.MustFromTON("1000")})
-	if ferr != nil {
-		return nil, fmt.Errorf("failed to fund wallet: %w", ferr)
-	}
-
 	p.chain = &cldf_ton.Chain{
 		ChainMetadata: cldf_ton.ChainMetadata{Selector: p.selector},
 		Client:        nodeClient,
-		Wallet:        tonWallet,
-		WalletAddress: tonWallet.Address(),
+		WalletAddress: tonWallet.WalletAddress(),
 		URL:           url,
+		TxOps: cldf_ton.TxOps{
+			Wallet: tonWallet,
+			Amount: tlb.MustFromTON(defaultTxTONAmount), // default amount for transactions
+		},
 	}
 
 	return *p.chain, nil
@@ -220,54 +219,6 @@ func createTonWallet(client ton.APIClientWrapped, versionConfig wallet.VersionCo
 	return pw, nil
 }
 
-func fundTonWallets(ctx context.Context, client ton.APIClientWrapped, recipients []*address.Address, amounts []tlb.Coins) error {
-	if len(amounts) != len(recipients) {
-		return errors.New("recipients and amounts must have the same length")
-	}
-
-	// initialize the prefunded wallet(Highload-V2), for other wallets, see https://github.com/neodix42/mylocalton-docker#pre-installed-wallets
-	version := wallet.HighloadV2Verified //nolint:staticcheck // SA1019: only available option in mylocalton-docker
-	rawHlWallet, err := wallet.FromSeed(client, strings.Fields(blockchain.DefaultTonHlWalletMnemonic), version)
-	if err != nil {
-		return fmt.Errorf("failed to create wallet from seed: %w", err)
-	}
-
-	mcFunderWallet, err := wallet.FromPrivateKeyWithOptions(client, rawHlWallet.PrivateKey(), version, wallet.WithWorkchain(-1))
-	if err != nil {
-		return fmt.Errorf("failed to create wallet from private key: %w", err)
-	}
-
-	funder, err := mcFunderWallet.GetSubwallet(uint32(42))
-	if err != nil {
-		return fmt.Errorf("failed to get subwallet: %w", err)
-	}
-
-	// double check funder address
-	if funder.Address().StringRaw() != blockchain.DefaultTonHlWalletAddress {
-		return fmt.Errorf("funder address mismatch: %s != %s", funder.Address().StringRaw(), blockchain.DefaultTonHlWalletAddress)
-	}
-
-	// create transfer messages for each recipient
-	messages := make([]*wallet.Message, len(recipients))
-	for i, addr := range recipients {
-		transfer, terr := funder.BuildTransfer(addr, amounts[i], false, "")
-		if terr != nil {
-			return fmt.Errorf("failed to build transfer: %w", terr)
-		}
-		messages[i] = transfer
-	}
-
-	// we don't wait for the transaction to be confirmed here, as it may take some time
-	// the name SendManyWaitTransaction is misleading, it doesn't wait for the transaction to be confirmed,
-	// it just sends the transactions(TON has asynchronous transactions)
-	_, _, txerr := funder.SendManyWaitTransaction(ctx, messages)
-	if txerr != nil {
-		return fmt.Errorf("failed to send many wait transaction: %w", txerr)
-	}
-
-	return nil
-}
-
 func getMasterchainBlockID(ctx context.Context, client ton.APIClientWrapped) (*ton.BlockIDExt, error) {
 	var masterchainBlockID *ton.BlockIDExt
 	// check connection, CTFv2 handles the readiness

chain/ton/provider/ctf_provider_test.go

@@ -88,7 +88,7 @@ func Test_CTFChainProvider_Initialize(t *testing.T) {
 				require.True(t, ok, "expected got to be of type ton.Chain")
 				assert.Equal(t, tt.giveSelector, gotChain.Selector)
 				assert.NotEmpty(t, gotChain.Client)
-				assert.NotEmpty(t, gotChain.Wallet)
+				assert.NotEmpty(t, gotChain.TxOps)
 				assert.NotEmpty(t, gotChain.WalletAddress)
 			}
 		})

chain/ton/provider/rpc_provider.go

@@ -7,6 +7,7 @@ import (
 	"strings"
 
 	"github.com/xssnick/tonutils-go/liteclient"
+	"github.com/xssnick/tonutils-go/tlb"
 	tonlib "github.com/xssnick/tonutils-go/ton"
 	"github.com/xssnick/tonutils-go/ton/wallet"
 
@@ -22,6 +23,8 @@ const (
 	WalletVersionV4R2    WalletVersion = "V4R2"
 	WalletVersionV5R1    WalletVersion = "V5R1"
 	WalletVersionDefault WalletVersion = ""
+
+	defaultAmountTonString = "0.1" // Default amount in TON for transactions
 )
 
 // RPCChainProviderConfig holds the configuration to initialize the RPCChainProvider.
@@ -173,17 +176,26 @@ func (p *RPCChainProvider) Initialize(ctx context.Context) (chain.BlockChain, er
 		return nil, err
 	}
 
-	p.chain = &ton.Chain{
+	p.chain = buildChain(p.selector, api, tonWallet, p.config.HTTPURL)
+
+	return *p.chain, nil
+}
+
+// buildChain creates a ton.Chain with the given parameters and default TxOps amount.
+func buildChain(selector uint64, api *tonlib.APIClient, tonWallet *wallet.Wallet, httpURL string) *ton.Chain {
+	return &ton.Chain{
 		ChainMetadata: ton.ChainMetadata{
-			Selector: p.selector,
+			Selector: selector,
 		},
 		Client:        api,
 		Wallet:        tonWallet,
 		WalletAddress: tonWallet.WalletAddress(),
-		URL:           p.config.HTTPURL,
+		URL:           httpURL,
+		TxOps: ton.TxOps{
+			Wallet: tonWallet,
+			Amount: tlb.MustFromTON(defaultAmountTonString),
+		},
 	}
-
-	return *p.chain, nil
 }
 
 // createLiteclientConnectionPool creates connection pool returning concrete type for production use

chain/ton/provider/rpc_provider_test.go

@@ -5,6 +5,8 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"github.com/xssnick/tonutils-go/tlb"
+	"github.com/xssnick/tonutils-go/ton/wallet"
 
 	tonchain "github.com/smartcontractkit/chainlink-deployments-framework/chain/ton"
 )
@@ -89,6 +91,22 @@ func Test_RPCChainProvider_Initialize(t *testing.T) {
 	assert.Equal(t, existingChain.Selector, gotChain.Selector)
 }
 
+func Test_RPCChainProvider_Initialize_InvalidConfig(t *testing.T) {
+	t.Parallel()
+
+	p := &RPCChainProvider{
+		selector: 123,
+		config: RPCChainProviderConfig{
+			HTTPURL:           "", // invalid - missing URL
+			DeployerSignerGen: PrivateKeyRandom(),
+		},
+	}
+
+	_, err := p.Initialize(t.Context())
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "failed to validate provider config")
+}
+
 func Test_RPCChainProvider_Name(t *testing.T) {
 	t.Parallel()
 
@@ -278,6 +296,35 @@ func Test_createWallet(t *testing.T) {
 	}
 }
 
+func Test_buildChain(t *testing.T) {
+	t.Parallel()
+
+	// Create a test wallet using a fixed private key
+	privateKey := make([]byte, 32)
+	for i := range privateKey {
+		privateKey[i] = byte(i)
+	}
+	testWallet, err := wallet.FromPrivateKeyWithOptions(nil, privateKey, wallet.V4R2, wallet.WithWorkchain(0))
+	require.NoError(t, err)
+
+	selector := uint64(789)
+	httpURL := "liteserver://publickey@localhost:8080"
+
+	chain := buildChain(selector, nil, testWallet, httpURL)
+
+	require.NotNil(t, chain)
+	assert.Equal(t, selector, chain.Selector)
+	assert.Equal(t, httpURL, chain.URL)
+	assert.Nil(t, chain.Client)
+	assert.Equal(t, testWallet, chain.Wallet)
+	assert.Equal(t, testWallet.WalletAddress(), chain.WalletAddress)
+
+	// Verify TxOps uses the default amount (0.1 TON)
+	expectedAmount := tlb.MustFromTON("0.1")
+	assert.Equal(t, expectedAmount, chain.TxOps.Amount)
+	assert.Equal(t, testWallet, chain.TxOps.Wallet)
+}
+
 func Test_createLiteclientConnectionPool_InvalidURL(t *testing.T) {
 	t.Parallel()
 

chain/ton/ton_chain.go

@@ -5,16 +5,25 @@ import (
 	"github.com/xssnick/tonutils-go/ton"
 	"github.com/xssnick/tonutils-go/ton/wallet"
 
+	"github.com/xssnick/tonutils-go/tlb"
+
 	"github.com/smartcontractkit/chainlink-deployments-framework/chain/internal/common"
 )
 
 type ChainMetadata = common.ChainMetadata
 
+// TxOps holds configuration for transaction operations.
+type TxOps struct {
+	Wallet *wallet.Wallet // Wallet abstraction (signing, sending)
+	Amount tlb.Coins      // Default amount for msg transfers
+}
+
 // Chain represents a TON chain.
 type Chain struct {
 	ChainMetadata                  // Contains canonical chain identifier
 	Client        *ton.APIClient   // APIClient for Lite Server connection
 	Wallet        *wallet.Wallet   // Wallet abstraction (signing, sending)
 	WalletAddress *address.Address // Address of deployer wallet
 	URL           string           // Liteserver URL
+	TxOps         TxOps            // Transaction operations configuration
 }

engine/cld/legacy/cli/mcmsv2/mcms_v2.go

@@ -28,6 +28,7 @@ import (
 	"github.com/smartcontractkit/mcms/sdk/evm/bindings"
 	"github.com/smartcontractkit/mcms/sdk/solana"
 	"github.com/smartcontractkit/mcms/sdk/sui"
+	"github.com/smartcontractkit/mcms/sdk/ton"
 	"github.com/smartcontractkit/mcms/types"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
@@ -1183,6 +1184,8 @@ func newCfgv2(lggr logger.Logger, cmd *cobra.Command, domain cldf_domain.Domain,
 				if err != nil {
 					return nil, fmt.Errorf("error creating Sui timelock converter: %w", err)
 				}
+			case chainsel.FamilyTon:
+				converter = ton.NewTimelockConverter()
 			default:
 				return nil, fmt.Errorf("unsupported chain family %s", fam)
 			}
@@ -1489,18 +1492,18 @@ func getExecutorWithChainOverride(cfg *cfgv2, chainSelector types.ChainSelector)
 		if !ok {
 			return nil, fmt.Errorf("invalid encoder type: %T", encoder)
 		}
-		chain := cfg.blockchains.EVMChains()[uint64(chainSelector)]
+		c := cfg.blockchains.EVMChains()[uint64(chainSelector)]
 
-		return evm.NewExecutor(evmEncoder, chain.Client, chain.DeployerKey), nil
+		return evm.NewExecutor(evmEncoder, c.Client, c.DeployerKey), nil
 
 	case chainsel.FamilySolana:
 		solanaEncoder, ok := encoder.(*solana.Encoder)
 		if !ok {
 			return nil, fmt.Errorf("invalid encoder type: %T", encoder)
 		}
-		chain := cfg.blockchains.SolanaChains()[uint64(chainSelector)]
+		c := cfg.blockchains.SolanaChains()[uint64(chainSelector)]
 
-		return solana.NewExecutor(solanaEncoder, chain.Client, *chain.DeployerKey), nil
+		return solana.NewExecutor(solanaEncoder, c.Client, *c.DeployerKey), nil
 
 	case chainsel.FamilyAptos:
 		encoder, ok := encoder.(*aptos.Encoder)
@@ -1511,9 +1514,9 @@ func getExecutorWithChainOverride(cfg *cfgv2, chainSelector types.ChainSelector)
 		if err != nil {
 			return nil, fmt.Errorf("error getting aptos role from proposal: %w", err)
 		}
-		chain := cfg.blockchains.AptosChains()[uint64(chainSelector)]
+		c := cfg.blockchains.AptosChains()[uint64(chainSelector)]
 
-		return aptos.NewExecutor(chain.Client, chain.DeployerSigner, encoder, *role), nil
+		return aptos.NewExecutor(c.Client, c.DeployerSigner, encoder, *role), nil
 
 	case chainsel.FamilySui:
 		encoder, ok := encoder.(*sui.Encoder)
@@ -1524,10 +1527,18 @@ func getExecutorWithChainOverride(cfg *cfgv2, chainSelector types.ChainSelector)
 		if err != nil {
 			return nil, fmt.Errorf("error getting sui metadata from proposal: %w", err)
 		}
-		chain := cfg.blockchains.SuiChains()[uint64(chainSelector)]
+		c := cfg.blockchains.SuiChains()[uint64(chainSelector)]
 		entrypointEncoder := suibindings.NewCCIPEntrypointArgEncoder(metadata.RegistryObj, metadata.DeployerStateObj)
 
-		return sui.NewExecutor(chain.Client, chain.Signer, encoder, entrypointEncoder, metadata.McmsPackageID, metadata.Role, cfg.timelockProposal.ChainMetadata[chainSelector].MCMAddress, metadata.AccountObj, metadata.RegistryObj, metadata.TimelockObj)
+		return sui.NewExecutor(c.Client, c.Signer, encoder, entrypointEncoder, metadata.McmsPackageID, metadata.Role, cfg.timelockProposal.ChainMetadata[chainSelector].MCMAddress, metadata.AccountObj, metadata.RegistryObj, metadata.TimelockObj)
+	case chainsel.FamilyTon:
+		encoder, ok := encoder.(*ton.Encoder)
+		if !ok {
+			return nil, fmt.Errorf("error getting encoder for chain %d", cfg.chainSelector)
+		}
+		c := cfg.blockchains.TonChains()[uint64(chainSelector)]
+
+		return ton.NewExecutor(encoder, c.Client, c.TxOps.Wallet, c.TxOps.Amount)
 	default:
 		return nil, fmt.Errorf("unsupported chain family %s", family)
 	}
@@ -1557,26 +1568,29 @@ func getTimelockExecutorWithChainOverride(cfg *cfgv2, chainSelector types.ChainS
 	var executor sdk.TimelockExecutor
 	switch family {
 	case chainsel.FamilyEVM:
-		chain := cfg.blockchains.EVMChains()[uint64(chainSelector)]
+		c := cfg.blockchains.EVMChains()[uint64(chainSelector)]
 
-		executor = evm.NewTimelockExecutor(chain.Client, chain.DeployerKey)
+		executor = evm.NewTimelockExecutor(c.Client, c.DeployerKey)
 	case chainsel.FamilySolana:
-		chain := cfg.blockchains.SolanaChains()[uint64(chainSelector)]
-		executor = solana.NewTimelockExecutor(chain.Client, *chain.DeployerKey)
+		c := cfg.blockchains.SolanaChains()[uint64(chainSelector)]
+		executor = solana.NewTimelockExecutor(c.Client, *c.DeployerKey)
 	case chainsel.FamilyAptos:
-		chain := cfg.blockchains.AptosChains()[uint64(chainSelector)]
-		executor = aptos.NewTimelockExecutor(chain.Client, chain.DeployerSigner)
+		c := cfg.blockchains.AptosChains()[uint64(chainSelector)]
+		executor = aptos.NewTimelockExecutor(c.Client, c.DeployerSigner)
 	case chainsel.FamilySui:
-		chain := cfg.blockchains.SuiChains()[uint64(chainSelector)]
+		c := cfg.blockchains.SuiChains()[uint64(chainSelector)]
 		metadata, err := suiMetadataFromProposal(chainSelector, cfg.timelockProposal)
 		if err != nil {
 			return nil, fmt.Errorf("error getting sui metadata from proposal: %w", err)
 		}
 		entrypointEncoder := suibindings.NewCCIPEntrypointArgEncoder(metadata.AccountObj, metadata.DeployerStateObj)
-		executor, err = sui.NewTimelockExecutor(chain.Client, chain.Signer, entrypointEncoder, metadata.McmsPackageID, metadata.RegistryObj, metadata.AccountObj)
+		executor, err = sui.NewTimelockExecutor(c.Client, c.Signer, entrypointEncoder, metadata.McmsPackageID, metadata.RegistryObj, metadata.AccountObj)
 		if err != nil {
 			return nil, fmt.Errorf("error creating sui timelock executor: %w", err)
 		}
+	case chainsel.FamilyTon:
+		c := cfg.blockchains.TonChains()[uint64(chainSelector)]
+		return ton.NewTimelockExecutor(c.Client, c.TxOps.Wallet, c.TxOps.Amount)
 	default:
 		return nil, fmt.Errorf("unsupported chain family %s", family)
 	}
@@ -1631,6 +1645,9 @@ var getInspectorFromChainSelector = func(cfg cfgv2) (sdk.Inspector, error) {
 		if err != nil {
 			return nil, fmt.Errorf("error creating sui inspector: %w", err)
 		}
+	case chainsel.FamilyTon:
+		chain := cfg.blockchains.TonChains()[cfg.chainSelector]
+		inspector = ton.NewInspector(chain.Client)
 	default:
 		return nil, fmt.Errorf("unsupported chain family %s", fam)
 	}