Add sdk/ton/timelock_executor_test.go

Author: krebernisak

sdk/ton/timelock_converter_test.go

@@ -7,14 +7,17 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	cselectors "github.com/smartcontractkit/chain-selectors"
+
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+
 	"github.com/xssnick/tonutils-go/address"
 	"github.com/xssnick/tonutils-go/tvm/cell"
 
 	sdkerrors "github.com/smartcontractkit/mcms/sdk/errors"
-	"github.com/smartcontractkit/mcms/sdk/ton"
 	"github.com/smartcontractkit/mcms/types"
+
+	"github.com/smartcontractkit/mcms/sdk/ton"
 )
 
 func TestTimelockConverter_ConvertBatchToChainOperation(t *testing.T) {

sdk/ton/timelock_executor.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/hex"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"math/rand/v2"
 
@@ -35,15 +36,19 @@ type timelockExecutor struct {
 }
 
 // NewTimelockExecutor creates a new TimelockExecutor
-func NewTimelockExecutor(client ton.APIClientWrapped, wallet *wallet.Wallet, amount tlb.Coins) sdk.TimelockExecutor {
+func NewTimelockExecutor(client ton.APIClientWrapped, wallet *wallet.Wallet, amount tlb.Coins) (sdk.TimelockExecutor, error) {
+	if IsNil(client) {
+		return nil, errors.New("failed to create sdk.Executor - client (ton.APIClientWrapped) is nil")
+	}
+
 	return &timelockExecutor{
 		TimelockInspector: NewTimelockInspector(client),
 		wallet:            wallet,
 		amount:            amount,
-	}
+	}, nil
 }
 
-func (t *timelockExecutor) Execute(
+func (e *timelockExecutor) Execute(
 	ctx context.Context, bop types.BatchOperation, timelockAddress string, predecessor common.Hash, salt common.Hash,
 ) (types.TransactionResult, error) {
 	// Map to Ton Address type
@@ -95,13 +100,13 @@ func (t *timelockExecutor) Execute(
 			IHRDisabled: true,
 			Bounce:      true,
 			DstAddr:     dstAddr,
-			Amount:      t.amount,
+			Amount:      e.amount,
 			Body:        body,
 		},
 	}
 
 	// TODO: do we wait for execution trace?
-	tx, _, err := t.wallet.SendWaitTransaction(ctx, msg)
+	tx, _, err := e.wallet.SendWaitTransaction(ctx, msg)
 	if err != nil {
 		return types.TransactionResult{}, fmt.Errorf("failed to execute batch: %w", err)
 	}

sdk/ton/timelock_executor_test.go

@@ -0,0 +1,150 @@
+package ton_test
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"math/big"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+
+	"github.com/xssnick/tonutils-go/tlb"
+	"github.com/xssnick/tonutils-go/ton"
+	"github.com/xssnick/tonutils-go/tvm/cell"
+
+	"github.com/ethereum/go-ethereum/common"
+
+	"github.com/smartcontractkit/mcms/internal/testutils/chaintest"
+	"github.com/smartcontractkit/mcms/types"
+
+	tonmcms "github.com/smartcontractkit/mcms/sdk/ton"
+	ton_mocks "github.com/smartcontractkit/mcms/sdk/ton/mocks"
+)
+
+func TestNewTimelockExecutor(t *testing.T) {
+	t.Parallel()
+
+	chainID := chaintest.Chain7ToniID
+
+	_api := ton_mocks.NewTonAPI(t)
+	walletOperator := must(makeRandomTestWallet(_api, chainID))
+	client := ton_mocks.NewAPIClientWrapped(t)
+
+	executor, err := tonmcms.NewTimelockExecutor(client, walletOperator, tlb.MustFromTON("0"))
+	assert.NotNil(t, executor, "expected Executor")
+	assert.NoError(t, err)
+}
+
+func TestTimelockExecutor_Execute(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+
+	sharedMockSetup := func(api *ton_mocks.TonAPI, client *ton_mocks.APIClientWrapped) {
+		// Mock CurrentMasterchainInfo
+		api.EXPECT().CurrentMasterchainInfo(mock.Anything).
+			Return(&ton.BlockIDExt{}, nil)
+
+		// Mock WaitForBlock
+		client.EXPECT().GetAccount(mock.Anything, mock.Anything, mock.Anything).
+			Return(&tlb.Account{}, nil)
+
+		client.EXPECT().RunGetMethod(mock.Anything, mock.Anything, mock.Anything, mock.Anything).
+			Return(ton.NewExecutionResult([]any{big.NewInt(5)}), nil)
+
+		api.EXPECT().WaitForBlock(mock.Anything).
+			Return(client)
+	}
+
+	tests := []struct {
+		name            string
+		timelockAddress string
+		bop             types.BatchOperation
+		predecessor     common.Hash
+		salt            common.Hash
+		mockSetup       func(api *ton_mocks.TonAPI, client *ton_mocks.APIClientWrapped)
+		wantTxHash      string
+		wantErr         error
+	}{
+		{
+			name: "success",
+			// auth:            mockAuth,
+			timelockAddress: "EQADa3W6G0nSiTV4a6euRA42fU9QxSEnb-WeDpcrtWzA2jM8",
+			bop: types.BatchOperation{
+				ChainSelector: chaintest.Chain7Selector,
+				Transactions: []types.Transaction{
+					{
+						To:               "EQADa3W6G0nSiTV4a6euRA42fU9QxSEnb-WeDpcrtWzA2jM8",
+						Data:             cell.BeginCell().MustStoreBinarySnake([]byte{1, 2, 3}).EndCell().ToBOC(),
+						AdditionalFields: json.RawMessage(`{"value": 0}`)},
+				},
+			},
+			mockSetup: func(api *ton_mocks.TonAPI, client *ton_mocks.APIClientWrapped) {
+				// Successful tx send
+				sharedMockSetup(api, client)
+
+				// Mock SendTransaction to return (no error)
+				api.EXPECT().SendExternalMessageWaitTransaction(mock.Anything, mock.Anything).
+					Return(&tlb.Transaction{Hash: []byte{1, 2, 3, 4, 14}}, &ton.BlockIDExt{}, []byte{}, nil)
+
+			},
+			wantTxHash: "010203040e",
+			wantErr:    nil,
+		},
+		{
+			name: "failure in tx execution",
+			// auth:            mockAuth,
+			timelockAddress: "EQADa3W6G0nSiTV4a6euRA42fU9QxSEnb-WeDpcrtWzA2jM8",
+			bop: types.BatchOperation{
+				ChainSelector: chaintest.Chain7Selector,
+				Transactions: []types.Transaction{
+					{
+						To:               "EQADa3W6G0nSiTV4a6euRA42fU9QxSEnb-WeDpcrtWzA2jM8",
+						Data:             cell.BeginCell().MustStoreBinarySnake([]byte{1, 2, 3}).EndCell().ToBOC(),
+						AdditionalFields: json.RawMessage(`{"value": 0}`)},
+				},
+			},
+			mockSetup: func(api *ton_mocks.TonAPI, client *ton_mocks.APIClientWrapped) {
+				// Error tx send
+				sharedMockSetup(api, client)
+
+				// Mock SendTransaction to return an error
+				api.EXPECT().SendExternalMessageWaitTransaction(mock.Anything, mock.Anything).
+					Return(&tlb.Transaction{Hash: []byte{1, 2, 3, 4, 14}}, &ton.BlockIDExt{}, []byte{}, errors.New("error during tx send"))
+			},
+			wantTxHash: "",
+			wantErr:    fmt.Errorf("failed to execute batch: error during tx send"),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			// Initialize the mock
+			chainID := chaintest.Chain7ToniID
+			_api := ton_mocks.NewTonAPI(t)
+			walletOperator := must(makeRandomTestWallet(_api, chainID))
+
+			client := ton_mocks.NewAPIClientWrapped(t)
+
+			if tt.mockSetup != nil {
+				tt.mockSetup(_api, client)
+			}
+
+			executor, err := tonmcms.NewTimelockExecutor(client, walletOperator, tlb.MustFromTON("0"))
+			assert.NoError(t, err)
+
+			tx, err := executor.Execute(ctx, tt.bop, tt.timelockAddress, tt.predecessor, tt.salt)
+			assert.Equal(t, tt.wantTxHash, tx.Hash)
+			if tt.wantErr != nil {
+				assert.EqualError(t, err, tt.wantErr.Error())
+			} else {
+				assert.NoError(t, err)
+			}
+		})
+	}
+}

types/signature_test.go

@@ -132,7 +132,7 @@ func Test_Recover(t *testing.T) {
 				V: 1,
 			},
 			giveHash: hash,
-			wantErr:  "recovery failed",
+			wantErr:  "failed to recover public key: recovery failed",
 		},
 	}