@tonappchain/sdk 0.7.2-payload-builder-0.1 → 0.7.2-payload-builder-0.3

package/dist/src/index.d.ts

@@ -10,7 +10,6 @@ export { LiteSequencerClient } from './sdk/LiteSequencerClient';
 export { ConsoleLogger, NoopLogger } from './sdk/Logger';
 export { OperationTracker } from './sdk/OperationTracker';
 export { Simulator } from './sdk/Simulator';
-export { startTracking, startTrackingMultiple } from './sdk/StartTracking';
 export { TacSdk } from './sdk/TacSdk';
 export { TACTransactionManager } from './sdk/TACTransactionManager';
 export { TONTransactionManager } from './sdk/TONTransactionManager';

package/dist/src/index.js

@@ -36,7 +36,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TONTransactionManager = exports.TACTransactionManager = exports.TacSdk = exports.startTrackingMultiple = exports.startTracking = exports.Simulator = exports.OperationTracker = exports.NoopLogger = exports.ConsoleLogger = exports.LiteSequencerClient = exports.Configuration = exports.AxiosHttpClient = exports.AgnosticStructs = exports.AgnosticProxySDK = void 0;
+exports.TONTransactionManager = exports.TACTransactionManager = exports.TacSdk = exports.Simulator = exports.OperationTracker = exports.NoopLogger = exports.ConsoleLogger = exports.LiteSequencerClient = exports.Configuration = exports.AxiosHttpClient = exports.AgnosticStructs = exports.AgnosticProxySDK = void 0;
 __exportStar(require("./adapters"), exports);
 var AgnosticSdk_1 = require("./agnosticSdk/AgnosticSdk");
 Object.defineProperty(exports, "AgnosticProxySDK", { enumerable: true, get: function () { return AgnosticSdk_1.AgnosticProxySDK; } });
@@ -57,9 +57,6 @@ var OperationTracker_1 = require("./sdk/OperationTracker");
 Object.defineProperty(exports, "OperationTracker", { enumerable: true, get: function () { return OperationTracker_1.OperationTracker; } });
 var Simulator_1 = require("./sdk/Simulator");
 Object.defineProperty(exports, "Simulator", { enumerable: true, get: function () { return Simulator_1.Simulator; } });
-var StartTracking_1 = require("./sdk/StartTracking");
-Object.defineProperty(exports, "startTracking", { enumerable: true, get: function () { return StartTracking_1.startTracking; } });
-Object.defineProperty(exports, "startTrackingMultiple", { enumerable: true, get: function () { return StartTracking_1.startTrackingMultiple; } });
 var TacSdk_1 = require("./sdk/TacSdk");
 Object.defineProperty(exports, "TacSdk", { enumerable: true, get: function () { return TacSdk_1.TacSdk; } });
 var TACTransactionManager_1 = require("./sdk/TACTransactionManager");

package/dist/src/interfaces/ContractOpener.d.ts

@@ -1,5 +1,6 @@
 import { SandboxContract } from '@ton/sandbox';
-import type { Address, Contract, OpenedContract } from '@ton/ton';
+import type { Address, Contract, OpenedContract, Transaction } from '@ton/ton';
+import { AddressInformation, GetTransactionsOptions } from '../structs/InternalStruct';
 import { ContractState } from '../structs/Struct';
 export interface ContractOpener {
     /**
@@ -18,4 +19,7 @@ export interface ContractOpener {
      * Closes any underlying connections if supported by the implementation.
      */
     closeConnections?: () => unknown;
+    getTransactionByHash(address: Address, hash: string, opts?: GetTransactionsOptions): Promise<Transaction | null>;
+    getAdjacentTransactions(address: Address, hash: string, opts?: GetTransactionsOptions): Promise<Transaction[]>;
+    getAddressInformation(address: Address): Promise<AddressInformation>;
 }

package/dist/src/interfaces/ITxFinalizer.d.ts

@@ -0,0 +1,5 @@
+export interface ITxFinalizer {
+    trackTransactionTree(address: string, hash: string, params: {
+        maxDepth?: number;
+    }): Promise<void>;
+}

package/dist/src/interfaces/ITxFinalizer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/interfaces/WalletInstanse.d.ts

@@ -1,20 +1,16 @@
-import type { Contract, ContractProvider, MessageRelaxed, SendMode } from '@ton/ton';
+import type { Cell, Contract, ContractProvider, MessageRelaxed, SendMode } from '@ton/ton';
 export interface WalletInstanse extends Contract {
     /**
      * Returns current wallet seqno, used for nonce/ordering.
      * @param provider Contract provider to query the wallet.
      */
     getSeqno(provider: ContractProvider): Promise<number>;
-    /**
-     * Sends a transfer with specified messages and send mode.
-     * @param provider Contract provider used to send the transfer.
-     * @param args Transfer arguments including seqno, secretKey, messages and sendMode.
-     */
-    sendTransfer(provider: ContractProvider, args: {
+    send(provider: ContractProvider, msg: Cell): Promise<string | void>;
+    createTransfer(args: {
         seqno: number;
         secretKey: Buffer;
         messages: MessageRelaxed[];
         sendMode: SendMode;
         timeout?: number;
-    }): Promise<void>;
+    }): Cell;
 }

package/dist/src/sdk/StartTracking.d.ts

@@ -1,5 +1,5 @@
 import { ILogger } from '../interfaces';
-import { TxFinalizerConfig } from '../structs/InternalStruct';
+import { ITxFinalizer } from '../interfaces/ITxFinalizer';
 import { ExecutionStages, Network, TransactionLinker } from '../structs/Struct';
 export declare function startTracking(transactionLinker: TransactionLinker, network: Network, options?: {
     customLiteSequencerEndpoints?: string[];
@@ -7,8 +7,9 @@ export declare function startTracking(transactionLinker: TransactionLinker, netw
     maxIterationCount?: number;
     returnValue?: boolean;
     tableView?: boolean;
-    txFinalizerConfig?: TxFinalizerConfig;
     logger?: ILogger;
+    txFinalizer?: ITxFinalizer;
+    cclAddress?: string;
 }): Promise<void | ExecutionStages>;
 export declare function startTrackingMultiple(transactionLinkers: TransactionLinker[], network: Network, options?: {
     customLiteSequencerEndpoints?: string[];
@@ -16,6 +17,7 @@ export declare function startTrackingMultiple(transactionLinkers: TransactionLin
     maxIterationCount?: number;
     returnValue?: boolean;
     tableView?: boolean;
-    txFinalizerConfig?: TxFinalizerConfig;
     logger?: ILogger;
+    txFinalizer?: ITxFinalizer;
 }): Promise<void | ExecutionStages[]>;
+export declare function printExecutionStagesTable(stages: ExecutionStages, logger: ILogger): void;

package/dist/src/sdk/StartTracking.js

@@ -1,19 +1,15 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startTracking = startTracking;
 exports.startTrackingMultiple = startTrackingMultiple;
-const cli_table3_1 = __importDefault(require("cli-table3"));
+exports.printExecutionStagesTable = printExecutionStagesTable;
 const Struct_1 = require("../structs/Struct");
 const Consts_1 = require("./Consts");
 const Logger_1 = require("./Logger");
 const OperationTracker_1 = require("./OperationTracker");
-const TxFinalizer_1 = require("./TxFinalizer");
 const Utils_1 = require("./Utils");
 async function startTracking(transactionLinker, network, options) {
-    const { customLiteSequencerEndpoints, delay = 10, maxIterationCount = Consts_1.MAX_ITERATION_COUNT, returnValue = false, tableView = true, txFinalizerConfig, logger = new Logger_1.NoopLogger(), } = options || {};
+    const { customLiteSequencerEndpoints, delay = 10, maxIterationCount = Consts_1.MAX_ITERATION_COUNT, returnValue = false, tableView = true, logger = new Logger_1.NoopLogger(), txFinalizer, cclAddress, } = options || {};
     const tracker = new OperationTracker_1.OperationTracker(network, customLiteSequencerEndpoints, logger);
     logger.debug('Start tracking operation');
     logger.debug('caller: ' + transactionLinker.caller);
@@ -70,13 +66,12 @@ async function startTracking(transactionLinker, network, options) {
     // Check if EXECUTED_IN_TON stage exists and use TxFinalizer to verify transaction success
     if (profilingData.executedInTON.exists && profilingData.executedInTON.stageData?.transactions) {
         logger.debug('EXECUTED_IN_TON stage found, verifying transaction success in TON...');
-        if (txFinalizerConfig) {
-            const txFinalizer = new TxFinalizer_1.TonTxFinalizer(txFinalizerConfig, logger);
+        if (txFinalizer && cclAddress) {
             const transactions = profilingData.executedInTON.stageData.transactions;
             for (const tx of transactions) {
                 try {
                     logger.debug(`Verifying transaction: ${tx.hash}`);
-                    await txFinalizer.trackTransactionTree(tx.hash);
+                    await txFinalizer.trackTransactionTree(cclAddress, tx.hash, { maxDepth: 10 });
                     logger.debug(`Transaction ${tx.hash} verified successfully in TON`);
                 }
                 catch (error) {
@@ -104,7 +99,7 @@ async function startTracking(transactionLinker, network, options) {
     }
 }
 async function startTrackingMultiple(transactionLinkers, network, options) {
-    const { customLiteSequencerEndpoints, delay = 10, maxIterationCount = Consts_1.MAX_ITERATION_COUNT, returnValue = false, tableView = true, txFinalizerConfig, logger = new Logger_1.NoopLogger(), } = options || {};
+    const { customLiteSequencerEndpoints, delay = 10, maxIterationCount = Consts_1.MAX_ITERATION_COUNT, returnValue = false, tableView = true, txFinalizer, logger = new Logger_1.NoopLogger(), } = options || {};
     logger.debug(`Start tracking ${transactionLinkers.length} operations`);
     const results = await Promise.all(transactionLinkers.map((linker, index) => {
         logger.debug(`\nProcessing operation ${index + 1}/${transactionLinkers.length}`);
@@ -114,7 +109,7 @@ async function startTrackingMultiple(transactionLinkers, network, options) {
             maxIterationCount,
             returnValue: true,
             tableView: false,
-            txFinalizerConfig,
+            txFinalizer,
             logger,
         });
     }));
@@ -160,35 +155,60 @@ function formatExecutionStages(stages) {
         bytesError: data.exists && data.stageData && data.stageData.note != null ? data.stageData.note.internalBytesError : '-',
     }));
 }
-function printExecutionStagesTable(stages, logger) {
-    const table = new cli_table3_1.default({
-        head: [
-            'Stage',
-            'Exists',
-            'Success',
-            'Timestamp',
-            'Transactions',
-            'NoteContent',
-            'ErrorName',
-            'InternalMsg',
-            'BytesError',
-        ],
-        colWidths: [30, 8, 9, 13, 70, 13, 13, 13, 13],
-        wordWrap: true,
+/**
+ * Simple table formatter that works in both browser and Node.js without external dependencies
+ */
+function createSimpleTable(headers, rows, colWidths) {
+    const lines = [];
+    // Helper to truncate and pad text to fit column width
+    const fitToWidth = (text, width) => {
+        // Handle multi-line text by taking only the first line for table cell
+        const firstLine = text.split('\n')[0];
+        if (firstLine.length > width - 2) {
+            return firstLine.substring(0, width - 5) + '...';
+        }
+        return firstLine.padEnd(width, ' ');
+    };
+    // Create separator line
+    const separator = '+' + colWidths.map((w) => '-'.repeat(w)).join('+') + '+';
+    // Create header row
+    const headerRow = '|' + headers.map((h, i) => fitToWidth(h, colWidths[i])).join('|') + '|';
+    lines.push(separator);
+    lines.push(headerRow);
+    lines.push(separator);
+    // Create data rows
+    rows.forEach((row) => {
+        const dataRow = '|' + row.map((cell, i) => fitToWidth(cell, colWidths[i])).join('|') + '|';
+        lines.push(dataRow);
     });
+    lines.push(separator);
+    return lines.join('\n');
+}
+function printExecutionStagesTable(stages, logger) {
+    const headers = [
+        'Stage',
+        'Exists',
+        'Success',
+        'Timestamp',
+        'Transactions',
+        'NoteContent',
+        'ErrorName',
+        'InternalMsg',
+        'BytesError',
+    ];
+    const colWidths = [30, 8, 9, 13, 70, 13, 13, 13, 13];
     const tableData = formatExecutionStages(stages);
-    tableData.forEach((row) => {
-        table.push([
-            row.stage,
-            row.exists,
-            row.success,
-            row.timestamp,
-            row.transactions,
-            row.noteContent,
-            row.errorName,
-            row.internalMsg,
-            row.bytesError,
-        ]);
-    });
-    logger.debug(table.toString());
+    const rows = tableData.map((row) => [
+        row.stage,
+        row.exists,
+        row.success,
+        row.timestamp,
+        row.transactions,
+        row.noteContent,
+        row.errorName,
+        row.internalMsg,
+        row.bytesError,
+    ]);
+    const table = createSimpleTable(headers, rows, colWidths);
+    logger.debug(table);
 }

package/dist/src/sdk/TONTransactionManager.d.ts

@@ -1,4 +1,5 @@
 import { Asset, IConfiguration, ILogger, IOperationTracker, ISimulator, ITONTransactionManager } from '../interfaces';
+import { ITxFinalizer } from '../interfaces/ITxFinalizer';
 import type { SenderAbstraction } from '../sender';
 import { BatchCrossChainTx, CrossChainPayloadResult, CrossChainTransactionOptions, CrossChainTransactionsOptions, CrosschainTx, EvmProxyMsg, FeeParams, TransactionLinkerWithOperationId } from '../structs/Struct';
 export declare class TONTransactionManager implements ITONTransactionManager {
@@ -6,7 +7,8 @@ export declare class TONTransactionManager implements ITONTransactionManager {
     private readonly simulator;
     private readonly operationTracker;
     private readonly logger;
-    constructor(config: IConfiguration, simulator: ISimulator, operationTracker: IOperationTracker, logger?: ILogger);
+    private readonly txFinalizer;
+    constructor(config: IConfiguration, simulator: ISimulator, operationTracker: IOperationTracker, logger: ILogger | undefined, txFinalizer: ITxFinalizer);
     buildFeeParams(options: CrossChainTransactionOptions, evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, tx: CrosschainTx): Promise<FeeParams>;
     private prepareCrossChainTransaction;
     private generateCrossChainMessages;

package/dist/src/sdk/TONTransactionManager.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TONTransactionManager = void 0;
+const ton_1 = require("@ton/ton");
 const assets_1 = require("../assets");
 const errors_1 = require("../errors");
 const instances_1 = require("../errors/instances");
@@ -9,11 +10,12 @@ const Logger_1 = require("./Logger");
 const Utils_1 = require("./Utils");
 const Validator_1 = require("./Validator");
 class TONTransactionManager {
-    constructor(config, simulator, operationTracker, logger = new Logger_1.NoopLogger()) {
+    constructor(config, simulator, operationTracker, logger = new Logger_1.NoopLogger(), txFinalizer) {
         this.config = config;
         this.simulator = simulator;
         this.operationTracker = operationTracker;
         this.logger = logger;
+        this.txFinalizer = txFinalizer;
     }
     async buildFeeParams(options, evmProxyMsg, sender, tx) {
         const { withoutSimulation, protocolFee, evmExecutorFee, tvmExecutorFee, isRoundTrip } = options;
@@ -155,7 +157,17 @@ class TONTransactionManager {
         if (!shouldWaitForOperationId) {
             return { sendTransactionResult, ...transactionLinker };
         }
-        const waitOptions = tx.options?.waitOptions ?? {};
+        const waitOptions = tx.options?.waitOptions ?? {
+            ensureTxExecuted: true,
+        };
+        if (waitOptions.ensureTxExecuted && sendTransactionResult.boc) {
+            const hash = (0, Utils_1.getNormalizedExtMessageHash)((0, ton_1.loadMessage)(ton_1.Cell.fromBase64(sendTransactionResult.boc).beginParse()));
+            this.logger.info(`Tracking transaction tree for hash: ${hash}`);
+            await this.txFinalizer.trackTransactionTree(sender.getSenderAddress(), hash, {
+                maxDepth: 10,
+            });
+            this.logger.info(`Transaction tree successful`);
+        }
         waitOptions.successCheck = waitOptions.successCheck ?? ((id) => !!id);
         waitOptions.logger = waitOptions.logger ?? this.logger;
         const operationId = await this.operationTracker
@@ -226,7 +238,7 @@ class TONTransactionManager {
         this.logger.debug('Preparing cross-chain transaction payload');
         const mockSender = {
             getSenderAddress: () => senderAddress,
-            sendShardTransaction: async () => ({ success: true }),
+            sendShardTransaction: async () => ({ success: true, boc: '' }),
             sendShardTransactions: async () => [],
             getBalance: async () => 0n,
             getBalanceOf: async () => 0n,
@@ -237,6 +249,7 @@ class TONTransactionManager {
             destinationAddress: r.address,
             tonAmount: r.value,
             networkFee: r.extra.networkFeeIncluded,
+            transactionLinker: result.transactionLinker,
         }));
     }
 }

package/dist/src/sdk/TacSdk.js

@@ -11,6 +11,7 @@ const OperationTracker_1 = require("./OperationTracker");
 const Simulator_1 = require("./Simulator");
 const TACTransactionManager_1 = require("./TACTransactionManager");
 const TONTransactionManager_1 = require("./TONTransactionManager");
+const TxFinalizer_1 = require("./TxFinalizer");
 const Utils_1 = require("./Utils");
 class TacSdk {
     constructor(config, simulator, tonTransactionManager, tacTransactionManager, operationTracker) {
@@ -40,7 +41,8 @@ class TacSdk {
         const config = await Configuration_1.Configuration.create(network, artifacts, sdkParams.TONParams, sdkParams.TACParams, sdkParams.customLiteSequencerEndpoints, delay);
         const operationTracker = new OperationTracker_1.OperationTracker(network, config.liteSequencerEndpoints);
         const simulator = new Simulator_1.Simulator(config, operationTracker, logger);
-        const tonTransactionManager = new TONTransactionManager_1.TONTransactionManager(config, simulator, operationTracker, logger);
+        const txFinalizer = sdkParams.TONParams?.txFinalizer ?? new TxFinalizer_1.TonTxFinalizer(config.TONParams.contractOpener, logger);
+        const tonTransactionManager = new TONTransactionManager_1.TONTransactionManager(config, simulator, operationTracker, logger, txFinalizer);
         const tacTransactionManager = new TACTransactionManager_1.TACTransactionManager(config, operationTracker, logger);
         return new TacSdk(config, simulator, tonTransactionManager, tacTransactionManager, operationTracker);
     }

package/dist/src/sdk/TxFinalizer.d.ts

@@ -1,11 +1,22 @@
-import { IHttpClient, ILogger } from '../interfaces';
+import { ContractOpener, IHttpClient, ILogger } from '../interfaces';
+import { ITxFinalizer } from '../interfaces/ITxFinalizer';
 import { TxFinalizerConfig } from '../structs/InternalStruct';
-export declare class TonTxFinalizer {
+export declare class TonTxFinalizer implements ITxFinalizer {
+    private logger;
+    private contractOpener;
+    constructor(contractOpener: ContractOpener, logger?: ILogger);
+    private fetchAdjacentTransactions;
+    trackTransactionTree(address: string, hash: string, params: {
+        maxDepth?: number;
+    }): Promise<void>;
+}
+export declare class TonTxFinalizerV3 implements ITxFinalizer {
     private logger;
     private apiConfig;
     private readonly httpClient;
     constructor(apiConfig: TxFinalizerConfig, logger?: ILogger, httpClient?: IHttpClient);
-    private logHashFormats;
     private fetchAdjacentTransactions;
-    trackTransactionTree(hash: string, maxDepth?: number): Promise<void>;
+    trackTransactionTree(_: string, hash: string, params?: {
+        maxDepth?: number;
+    }): Promise<void>;
 }

package/dist/src/sdk/TxFinalizer.js

@@ -1,33 +1,111 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TonTxFinalizer = void 0;
+exports.TonTxFinalizerV3 = exports.TonTxFinalizer = void 0;
+const ton_1 = require("@ton/ton");
 const AxiosHttpClient_1 = require("./AxiosHttpClient");
 const Logger_1 = require("./Logger");
 const Utils_1 = require("./Utils");
 const IGNORE_OPCODE = [
-    '0xd53276db', // Excess
-    '0x7362d09c', // Jetton Notify
+    0xd53276db, // Excess
+    0x7362d09c, // Jetton Notify
 ];
 class TonTxFinalizer {
-    constructor(apiConfig, logger = new Logger_1.NoopLogger(), httpClient = new AxiosHttpClient_1.AxiosHttpClient()) {
-        this.apiConfig = apiConfig;
+    constructor(contractOpener, logger = new Logger_1.NoopLogger()) {
+        this.contractOpener = contractOpener;
         this.logger = logger;
-        this.httpClient = httpClient;
     }
-    logHashFormats(hash) {
-        let hex, base64;
-        if (hash.startsWith('0x')) {
-            hex = hash;
-            const cleanHex = hex.slice(2);
-            const buffer = Buffer.from(cleanHex, 'hex');
-            base64 = buffer.toString('base64');
+    // Fetches adjacent transactions from toncenter
+    async fetchAdjacentTransactions(address, hash, retries = 5, delay = 1000, opts) {
+        for (let i = retries; i >= 0; i--) {
+            try {
+                const txs = await this.contractOpener.getAdjacentTransactions(address, hash, opts);
+                return txs;
+            }
+            catch (error) {
+                const errorMessage = error.message;
+                // Rate limit error (429) - retry
+                if (errorMessage.includes('429')) {
+                    if (i > 0) {
+                        await (0, Utils_1.sleep)(delay);
+                    }
+                    continue;
+                }
+                // Log all errors except 404 Not Found
+                if (!errorMessage.includes('404')) {
+                    const logMessage = error instanceof Error ? error.message : error;
+                    this.logger.warn(`Failed to fetch adjacent transactions for ${hash}:`, logMessage);
+                }
+                if (i > 0) {
+                    await (0, Utils_1.sleep)(delay);
+                }
+            }
         }
-        else {
-            base64 = hash;
-            const buffer = Buffer.from(base64, 'base64');
-            hex = '0x' + buffer.toString('hex');
+        return [];
+    }
+    // Checks if all transactions in the tree are successful
+    async trackTransactionTree(address, hash, params) {
+        const { maxDepth = 10 } = params;
+        const parsedAddress = ton_1.Address.parse(address);
+        const visitedHashes = new Set();
+        const queue = [{ address: parsedAddress, hash, depth: 0 }];
+        while (queue.length > 0) {
+            const { hash: currentHash, depth: currentDepth, address: currentAddress } = queue.shift();
+            if (visitedHashes.has(currentHash)) {
+                continue;
+            }
+            visitedHashes.add(currentHash);
+            this.logger.debug(`Checking hash (depth ${currentDepth}): ${currentHash}`);
+            const transactions = await this.fetchAdjacentTransactions(currentAddress, currentHash, 5, 1000, {
+                limit: 10,
+                archival: true,
+            });
+            console.log(`Found ${transactions.length} adjacent transactions for ${currentHash}`);
+            if (transactions.length === 0)
+                continue;
+            for (const tx of transactions) {
+                if (tx.description.type !== 'generic' || !tx.inMessage)
+                    continue;
+                const bodySlice = tx.inMessage.body.beginParse();
+                if (bodySlice.remainingBits < 32)
+                    continue;
+                const opcode = bodySlice.loadUint(32);
+                if (!IGNORE_OPCODE.includes(opcode)) {
+                    const { aborted, computePhase, actionPhase } = tx.description;
+                    if (aborted ||
+                        computePhase.type == 'skipped' ||
+                        !computePhase.success ||
+                        computePhase.exitCode !== 0 ||
+                        (actionPhase && (!actionPhase.success || actionPhase.resultCode !== 0))) {
+                        throw new Error(`Transaction failed:\n` +
+                            `hash = ${currentHash}, ` +
+                            `aborted = ${aborted}, ` +
+                            `compute phase: ${computePhase.type === 'skipped' ? 'skipped' : `success = ${computePhase.success}, exit code = ${computePhase.exitCode}`}, ` +
+                            `action phase: ${!actionPhase ? 'skipped' : `success = ${actionPhase.success}, result code = ${actionPhase.resultCode}`} `);
+                    }
+                    if (currentDepth + 1 < maxDepth) {
+                        if (tx.outMessages.size > 0) {
+                            queue.push({
+                                hash: tx.hash().toString('base64'),
+                                address: tx.inMessage.info.dest,
+                                depth: currentDepth + 1,
+                            });
+                        }
+                    }
+                }
+                else {
+                    this.logger.debug(`Skipping hash (depth ${currentDepth}): ${tx.hash().toString('base64')}`);
+                }
+            }
+            this.logger.debug(`Finished checking hash (depth ${currentDepth}): ${currentHash}`);
         }
-        return { hex: hex, base64: base64 };
+    }
+}
+exports.TonTxFinalizer = TonTxFinalizer;
+class TonTxFinalizerV3 {
+    constructor(apiConfig, logger = new Logger_1.NoopLogger(), httpClient = new AxiosHttpClient_1.AxiosHttpClient()) {
+        this.apiConfig = apiConfig;
+        this.logger = logger;
+        this.httpClient = httpClient;
     }
     // Fetches adjacent transactions from toncenter
     async fetchAdjacentTransactions(hash, retries = 5, delay = 1000) {
@@ -64,7 +142,8 @@ class TonTxFinalizer {
         return [];
     }
     // Checks if all transactions in the tree are successful
-    async trackTransactionTree(hash, maxDepth = 10) {
+    async trackTransactionTree(_, hash, params = { maxDepth: 10 }) {
+        const { maxDepth = 10 } = params;
         const visitedHashes = new Set();
         const queue = [{ hash, depth: 0 }];
         while (queue.length > 0) {
@@ -73,12 +152,12 @@ class TonTxFinalizer {
                 continue;
             }
             visitedHashes.add(currentHash);
-            this.logger.debug(`Checking hash (depth ${currentDepth}):\nhex: ${this.logHashFormats(currentHash).hex}\nbase64: ${this.logHashFormats(currentHash).base64}`);
+            this.logger.debug(`Checking hash (depth ${currentDepth}): ${currentHash}`);
             const transactions = await this.fetchAdjacentTransactions(currentHash);
             if (transactions.length === 0)
                 continue;
             for (const tx of transactions) {
-                if (!IGNORE_OPCODE.includes(tx.inMsg.opcode) && tx.inMsg.opcode !== null) {
+                if (!IGNORE_OPCODE.includes(Number(tx.inMsg.opcode)) && tx.inMsg.opcode !== null) {
                     const { aborted, computePh: compute_ph, action } = tx.description;
                     if (aborted ||
                         !compute_ph.success ||
@@ -100,10 +179,10 @@ class TonTxFinalizer {
                     }
                 }
                 else {
-                    this.logger.debug(`Skipping hash (depth ${currentDepth}):\nhex: ${this.logHashFormats(tx.hash).hex}\nbase64: ${this.logHashFormats(tx.hash).base64}`);
+                    this.logger.debug(`Skipping hash (depth ${currentDepth}): ${tx.hash}`);
                 }
             }
         }
     }
 }
-exports.TonTxFinalizer = TonTxFinalizer;
+exports.TonTxFinalizerV3 = TonTxFinalizerV3;

package/dist/src/sdk/Utils.d.ts

@@ -1,4 +1,4 @@
-import { Address, Cell } from '@ton/ton';
+import { Address, Cell, Message } from '@ton/ton';
 import { AbiCoder } from 'ethers';
 import type { FT, NFT, TON } from '../assets';
 import { Asset, IConfiguration } from '../interfaces';
@@ -32,3 +32,8 @@ export declare function normalizeAssets(config: IConfiguration, assets?: AssetLi
 export declare function getAddressString(cell?: Cell): string;
 export declare function getNumber(len: number, cell?: Cell): number;
 export declare function getString(cell?: Cell): string;
+export declare function getNormalizedExtMessageHash(message: Message): string;
+export declare function retry<T>(fn: () => Promise<T>, options: {
+    retries: number;
+    delay: number;
+}): Promise<T>;

package/dist/src/sdk/Utils.js

@@ -19,6 +19,8 @@ exports.normalizeAssets = normalizeAssets;
 exports.getAddressString = getAddressString;
 exports.getNumber = getNumber;
 exports.getString = getString;
+exports.getNormalizedExtMessageHash = getNormalizedExtMessageHash;
+exports.retry = retry;
 const ton_1 = require("@ton/ton");
 const ethers_1 = require("ethers");
 const ton_crypto_1 = require("ton-crypto");
@@ -299,3 +301,38 @@ function getNumber(len, cell) {
 function getString(cell) {
     return cell?.beginParse().loadStringTail() ?? '';
 }
+function getNormalizedExtMessageHash(message) {
+    if (message.info.type !== 'external-in') {
+        throw new Error(`Message must be "external-in", got ${message.info.type}`);
+    }
+    const info = {
+        ...message.info,
+        src: undefined,
+        importFee: 0n,
+    };
+    const normalizedMessage = {
+        ...message,
+        init: null,
+        info: info,
+    };
+    return (0, ton_1.beginCell)()
+        .store((0, ton_1.storeMessage)(normalizedMessage, { forceRef: true }))
+        .endCell()
+        .hash()
+        .toString('base64');
+}
+async function retry(fn, options) {
+    let lastError;
+    for (let i = 0; i < options.retries; i++) {
+        try {
+            return await fn();
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                lastError = e;
+            }
+            await new Promise((resolve) => setTimeout(resolve, options.delay));
+        }
+    }
+    throw lastError;
+}

package/dist/src/sender/BatchSender.js

@@ -38,7 +38,16 @@ class BatchSender {
         for (const group of groups) {
             try {
                 const result = await this.sendGroup(group, contractOpener);
+                // Extract BoC if it's a string, or from sandbox result
+                let externalMsgBoc = '';
+                if (typeof result === 'string') {
+                    externalMsgBoc = result;
+                }
+                else if (result?.result) {
+                    externalMsgBoc = result.result;
+                }
                 results.push({
+                    boc: externalMsgBoc,
                     success: true,
                     result,
                     lastMessageIndex: currentMessageIndex + group.length - 1,
@@ -46,6 +55,7 @@ class BatchSender {
             }
             catch (error) {
                 results.push({
+                    boc: '',
                     success: false,
                     error: error,
                     lastMessageIndex: currentMessageIndex - 1,
@@ -118,7 +128,16 @@ class BatchSender {
             }));
         }
         const result = await this.sendGroup(messages, contractOpener);
+        // Extract BoC if it's a string, or from sandbox result
+        let externalMsgBoc = '';
+        if (typeof result === 'string') {
+            externalMsgBoc = result;
+        }
+        else if (result?.result) {
+            externalMsgBoc = result.result;
+        }
         return {
+            boc: externalMsgBoc,
             success: true,
             result,
             lastMessageIndex: shardTransaction.messages.length - 1,