@tonappchain/sdk 0.7.1 → 0.7.2-alpha-2

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

@@ -1,4 +1,3 @@
-export declare const TRANSACTION_TON_AMOUNT: bigint;
 export declare const JETTON_TRANSFER_FORWARD_TON_AMOUNT: bigint;
 export declare const NFT_TRANSFER_FORWARD_TON_AMOUNT: bigint;
 export declare const MAX_ITERATION_COUNT = 120;
@@ -11,5 +10,55 @@ export declare const MAX_MSG_DEPTH = 512;
 export declare const TON_SYMBOL = "TON";
 export declare const TAC_SYMBOL = "TAC";
 export declare const FIFTEEN_MINUTES: number;
+export declare const ONE_YEAR_SECONDS: number;
 export declare const TON_DECIMALS = 9;
 export declare const TAC_DECIMALS = 18;
+export declare const TON_BURN_ADDRESS = "EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c";
+export declare const FIXED_POINT_SHIFT: number;
+export declare const CONTRACT_FEE_USAGE_PARAMS: {
+    crossChainLayer: {
+        accountBits: number;
+        accountCells: number;
+        gas: {
+            tvmMsgToEvm: number;
+        };
+    };
+    jettonWallet: {
+        accountBits: number;
+        accountCells: number;
+        gas: {
+            internalTransfer: number;
+            receive: number;
+            burn: number;
+        };
+    };
+    jettonProxy: {
+        accountbits: number;
+        accountCells: number;
+        gas: {
+            ownershipAssigned: number;
+        };
+    };
+    jettonMinter: {
+        accountBits: number;
+        accountCells: number;
+        gas: {
+            burnNotification: number;
+        };
+    };
+    nftItem: {
+        accountBits: number;
+        accountCells: number;
+        gas: {
+            send: number;
+            burn: number;
+        };
+    };
+    nftProxy: {
+        accountBits: number;
+        accountCells: number;
+        gas: {
+            ownershipAssigned: number;
+        };
+    };
+};

package/dist/src/sdk/Consts.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TAC_DECIMALS = exports.TON_DECIMALS = exports.FIFTEEN_MINUTES = exports.TAC_SYMBOL = exports.TON_SYMBOL = exports.MAX_MSG_DEPTH = exports.MAX_HIGHLOAD_GROUP_MSG_NUM = exports.MAX_EXT_MSG_SIZE = exports.SOLIDITY_METHOD_NAME_REGEX = exports.SOLIDITY_SIGNATURE_REGEX = exports.DEFAULT_DELAY = exports.MAX_ITERATION_COUNT = exports.NFT_TRANSFER_FORWARD_TON_AMOUNT = exports.JETTON_TRANSFER_FORWARD_TON_AMOUNT = exports.TRANSACTION_TON_AMOUNT = void 0;
+exports.CONTRACT_FEE_USAGE_PARAMS = exports.FIXED_POINT_SHIFT = exports.TON_BURN_ADDRESS = exports.TAC_DECIMALS = exports.TON_DECIMALS = exports.ONE_YEAR_SECONDS = exports.FIFTEEN_MINUTES = exports.TAC_SYMBOL = exports.TON_SYMBOL = exports.MAX_MSG_DEPTH = exports.MAX_HIGHLOAD_GROUP_MSG_NUM = exports.MAX_EXT_MSG_SIZE = exports.SOLIDITY_METHOD_NAME_REGEX = exports.SOLIDITY_SIGNATURE_REGEX = exports.DEFAULT_DELAY = exports.MAX_ITERATION_COUNT = exports.NFT_TRANSFER_FORWARD_TON_AMOUNT = exports.JETTON_TRANSFER_FORWARD_TON_AMOUNT = void 0;
 const ton_1 = require("@ton/ton");
-exports.TRANSACTION_TON_AMOUNT = (0, ton_1.toNano)(0.55);
 exports.JETTON_TRANSFER_FORWARD_TON_AMOUNT = (0, ton_1.toNano)(0.2);
 exports.NFT_TRANSFER_FORWARD_TON_AMOUNT = (0, ton_1.toNano)(0.3);
 exports.MAX_ITERATION_COUNT = 120;
@@ -15,5 +14,56 @@ exports.MAX_MSG_DEPTH = 512;
 exports.TON_SYMBOL = 'TON';
 exports.TAC_SYMBOL = 'TAC';
 exports.FIFTEEN_MINUTES = 15 * 60 * 1000;
+exports.ONE_YEAR_SECONDS = 365 * 24 * 3600;
 exports.TON_DECIMALS = 9;
 exports.TAC_DECIMALS = 18;
+exports.TON_BURN_ADDRESS = 'EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c';
+// FEES
+exports.FIXED_POINT_SHIFT = 2 ** 16;
+exports.CONTRACT_FEE_USAGE_PARAMS = {
+    crossChainLayer: {
+        accountBits: 43514,
+        accountCells: 100,
+        gas: {
+            tvmMsgToEvm: 14619,
+        },
+    },
+    jettonWallet: {
+        accountBits: 949,
+        accountCells: 3,
+        gas: {
+            internalTransfer: 10669,
+            receive: 11427,
+            burn: 8653,
+        },
+    },
+    jettonProxy: {
+        accountbits: 7760,
+        accountCells: 16,
+        gas: {
+            ownershipAssigned: 8515,
+        },
+    },
+    jettonMinter: {
+        accountBits: 10208,
+        accountCells: 28,
+        gas: {
+            burnNotification: 10357,
+        },
+    },
+    nftItem: {
+        accountBits: 1422,
+        accountCells: 5,
+        gas: {
+            send: 11722,
+            burn: 11552,
+        },
+    },
+    nftProxy: {
+        accountBits: 7512,
+        accountCells: 15,
+        gas: {
+            ownershipAssigned: 7688,
+        },
+    },
+};

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

@@ -1,6 +1,6 @@
-import { IConfiguration, ILogger, IOperationTracker, ISimulator } from '../interfaces';
+import { Asset, IConfiguration, ILogger, IOperationTracker, ISimulator } from '../interfaces';
 import type { SenderAbstraction } from '../sender';
-import { CrosschainTx, ExecutionFeeEstimationResult } from '../structs/Struct';
+import { CrosschainTx, ExecutionFeeEstimationResult, GeneratePayloadParams } from '../structs/Struct';
 export declare class Simulator implements ISimulator {
     private readonly config;
     private readonly operationTracker;
@@ -8,4 +8,13 @@ export declare class Simulator implements ISimulator {
     constructor(config: IConfiguration, operationTracker: IOperationTracker, logger?: ILogger);
     getSimulationsInfo(sender: SenderAbstraction, txs: CrosschainTx[]): Promise<ExecutionFeeEstimationResult[]>;
     getSimulationInfo(sender: SenderAbstraction, tx: CrosschainTx): Promise<ExecutionFeeEstimationResult>;
+    private calculateTONFees;
+    private calculateTransactionPipeline;
+    private calculateTONCrosschainFee;
+    private calculateJettonTransferCrosschainFee;
+    private calculateJettonBurnCrosschainFee;
+    private calculateNftTransferCrosschainFee;
+    private calculateNftBurnCrosschainFee;
+    estimateTONFees(assets: Asset[], params: GeneratePayloadParams): bigint;
+    estimateTONFee(asset: Asset, params: GeneratePayloadParams): bigint;
 }

package/dist/src/sdk/Simulator.js

@@ -2,6 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Simulator = 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 Struct_1 = require("../structs/Struct");
+const Consts_1 = require("./Consts");
 const Logger_1 = require("./Logger");
 const Utils_1 = require("./Utils");
 const Validator_1 = require("./Validator");
@@ -66,5 +71,190 @@ class Simulator {
         }
         return { feeParams, simulation };
     }
+    calculateTONFees({ 
+    // Contract usage
+    accountBits, accountCells, timeDelta, 
+    // Message size
+    msgBits, msgCells, 
+    // Gas and computation
+    gasUsed, 
+    // Config values (defaults for BaseChain)
+    bitPricePs = 1, cellPricePs = 500, lumpPrice = 400000, gasPrice = 400, firstFrac = 21845, ihrPriceFactor = 0, }) {
+        // Storage Fee (nanotons)
+        const storageFee = Math.ceil(((accountBits * bitPricePs + accountCells * cellPricePs) * timeDelta) / Consts_1.FIXED_POINT_SHIFT);
+        // Computation Fee (nanotons)
+        const computeFee = gasUsed * gasPrice;
+        // Forwarding Fee (nanotons)
+        const msgFwdFees = lumpPrice + Math.ceil((bitPricePs * msgBits + cellPricePs * msgCells) / Consts_1.FIXED_POINT_SHIFT);
+        const ihrFwdFees = Math.ceil((msgFwdFees * ihrPriceFactor) / Consts_1.FIXED_POINT_SHIFT);
+        const totalFwdFees = msgFwdFees + ihrFwdFees;
+        // Action Fee (nanotons)
+        const actionFee = Math.floor((msgFwdFees * firstFrac) / Consts_1.FIXED_POINT_SHIFT);
+        // Combine all fees
+        const totalFees = BigInt(storageFee) + BigInt(computeFee) + BigInt(actionFee) + BigInt(totalFwdFees);
+        return totalFees;
+    }
+    calculateTransactionPipeline(steps) {
+        return steps.reduce((total, step) => total + this.calculateTONFees(step), 0n);
+    }
+    calculateTONCrosschainFee(msgBits, msgCells) {
+        return this.calculateTransactionPipeline([
+            {
+                accountBits: Consts_1.CONTRACT_FEE_USAGE_PARAMS.crossChainLayer.accountBits,
+                accountCells: Consts_1.CONTRACT_FEE_USAGE_PARAMS.crossChainLayer.accountCells,
+                gasUsed: Consts_1.CONTRACT_FEE_USAGE_PARAMS.crossChainLayer.gas.tvmMsgToEvm,
+                msgBits,
+                msgCells,
+                timeDelta: Consts_1.ONE_YEAR_SECONDS,
+            },
+        ]);
+    }
+    calculateJettonTransferCrosschainFee(msgBits, msgCells) {
+        return this.calculateTransactionPipeline([
+            {
+                accountBits: Consts_1.CONTRACT_FEE_USAGE_PARAMS.jettonWallet.accountBits,
+                accountCells: Consts_1.CONTRACT_FEE_USAGE_PARAMS.jettonWallet.accountCells,
+                gasUsed: Consts_1.CONTRACT_FEE_USAGE_PARAMS.jettonWallet.gas.internalTransfer,
+                msgBits,
+                msgCells,
+                timeDelta: Consts_1.ONE_YEAR_SECONDS,
+            },
+            {
+                accountBits: Consts_1.CONTRACT_FEE_USAGE_PARAMS.jettonWallet.accountBits,
+                accountCells: Consts_1.CONTRACT_FEE_USAGE_PARAMS.jettonWallet.accountCells,
+                gasUsed: Consts_1.CONTRACT_FEE_USAGE_PARAMS.jettonWallet.gas.receive,
+                msgBits,
+                msgCells,
+                timeDelta: Consts_1.ONE_YEAR_SECONDS,
+            },
+            {
+                accountBits: Consts_1.CONTRACT_FEE_USAGE_PARAMS.jettonProxy.accountbits,
+                accountCells: Consts_1.CONTRACT_FEE_USAGE_PARAMS.jettonProxy.accountCells,
+                gasUsed: Consts_1.CONTRACT_FEE_USAGE_PARAMS.jettonProxy.gas.ownershipAssigned,
+                msgBits,
+                msgCells,
+                timeDelta: Consts_1.ONE_YEAR_SECONDS,
+            },
+            {
+                accountBits: Consts_1.CONTRACT_FEE_USAGE_PARAMS.crossChainLayer.accountBits,
+                accountCells: Consts_1.CONTRACT_FEE_USAGE_PARAMS.crossChainLayer.accountCells,
+                gasUsed: Consts_1.CONTRACT_FEE_USAGE_PARAMS.crossChainLayer.gas.tvmMsgToEvm,
+                msgBits,
+                msgCells,
+                timeDelta: Consts_1.ONE_YEAR_SECONDS,
+            },
+        ]);
+    }
+    calculateJettonBurnCrosschainFee(msgBits, msgCells) {
+        return this.calculateTransactionPipeline([
+            {
+                accountBits: Consts_1.CONTRACT_FEE_USAGE_PARAMS.jettonWallet.accountBits,
+                accountCells: Consts_1.CONTRACT_FEE_USAGE_PARAMS.jettonWallet.accountCells,
+                gasUsed: Consts_1.CONTRACT_FEE_USAGE_PARAMS.jettonWallet.gas.burn,
+                msgBits,
+                msgCells,
+                timeDelta: Consts_1.ONE_YEAR_SECONDS,
+            },
+            {
+                accountBits: Consts_1.CONTRACT_FEE_USAGE_PARAMS.jettonMinter.accountBits,
+                accountCells: Consts_1.CONTRACT_FEE_USAGE_PARAMS.jettonMinter.accountCells,
+                gasUsed: Consts_1.CONTRACT_FEE_USAGE_PARAMS.jettonMinter.gas.burnNotification,
+                msgBits,
+                msgCells,
+                timeDelta: Consts_1.ONE_YEAR_SECONDS,
+            },
+            {
+                accountBits: Consts_1.CONTRACT_FEE_USAGE_PARAMS.crossChainLayer.accountBits,
+                accountCells: Consts_1.CONTRACT_FEE_USAGE_PARAMS.crossChainLayer.accountCells,
+                gasUsed: Consts_1.CONTRACT_FEE_USAGE_PARAMS.crossChainLayer.gas.tvmMsgToEvm,
+                msgBits,
+                msgCells,
+                timeDelta: Consts_1.ONE_YEAR_SECONDS,
+            },
+        ]);
+    }
+    calculateNftTransferCrosschainFee(msgBits, msgCells) {
+        return this.calculateTransactionPipeline([
+            {
+                accountBits: Consts_1.CONTRACT_FEE_USAGE_PARAMS.nftItem.accountBits,
+                accountCells: Consts_1.CONTRACT_FEE_USAGE_PARAMS.nftItem.accountCells,
+                gasUsed: Consts_1.CONTRACT_FEE_USAGE_PARAMS.nftItem.gas.send,
+                msgBits,
+                msgCells,
+                timeDelta: Consts_1.ONE_YEAR_SECONDS,
+            },
+            {
+                accountBits: Consts_1.CONTRACT_FEE_USAGE_PARAMS.nftProxy.accountBits,
+                accountCells: Consts_1.CONTRACT_FEE_USAGE_PARAMS.nftProxy.accountCells,
+                gasUsed: Consts_1.CONTRACT_FEE_USAGE_PARAMS.nftProxy.gas.ownershipAssigned,
+                msgBits,
+                msgCells,
+                timeDelta: Consts_1.ONE_YEAR_SECONDS,
+            },
+            {
+                accountBits: Consts_1.CONTRACT_FEE_USAGE_PARAMS.crossChainLayer.accountBits,
+                accountCells: Consts_1.CONTRACT_FEE_USAGE_PARAMS.crossChainLayer.accountCells,
+                gasUsed: Consts_1.CONTRACT_FEE_USAGE_PARAMS.crossChainLayer.gas.tvmMsgToEvm,
+                msgBits,
+                msgCells,
+                timeDelta: Consts_1.ONE_YEAR_SECONDS,
+            },
+        ]);
+    }
+    calculateNftBurnCrosschainFee(msgBits, msgCells) {
+        return this.calculateTransactionPipeline([
+            {
+                accountBits: Consts_1.CONTRACT_FEE_USAGE_PARAMS.nftItem.accountBits,
+                accountCells: Consts_1.CONTRACT_FEE_USAGE_PARAMS.nftItem.accountCells,
+                gasUsed: Consts_1.CONTRACT_FEE_USAGE_PARAMS.nftItem.gas.burn,
+                msgBits,
+                msgCells,
+                timeDelta: Consts_1.ONE_YEAR_SECONDS,
+            },
+            {
+                accountBits: Consts_1.CONTRACT_FEE_USAGE_PARAMS.crossChainLayer.accountBits,
+                accountCells: Consts_1.CONTRACT_FEE_USAGE_PARAMS.crossChainLayer.accountCells,
+                gasUsed: Consts_1.CONTRACT_FEE_USAGE_PARAMS.crossChainLayer.gas.tvmMsgToEvm,
+                msgBits,
+                msgCells,
+                timeDelta: Consts_1.ONE_YEAR_SECONDS,
+            },
+        ]);
+    }
+    estimateTONFees(assets, params) {
+        return assets.reduce((totalFees, asset) => totalFees + this.estimateTONFee(asset, params), 0n);
+    }
+    estimateTONFee(asset, params) {
+        const payload = asset.generatePayload(params);
+        const { bits: msgBits, cells: msgCells } = (0, Utils_1.recurisivelyCollectCellStats)(payload);
+        switch (asset.type) {
+            case Struct_1.AssetType.FT:
+                if (asset instanceof assets_1.TON) {
+                    // Pipeline: wallet -> ccl -> log
+                    return this.calculateTONCrosschainFee(msgBits, msgCells);
+                }
+                if (asset.origin === Struct_1.Origin.TON) {
+                    // Pipeline: wallet -> jetton wallet -> jetton wallet -> jetton proxy -> ccl -> log
+                    return this.calculateJettonTransferCrosschainFee(msgBits, msgCells);
+                }
+                if (asset.origin === Struct_1.Origin.TAC) {
+                    // Pipeline: wallet -> jetton wallet -> jetton minter -> ccl -> log
+                    return this.calculateJettonBurnCrosschainFee(msgBits, msgCells);
+                }
+                throw (0, instances_1.unknownAssetOriginError)(asset.origin);
+            case Struct_1.AssetType.NFT:
+                if (asset.origin === Struct_1.Origin.TON) {
+                    // Pipeline: wallet -> nft item -> nft proxy -> ccl -> log
+                    return this.calculateNftTransferCrosschainFee(msgBits, msgCells);
+                }
+                if (asset.origin === Struct_1.Origin.TAC) {
+                    // Pipeline: wallet -> nft item -> ccl -> log
+                    return this.calculateNftBurnCrosschainFee(msgBits, msgCells);
+                }
+                throw (0, instances_1.unknownAssetOriginError)(asset.origin);
+            default:
+                throw (0, errors_1.unknownTokenTypeError)(asset.type);
+        }
+    }
 }
 exports.Simulator = Simulator;

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,17 +1,20 @@
-import { IConfiguration, ILogger, IOperationTracker, ISimulator, ITONTransactionManager } from '../interfaces';
-import type { SenderAbstraction } from '../sender';
-import { BatchCrossChainTx, CrossChainTransactionOptions, CrossChainTransactionsOptions, CrosschainTx, EvmProxyMsg, FeeParams, TransactionLinkerWithOperationId } from '../structs/Struct';
+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 {
     private readonly config;
     private readonly simulator;
     private readonly operationTracker;
     private readonly logger;
-    constructor(config: IConfiguration, simulator: ISimulator, operationTracker: IOperationTracker, logger?: ILogger);
-    protected buildFeeParams(options: CrossChainTransactionOptions, evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, tx: CrosschainTx): Promise<FeeParams>;
+    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;
     sendCrossChainTransaction(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, tx: CrosschainTx): Promise<TransactionLinkerWithOperationId>;
     sendCrossChainTransactions(sender: SenderAbstraction, txs: BatchCrossChainTx[], options?: CrossChainTransactionsOptions): Promise<TransactionLinkerWithOperationId[]>;
     private prepareBatchTransactions;
     private waitForOperationIds;
+    prepareCrossChainTransactionPayload(evmProxyMsg: EvmProxyMsg, senderAddress: string, assets?: Asset[], options?: CrossChainTransactionOptions): Promise<CrossChainPayloadResult[]>;
 }