@tonappchain/sdk 0.7.2-payload-builder-0.3 → 0.7.2-scaled-ui-support-1

package/dist/src/sdk/Simulator.js

@@ -2,71 +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 Struct_1 = require("../structs/Struct");
 const Logger_1 = require("./Logger");
 const Utils_1 = require("./Utils");
 const Validator_1 = require("./Validator");
 class Simulator {
     constructor(config, operationTracker, logger = new Logger_1.NoopLogger()) {
-        this.TON_FEE_CONSTANTS = {
-            messageSizes: {
-                jetton: { bits: 1500, cells: 4 },
-                nft: { bits: 1300, cells: 4 },
-                ton: { bits: 500, cells: 1 },
-            },
-            walletSendTokenPrice: 0.006 * 10 ** 9, // 0.006 TON in nanotons
-            storageTimeDelta: 1 * 24 * 3600, // 1 day in seconds
-            messageOverhead: { bits: 847, cells: 3 },
-        };
-        this.TRANSACTION_STEPS = {
-            crossChainLayer: {
-                accountBits: 34534,
-                accountCells: 85,
-                gasUsed: 13636,
-            },
-            jettonWallet: {
-                accountBits: 949,
-                accountCells: 3,
-                gasUsed: 11000,
-            },
-            jettonWalletTransfer: {
-                accountBits: 949,
-                accountCells: 3,
-                gasUsed: 12000,
-            },
-            jettonWalletBurn: {
-                accountBits: 949,
-                accountCells: 3,
-                gasUsed: 8653,
-            },
-            jettonProxy: {
-                accountBits: 7760,
-                accountCells: 16,
-                gasUsed: 8515,
-            },
-            jettonMinter: {
-                accountBits: 10208,
-                accountCells: 28,
-                gasUsed: 10357,
-            },
-            nftItem: {
-                accountBits: 1422,
-                accountCells: 5,
-                gasUsed: 11722,
-            },
-            nftItemBurn: {
-                accountBits: 1422,
-                accountCells: 5,
-                gasUsed: 11552,
-            },
-            nftProxy: {
-                accountBits: 7512,
-                accountCells: 15,
-                gasUsed: 7688,
-            },
-        };
         this.config = config;
         this.operationTracker = operationTracker;
         this.logger = logger;
@@ -126,105 +66,5 @@ 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) / 2 ** 16);
-        // Computation Fee (nanotons)
-        const computeFee = gasUsed * gasPrice;
-        // Forwarding Fee (nanotons)
-        const msgFwdFees = lumpPrice + Math.ceil((bitPricePs * msgBits + cellPricePs * msgCells) / 2 ** 16);
-        const ihrFwdFees = Math.ceil((msgFwdFees * ihrPriceFactor) / 2 ** 16);
-        const totalFwdFees = msgFwdFees + ihrFwdFees;
-        // Action Fee (nanotons)
-        const actionFee = Math.floor((msgFwdFees * firstFrac) / 2 ** 16);
-        // Combine all fees
-        const totalFees = storageFee + computeFee + actionFee + totalFwdFees;
-        return totalFees;
-    }
-    calculateStepFee(step, messageSize) {
-        return this.calculateTONFees({
-            ...step,
-            timeDelta: this.TON_FEE_CONSTANTS.storageTimeDelta,
-            msgBits: messageSize.bits,
-            msgCells: messageSize.cells,
-        });
-    }
-    calculateTransactionPipeline(steps) {
-        return steps.reduce((total, { step, messageSize }) => total + this.calculateStepFee(step, messageSize), this.TON_FEE_CONSTANTS.walletSendTokenPrice);
-    }
-    estimateTONFees(assets) {
-        const { messageSizes, messageOverhead } = this.TON_FEE_CONSTANTS;
-        return assets.reduce((totalFees, asset) => {
-            const assetFee = (() => {
-                switch (asset.type) {
-                    case Struct_1.AssetType.FT:
-                        if (asset instanceof assets_1.TON) {
-                            // Pipeline: wallet -> ccl -> log
-                            return this.calculateTransactionPipeline([
-                                { step: this.TRANSACTION_STEPS.crossChainLayer, messageSize: messageSizes.ton },
-                            ]);
-                        }
-                        if (asset.origin === Struct_1.Origin.TON) {
-                            // Pipeline: wallet -> jetton wallet -> jetton wallet -> jetton proxy -> ccl -> log
-                            return this.calculateTransactionPipeline([
-                                {
-                                    step: this.TRANSACTION_STEPS.jettonWallet,
-                                    messageSize: {
-                                        bits: messageSizes.jetton.bits + messageOverhead.bits,
-                                        cells: messageSizes.jetton.cells + messageOverhead.cells,
-                                    },
-                                },
-                                { step: this.TRANSACTION_STEPS.jettonWalletTransfer, messageSize: messageSizes.jetton },
-                                { step: this.TRANSACTION_STEPS.jettonProxy, messageSize: messageSizes.jetton },
-                                { step: this.TRANSACTION_STEPS.crossChainLayer, messageSize: messageSizes.jetton },
-                            ]);
-                        }
-                        if (asset.origin === Struct_1.Origin.TAC) {
-                            // Pipeline: wallet -> jetton wallet -> jetton minter -> ccl -> log
-                            return this.calculateTransactionPipeline([
-                                {
-                                    step: this.TRANSACTION_STEPS.jettonWalletBurn,
-                                    messageSize: {
-                                        bits: messageSizes.jetton.bits + messageOverhead.bits,
-                                        cells: messageSizes.jetton.cells + messageOverhead.cells,
-                                    },
-                                },
-                                { step: this.TRANSACTION_STEPS.jettonMinter, messageSize: messageSizes.jetton },
-                                { step: this.TRANSACTION_STEPS.crossChainLayer, messageSize: messageSizes.jetton },
-                            ]);
-                        }
-                        return 0;
-                    case Struct_1.AssetType.NFT:
-                        if (asset.origin === Struct_1.Origin.TON) {
-                            // Pipeline: wallet -> nft item -> nft proxy -> ccl -> log
-                            return this.calculateTransactionPipeline([
-                                { step: this.TRANSACTION_STEPS.nftItem, messageSize: messageSizes.nft },
-                                { step: this.TRANSACTION_STEPS.nftProxy, messageSize: messageSizes.nft },
-                                { step: this.TRANSACTION_STEPS.crossChainLayer, messageSize: messageSizes.nft },
-                            ]);
-                        }
-                        if (asset.origin === Struct_1.Origin.TAC) {
-                            // Pipeline: wallet -> nft item -> ccl -> log
-                            return this.calculateTransactionPipeline([
-                                { step: this.TRANSACTION_STEPS.nftItemBurn, messageSize: messageSizes.nft },
-                                { step: this.TRANSACTION_STEPS.crossChainLayer, messageSize: messageSizes.nft },
-                            ]);
-                        }
-                        return 0;
-                    default:
-                        throw (0, errors_1.unknownTokenTypeError)(asset.type);
-                }
-            })();
-            return totalFees + assetFee;
-        }, 0);
-    }
 }
 exports.Simulator = Simulator;

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

@@ -1,5 +1,5 @@
 import { ILogger } from '../interfaces';
-import { ITxFinalizer } from '../interfaces/ITxFinalizer';
+import { TxFinalizerConfig } from '../structs/InternalStruct';
 import { ExecutionStages, Network, TransactionLinker } from '../structs/Struct';
 export declare function startTracking(transactionLinker: TransactionLinker, network: Network, options?: {
     customLiteSequencerEndpoints?: string[];
@@ -7,9 +7,8 @@ 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[];
@@ -17,7 +16,6 @@ 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,15 +1,19 @@
 "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;
-exports.printExecutionStagesTable = printExecutionStagesTable;
+const cli_table3_1 = __importDefault(require("cli-table3"));
 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, logger = new Logger_1.NoopLogger(), txFinalizer, cclAddress, } = options || {};
+    const { customLiteSequencerEndpoints, delay = 10, maxIterationCount = Consts_1.MAX_ITERATION_COUNT, returnValue = false, tableView = true, txFinalizerConfig, logger = new Logger_1.NoopLogger(), } = options || {};
     const tracker = new OperationTracker_1.OperationTracker(network, customLiteSequencerEndpoints, logger);
     logger.debug('Start tracking operation');
     logger.debug('caller: ' + transactionLinker.caller);
@@ -66,12 +70,13 @@ 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 (txFinalizer && cclAddress) {
+        if (txFinalizerConfig) {
+            const txFinalizer = new TxFinalizer_1.TonTxFinalizer(txFinalizerConfig, logger);
             const transactions = profilingData.executedInTON.stageData.transactions;
             for (const tx of transactions) {
                 try {
                     logger.debug(`Verifying transaction: ${tx.hash}`);
-                    await txFinalizer.trackTransactionTree(cclAddress, tx.hash, { maxDepth: 10 });
+                    await txFinalizer.trackTransactionTree(tx.hash);
                     logger.debug(`Transaction ${tx.hash} verified successfully in TON`);
                 }
                 catch (error) {
@@ -99,7 +104,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, txFinalizer, logger = new Logger_1.NoopLogger(), } = options || {};
+    const { customLiteSequencerEndpoints, delay = 10, maxIterationCount = Consts_1.MAX_ITERATION_COUNT, returnValue = false, tableView = true, txFinalizerConfig, 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}`);
@@ -109,7 +114,7 @@ async function startTrackingMultiple(transactionLinkers, network, options) {
             maxIterationCount,
             returnValue: true,
             tableView: false,
-            txFinalizer,
+            txFinalizerConfig,
             logger,
         });
     }));
@@ -155,60 +160,35 @@ function formatExecutionStages(stages) {
         bytesError: data.exists && data.stageData && data.stageData.note != null ? data.stageData.note.internalBytesError : '-',
     }));
 }
-/**
- * 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 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,
+    });
     const tableData = formatExecutionStages(stages);
-    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);
+    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());
 }

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

@@ -1,20 +1,17 @@
-import { Asset, IConfiguration, ILogger, IOperationTracker, ISimulator, ITONTransactionManager } from '../interfaces';
-import { ITxFinalizer } from '../interfaces/ITxFinalizer';
+import { IConfiguration, ILogger, IOperationTracker, ISimulator, ITONTransactionManager } from '../interfaces';
 import type { SenderAbstraction } from '../sender';
-import { BatchCrossChainTx, CrossChainPayloadResult, CrossChainTransactionOptions, CrossChainTransactionsOptions, CrosschainTx, EvmProxyMsg, FeeParams, TransactionLinkerWithOperationId } from '../structs/Struct';
+import { BatchCrossChainTx, 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;
-    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>;
+    constructor(config: IConfiguration, simulator: ISimulator, operationTracker: IOperationTracker, logger?: ILogger);
+    protected 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[]>;
 }

package/dist/src/sdk/TONTransactionManager.js

@@ -1,7 +1,6 @@
 "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");
@@ -10,12 +9,11 @@ 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(), txFinalizer) {
+    constructor(config, simulator, operationTracker, logger = new Logger_1.NoopLogger()) {
         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;
@@ -113,9 +111,6 @@ class TONTransactionManager {
                     address: this.config.TONParams.crossChainLayerAddress,
                     value: crossChainTonAmount + feeTonAmount + Consts_1.TRANSACTION_TON_AMOUNT,
                     payload: await ton.generatePayload({ excessReceiver: caller, evmData, feeParams }),
-                    extra: {
-                        networkFeeIncluded: Consts_1.TRANSACTION_TON_AMOUNT,
-                    },
                 },
             ];
         }
@@ -134,9 +129,6 @@ class TONTransactionManager {
                 address,
                 value: crossChainTonAmount + feeTonAmount + Consts_1.TRANSACTION_TON_AMOUNT,
                 payload,
-                extra: {
-                    networkFeeIncluded: Consts_1.TRANSACTION_TON_AMOUNT,
-                },
             });
             crossChainTonAmount = 0n;
             feeTonAmount = 0n;
@@ -157,17 +149,7 @@ class TONTransactionManager {
         if (!shouldWaitForOperationId) {
             return { sendTransactionResult, ...transactionLinker };
         }
-        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`);
-        }
+        const waitOptions = tx.options?.waitOptions ?? {};
         waitOptions.successCheck = waitOptions.successCheck ?? ((id) => !!id);
         waitOptions.logger = waitOptions.logger ?? this.logger;
         const operationId = await this.operationTracker
@@ -234,23 +216,5 @@ class TONTransactionManager {
             return transactionLinkers;
         }
     }
-    async prepareCrossChainTransactionPayload(evmProxyMsg, senderAddress, assets = [], options) {
-        this.logger.debug('Preparing cross-chain transaction payload');
-        const mockSender = {
-            getSenderAddress: () => senderAddress,
-            sendShardTransaction: async () => ({ success: true, boc: '' }),
-            sendShardTransactions: async () => [],
-            getBalance: async () => 0n,
-            getBalanceOf: async () => 0n,
-        };
-        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,
-            networkFee: r.extra.networkFeeIncluded,
-            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, CrossChainPayloadResult, CrossChainTransactionOptions, CrossChainTransactionsOptions, CrosschainTx, EVMAddress, EvmProxyMsg, ExecutionFeeEstimationResult, NFTAddressType, SDKParams, SuggestedTVMExecutorFee, TACSimulationParams, TACSimulationResult, TransactionLinkerWithOperationId, TVMAddress, UserWalletBalanceExtended } from '../structs/Struct';
+import { AssetFromFTArg, AssetFromNFTCollectionArg, AssetFromNFTItemArg, AssetLike, BatchCrossChainTxWithAssetLike, 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,5 +41,4 @@ 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,7 +11,6 @@ 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) {
@@ -41,8 +40,7 @@ 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 txFinalizer = sdkParams.TONParams?.txFinalizer ?? new TxFinalizer_1.TonTxFinalizer(config.TONParams.contractOpener, logger);
-        const tonTransactionManager = new TONTransactionManager_1.TONTransactionManager(config, simulator, operationTracker, logger, txFinalizer);
+        const tonTransactionManager = new TONTransactionManager_1.TONTransactionManager(config, simulator, operationTracker, logger);
         const tacTransactionManager = new TACTransactionManager_1.TACTransactionManager(config, operationTracker, logger);
         return new TacSdk(config, simulator, tonTransactionManager, tacTransactionManager, operationTracker);
     }
@@ -179,9 +177,5 @@ 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,22 +1,11 @@
-import { ContractOpener, IHttpClient, ILogger } from '../interfaces';
-import { ITxFinalizer } from '../interfaces/ITxFinalizer';
+import { IHttpClient, ILogger } from '../interfaces';
 import { TxFinalizerConfig } from '../structs/InternalStruct';
-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 {
+export declare class TonTxFinalizer {
     private logger;
     private apiConfig;
     private readonly httpClient;
     constructor(apiConfig: TxFinalizerConfig, logger?: ILogger, httpClient?: IHttpClient);
+    private logHashFormats;
     private fetchAdjacentTransactions;
-    trackTransactionTree(_: string, hash: string, params?: {
-        maxDepth?: number;
-    }): Promise<void>;
+    trackTransactionTree(hash: string, maxDepth?: number): Promise<void>;
 }