@tonappchain/sdk 0.7.1-frost-test-1 → 0.7.2-alpha-1

package/dist/src/sdk/TONTransactionManager.js

@@ -1,19 +1,22 @@
 "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");
+const sender_1 = require("../sender");
 const Consts_1 = require("./Consts");
 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;
@@ -46,6 +49,7 @@ class TONTransactionManager {
                 : simulationResult.feeParams.tvmExecutorFee,
             gasLimit: evmProxyMsg.gasLimit ?? simulationResult.feeParams.gasLimit,
             isRoundTrip: isRoundTrip ?? simulationResult.feeParams.isRoundTrip,
+            evmEstimatedGas: simulationResult.simulation?.estimatedGas,
         };
     }
     async prepareCrossChainTransaction(evmProxyMsg, sender, assets, options, skipAssetsBalanceValidation = false) {
@@ -106,29 +110,45 @@ class TONTransactionManager {
         let feeTonAmount = feeParams.protocolFee + feeParams.evmExecutorFee + feeParams.tvmExecutorFee;
         this.logger.debug(`Crosschain ton amount: ${crossChainTonAmount}, Fee ton amount: ${feeTonAmount}`);
         if (!totalAssets.length) {
+            const tonNetworkFee = this.simulator.estimateTONFee(ton, {
+                excessReceiver: caller,
+                evmData,
+                feeParams,
+            });
             return [
                 {
                     address: this.config.TONParams.crossChainLayerAddress,
-                    value: crossChainTonAmount + feeTonAmount + Consts_1.TRANSACTION_TON_AMOUNT,
+                    value: crossChainTonAmount + feeTonAmount + tonNetworkFee,
                     payload: await ton.generatePayload({ excessReceiver: caller, evmData, feeParams }),
+                    extra: {
+                        tonNetworkFee,
+                        tacEstimatedGas: feeParams.evmEstimatedGas,
+                    },
                 },
             ];
         }
         const messages = [];
         let currentFeeParams = feeParams;
         for (const asset of totalAssets) {
-            const payload = await asset.generatePayload({
+            const params = {
                 excessReceiver: caller,
                 evmData,
                 crossChainTonAmount,
                 forwardFeeTonAmount: feeTonAmount,
                 feeParams: currentFeeParams,
-            });
+            };
+            const payload = await asset.generatePayload(params);
             const address = asset instanceof assets_1.FT ? await asset.getUserWalletAddress(caller) : asset.address;
+            const forwardAmount = asset instanceof assets_1.FT ? Consts_1.JETTON_TRANSFER_FORWARD_TON_AMOUNT : Consts_1.NFT_TRANSFER_FORWARD_TON_AMOUNT;
+            const tonNetworkFee = this.simulator.estimateTONFee(asset, params);
             messages.push({
                 address,
-                value: crossChainTonAmount + feeTonAmount + Consts_1.TRANSACTION_TON_AMOUNT,
+                value: crossChainTonAmount + feeTonAmount + tonNetworkFee + forwardAmount,
                 payload,
+                extra: {
+                    tonNetworkFee,
+                    tacEstimatedGas: currentFeeParams?.evmEstimatedGas,
+                },
             });
             crossChainTonAmount = 0n;
             feeTonAmount = 0n;
@@ -149,7 +169,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
@@ -216,5 +246,18 @@ class TONTransactionManager {
             return transactionLinkers;
         }
     }
+    async prepareCrossChainTransactionPayload(evmProxyMsg, senderAddress, assets = [], options) {
+        this.logger.debug('Preparing cross-chain transaction payload');
+        const mockSender = (0, sender_1.getMockSender)(senderAddress);
+        const result = await this.prepareCrossChainTransaction(evmProxyMsg, mockSender, assets, options, true);
+        return result.transaction.messages.map((r) => ({
+            body: r.payload,
+            destinationAddress: r.address,
+            tonAmount: r.value,
+            tonNetworkFee: r.extra.tonNetworkFee,
+            tacEstimatedGas: r.extra.tacEstimatedGas,
+            transactionLinker: result.transactionLinker,
+        }));
+    }
 }
 exports.TONTransactionManager = TONTransactionManager;

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

@@ -3,7 +3,7 @@ import { JettonMinterData, NFTItemData } from '../../artifacts/tonTypes';
 import { FT, NFT } from '../assets';
 import { IConfiguration, ILogger, IOperationTracker, ITacSDK } from '../interfaces';
 import type { SenderAbstraction } from '../sender';
-import { AssetFromFTArg, AssetFromNFTCollectionArg, AssetFromNFTItemArg, AssetLike, BatchCrossChainTxWithAssetLike, CrossChainTransactionOptions, CrossChainTransactionsOptions, CrosschainTx, EVMAddress, EvmProxyMsg, ExecutionFeeEstimationResult, NFTAddressType, SDKParams, SuggestedTVMExecutorFee, TACSimulationParams, TACSimulationResult, TransactionLinkerWithOperationId, TVMAddress, UserWalletBalanceExtended } from '../structs/Struct';
+import { AssetFromFTArg, AssetFromNFTCollectionArg, AssetFromNFTItemArg, AssetLike, BatchCrossChainTxWithAssetLike, CrossChainPayloadResult, CrossChainTransactionOptions, CrossChainTransactionsOptions, CrosschainTx, EVMAddress, EvmProxyMsg, ExecutionFeeEstimationResult, NFTAddressType, SDKParams, SuggestedTVMExecutorFee, TACSimulationParams, TACSimulationResult, TransactionLinkerWithOperationId, TVMAddress, UserWalletBalanceExtended } from '../structs/Struct';
 export declare class TacSdk implements ITacSDK {
     readonly config: IConfiguration;
     readonly operationTracker: IOperationTracker;
@@ -41,4 +41,5 @@ export declare class TacSdk implements ITacSDK {
     getTVMNFTAddress(evmNFTAddress: string, tokenId?: number | bigint): Promise<string>;
     getEVMNFTAddress(tvmNFTAddress: string, addressType: NFTAddressType): Promise<string>;
     getOperationTracker(): IOperationTracker;
+    prepareCrossChainTransactionPayload(evmProxyMsg: EvmProxyMsg, senderAddress: string, assets?: AssetLike[], options?: CrossChainTransactionOptions): Promise<CrossChainPayloadResult[]>;
 }

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);
     }
@@ -177,5 +179,9 @@ class TacSdk {
     getOperationTracker() {
         return this.operationTracker;
     }
+    async prepareCrossChainTransactionPayload(evmProxyMsg, senderAddress, assets = [], options) {
+        const normalizedAssets = await (0, Utils_1.normalizeAssets)(this.config, assets);
+        return this.tonTransactionManager.prepareCrossChainTransactionPayload(evmProxyMsg, senderAddress, normalizedAssets, options);
+    }
 }
 exports.TacSdk = TacSdk;

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 TonIndexerTxFinalizer 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.TonIndexerTxFinalizer = 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 TonIndexerTxFinalizer {
+    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.TonIndexerTxFinalizer = TonIndexerTxFinalizer;

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,12 @@ 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>;
+export declare function recurisivelyCollectCellStats(cell: Cell): {
+    bits: number;
+    cells: number;
+};

package/dist/src/sdk/Utils.js

@@ -19,6 +19,9 @@ exports.normalizeAssets = normalizeAssets;
 exports.getAddressString = getAddressString;
 exports.getNumber = getNumber;
 exports.getString = getString;
+exports.getNormalizedExtMessageHash = getNormalizedExtMessageHash;
+exports.retry = retry;
+exports.recurisivelyCollectCellStats = recurisivelyCollectCellStats;
 const ton_1 = require("@ton/ton");
 const ethers_1 = require("ethers");
 const ton_crypto_1 = require("ton-crypto");
@@ -299,3 +302,48 @@ 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;
+}
+function recurisivelyCollectCellStats(cell) {
+    let bits = 0;
+    let cells = 0;
+    for (const ref of cell.refs) {
+        const stats = recurisivelyCollectCellStats(ref);
+        bits += stats.bits;
+        cells += stats.cells;
+    }
+    return { bits: cell.bits.length + bits, cells: 1 + cells };
+}

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,

package/dist/src/sender/MockSender.d.ts

@@ -0,0 +1,2 @@
+import { SenderAbstraction } from '../interfaces/SenderAbstraction';
+export declare const getMockSender: (senderAddress: string) => SenderAbstraction;

package/dist/src/sender/MockSender.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMockSender = void 0;
+const getMockSender = (senderAddress) => {
+    return {
+        getSenderAddress: () => senderAddress,
+        sendShardTransaction: async () => ({ success: true, boc: '' }),
+        sendShardTransactions: async () => [],
+        getBalance: async () => 0n,
+        getBalanceOf: async () => 0n,
+    };
+};
+exports.getMockSender = getMockSender;

package/dist/src/sender/RawSender.js

@@ -34,7 +34,16 @@ class RawSender {
         for (const batch of batches) {
             try {
                 const result = await this.sendBatch(batch, 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 + batch.length - 1,
@@ -42,6 +51,7 @@ class RawSender {
             }
             catch (error) {
                 results.push({
+                    boc: '',
                     success: false,
                     error: error,
                     lastMessageIndex: currentMessageIndex - 1,
@@ -63,12 +73,26 @@ class RawSender {
     async sendBatch(messages, contractOpener) {
         const walletContract = contractOpener.open(this.wallet);
         const seqno = await walletContract.getSeqno();
-        return walletContract.sendTransfer({
+        // Try to create BoC locally for standard wallets
+        const msg = this.wallet.createTransfer({
             seqno,
             secretKey: this.secretKey,
             messages,
             sendMode: ton_2.SendMode.PAY_GAS_SEPARATELY,
         });
+        let neededInit = null;
+        if (this.wallet.init && (await contractOpener.getContractState(this.wallet.address)).state !== 'active') {
+            neededInit = this.wallet.init;
+        }
+        const ext = (0, ton_1.external)({
+            to: this.wallet.address,
+            init: neededInit,
+            body: msg,
+        });
+        const boc = (0, ton_1.beginCell)().store((0, ton_1.storeMessage)(ext)).endCell().toBoc().toString('base64');
+        // Send the transaction
+        const result = await walletContract.send(msg);
+        return result || boc;
     }
     getSenderAddress() {
         return this.wallet.address.toString();
@@ -84,7 +108,16 @@ class RawSender {
             }));
         }
         const result = await this.sendBatch(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,

package/dist/src/sender/SenderFactory.js

@@ -51,7 +51,7 @@ class SenderFactory {
             config.timeout = params.options?.highloadV3?.timeout ?? HighloadWalletV3_1.DEFAULT_TIMEOUT;
         }
         const wallet = exports.wallets[params.version].create(config);
-        if (params.version === 'HIGHLOAD_V3') {
+        if (wallet instanceof HighloadWalletV3_1.HighloadWalletV3) {
             return new BatchSender_1.BatchSender(wallet, keypair.secretKey);
         }
         return new RawSender_1.RawSender(wallet, keypair.secretKey, params.version === 'V5R1' ? 254 : 4);

package/dist/src/sender/TonConnectSender.js

@@ -35,6 +35,7 @@ class TonConnectSender {
                 responses.push({
                     success: true,
                     result: response,
+                    boc: response.boc,
                     lastMessageIndex: currentMessageIndex + chunk.length - 1,
                 });
                 currentMessageIndex += chunk.length;
@@ -42,6 +43,7 @@ class TonConnectSender {
             catch (error) {
                 responses.push({
                     success: false,
+                    boc: '',
                     error: error,
                     lastMessageIndex: currentMessageIndex - 1,
                 });

package/dist/src/sender/index.d.ts

@@ -1,3 +1,4 @@
 export * from '../interfaces/SenderAbstraction';
 export * from './BatchSender';
+export * from './MockSender';
 export * from './SenderFactory';

package/dist/src/sender/index.js

@@ -16,4 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("../interfaces/SenderAbstraction"), exports);
 __exportStar(require("./BatchSender"), exports);
+__exportStar(require("./MockSender"), exports);
 __exportStar(require("./SenderFactory"), exports);