@tonappchain/sdk 0.7.2-scaled-ui-support-2 → 0.7.2

package/dist/src/sdk/StartTracking.js

@@ -1,26 +1,22 @@
 "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, contractOpener, cclAddress, } = options || {};
     const tracker = new OperationTracker_1.OperationTracker(network, customLiteSequencerEndpoints, logger);
-    logger.debug('Start tracking operation');
-    logger.debug('caller: ' + transactionLinker.caller);
-    logger.debug('shardsKey: ' + transactionLinker.shardsKey);
-    logger.debug('shardCount: ' + transactionLinker.shardCount);
-    logger.debug('timestamp: ' + transactionLinker.timestamp);
-    let operationId = '';
+    logger.debug(`Start tracking operation\n` +
+        `caller: ${transactionLinker.caller}\n` +
+        `shardsKey: ${transactionLinker.shardsKey}\n` +
+        `shardCount: ${transactionLinker.shardCount}\n` +
+        `timestamp: ${transactionLinker.timestamp}`);
+    let operationId = transactionLinker.operationId ?? '';
     let iteration = 0; // number of iterations
     let operationType = '';
     let ok = true; // finished successfully
@@ -37,7 +33,8 @@ async function startTracking(transactionLinker, network, options) {
             try {
                 operationId = await tracker.getOperationId(transactionLinker);
             }
-            catch {
+            catch (err) {
+                logger.debug('failed to get operationId: ' + err);
                 // Ignore error and continue
             }
         }
@@ -67,16 +64,18 @@ async function startTracking(transactionLinker, network, options) {
         logger.debug(errorMessage);
     }
     const profilingData = await tracker.getStageProfiling(operationId);
-    // Check if EXECUTED_IN_TON stage exists and use TxFinalizer to verify transaction success
+    // Check if EXECUTED_IN_TON stage exists and use ContractOpener 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);
+        const finalizer = txFinalizer || contractOpener;
+        if (finalizer && 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 finalizer.trackTransactionTree(cclAddress, tx.hash, {
+                        maxDepth: Consts_1.DEFAULT_FIND_TX_MAX_DEPTH,
+                    });
                     logger.debug(`Transaction ${tx.hash} verified successfully in TON`);
                 }
                 catch (error) {
@@ -88,7 +87,7 @@ async function startTracking(transactionLinker, network, options) {
             }
         }
         else {
-            logger.debug('TxFinalizer config not provided, skipping TON transaction verification');
+            logger.debug('Finalizer, ContractOpener or CCL address is not provided, skipping TON transaction verification');
         }
     }
     if (returnValue) {
@@ -104,7 +103,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, contractOpener, cclAddress, 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 +113,9 @@ async function startTrackingMultiple(transactionLinkers, network, options) {
             maxIterationCount,
             returnValue: true,
             tableView: false,
-            txFinalizerConfig,
+            txFinalizer,
+            contractOpener,
+            cclAddress,
             logger,
         });
     }));
@@ -160,35 +161,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 '\n' + 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,18 @@
-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 { 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>;
+    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,9 +1,11 @@
 "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");
@@ -16,7 +18,7 @@ class TONTransactionManager {
         this.logger = logger;
     }
     async buildFeeParams(options, evmProxyMsg, sender, tx) {
-        const { withoutSimulation, protocolFee, evmExecutorFee, tvmExecutorFee, isRoundTrip } = options;
+        const { withoutSimulation, protocolFee, evmExecutorFee, tvmExecutorFee, isRoundTrip, shouldValidateFees = true, } = options;
         if (withoutSimulation) {
             if (protocolFee === undefined || evmExecutorFee === undefined) {
                 throw errors_1.missingFeeParamsError;
@@ -38,6 +40,20 @@ class TONTransactionManager {
         const simulationResult = await this.simulator.getSimulationInfo(sender, tx);
         if (!evmProxyMsg.gasLimit)
             evmProxyMsg.gasLimit = simulationResult.feeParams.gasLimit;
+        const shouldValidateSuggestedFees = shouldValidateFees && (simulationResult.simulation?.simulationStatus ?? true);
+        if (shouldValidateSuggestedFees) {
+            if (protocolFee !== undefined && protocolFee < simulationResult.feeParams.protocolFee) {
+                throw (0, errors_1.insufficientFeeParamsError)('protocolFee', protocolFee, simulationResult.feeParams.protocolFee);
+            }
+            if (evmExecutorFee !== undefined && evmExecutorFee < simulationResult.feeParams.evmExecutorFee) {
+                throw (0, errors_1.insufficientFeeParamsError)('evmExecutorFee', evmExecutorFee, simulationResult.feeParams.evmExecutorFee);
+            }
+            if (simulationResult.feeParams.isRoundTrip &&
+                tvmExecutorFee !== undefined &&
+                tvmExecutorFee < simulationResult.feeParams.tvmExecutorFee) {
+                throw (0, errors_1.insufficientFeeParamsError)('tvmExecutorFee', tvmExecutorFee, simulationResult.feeParams.tvmExecutorFee);
+            }
+        }
         return {
             protocolFee: protocolFee ?? simulationResult.feeParams.protocolFee,
             evmExecutorFee: evmExecutorFee ?? simulationResult.feeParams.evmExecutorFee,
@@ -46,12 +62,13 @@ 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) {
         this.logger.debug('Preparing cross-chain transaction');
         const caller = sender.getSenderAddress();
-        const { allowSimulationError = false, isRoundTrip = undefined, calculateRollbackFee = true, validateAssetsBalance = true, } = options || {};
+        const { allowSimulationError = false, isRoundTrip = undefined, calculateRollbackFee = true, validateAssetsBalance = true, evmDataBuilder = Utils_1.buildEvmDataCell, } = options || {};
         const { evmValidExecutors = [], tvmValidExecutors = [] } = options || {};
         Validator_1.Validator.validateEVMAddress(evmProxyMsg.evmTargetAddress);
         const aggregatedData = (0, Utils_1.aggregateTokens)(assets);
@@ -87,7 +104,7 @@ class TONTransactionManager {
             tac: tacExecutors,
             ton: tonExecutors,
         };
-        const evmData = (0, Utils_1.buildEvmDataCell)(transactionLinker, evmProxyMsg, validExecutors);
+        const evmData = evmDataBuilder(transactionLinker, evmProxyMsg, validExecutors);
         const messages = await this.generateCrossChainMessages(caller, evmData, aggregatedData, feeParams);
         return {
             transaction: {
@@ -106,29 +123,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;
@@ -140,16 +173,25 @@ class TONTransactionManager {
     async sendCrossChainTransaction(evmProxyMsg, sender, tx) {
         const { transaction, transactionLinker } = await this.prepareCrossChainTransaction(evmProxyMsg, sender, tx.assets, tx.options);
         await assets_1.TON.checkBalance(sender, this.config, [transaction]);
+        const shouldWaitForOperationId = tx.options?.waitOperationId ?? true;
         this.logger.debug(`Sending transaction: ${(0, Utils_1.formatObjectForLogging)(transactionLinker)}`);
         const sendTransactionResult = await sender.sendShardTransaction(transaction, this.config.network, this.config.TONParams.contractOpener);
         if (!sendTransactionResult.success || sendTransactionResult.error) {
             throw (0, instances_1.sendCrossChainTransactionFailedError)(sendTransactionResult.error?.message ?? 'Transaction failed to send');
         }
-        const shouldWaitForOperationId = tx.options?.waitOperationId ?? true;
         if (!shouldWaitForOperationId) {
             return { sendTransactionResult, ...transactionLinker };
         }
         const waitOptions = tx.options?.waitOptions ?? {};
+        const ensureTxExecuted = tx.options?.ensureTxExecuted ?? true;
+        if (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.config.TONParams.contractOpener.trackTransactionTree(sender.getSenderAddress(), hash, {
+                maxDepth: Consts_1.DEFAULT_FIND_TX_MAX_DEPTH,
+            });
+            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 +258,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/TacExplorerClient.d.ts

@@ -0,0 +1,8 @@
+import { IHttpClient, ITacExplorerClient } from '../interfaces';
+import { TacGasPriceResponse } from '../structs/InternalStruct';
+export declare class TacExplorerClient implements ITacExplorerClient {
+    private readonly explorerApiEndpoint;
+    private readonly httpClient;
+    constructor(explorerApiEndpoint: string, httpClient?: IHttpClient);
+    getTACGasPrice(): Promise<TacGasPriceResponse>;
+}

package/dist/src/sdk/TacExplorerClient.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TacExplorerClient = void 0;
+const instances_1 = require("../errors/instances");
+const AxiosHttpClient_1 = require("./AxiosHttpClient");
+const Utils_1 = require("./Utils");
+class TacExplorerClient {
+    constructor(explorerApiEndpoint, httpClient = new AxiosHttpClient_1.AxiosHttpClient()) {
+        this.explorerApiEndpoint = explorerApiEndpoint;
+        this.httpClient = httpClient;
+    }
+    async getTACGasPrice() {
+        try {
+            const response = await this.httpClient.get(new URL('stats', this.explorerApiEndpoint).toString(), { transformResponse: [Utils_1.toCamelCaseTransformer] });
+            return response.data;
+        }
+        catch (error) {
+            throw (0, instances_1.gasPriceFetchError)(`endpoint ${this.explorerApiEndpoint} failed to complete request`, error);
+        }
+    }
+}
+exports.TacExplorerClient = TacExplorerClient;

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

@@ -1,12 +1,14 @@
 import { Wallet } from 'ethers';
 import { JettonMinterData, NFTItemData } from '../../artifacts/tonTypes';
 import { FT, NFT } from '../assets';
-import { IConfiguration, ILogger, IOperationTracker, ITacSDK } from '../interfaces';
+import { ContractOpener, IConfiguration, ILogger, IOperationTracker, ITacExplorerClient, 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, TacGasPrice, TACSimulationParams, TACSimulationResult, TransactionLinkerWithOperationId, TVMAddress, UserWalletBalanceExtended } from '../structs/Struct';
 export declare class TacSdk implements ITacSDK {
     readonly config: IConfiguration;
+    readonly contactOpener: ContractOpener;
     readonly operationTracker: IOperationTracker;
+    readonly explorerClient: ITacExplorerClient;
     private readonly simulator;
     private readonly tonTransactionManager;
     private readonly tacTransactionManager;
@@ -41,4 +43,8 @@ export declare class TacSdk implements ITacSDK {
     getTVMNFTAddress(evmNFTAddress: string, tokenId?: number | bigint): Promise<string>;
     getEVMNFTAddress(tvmNFTAddress: string, addressType: NFTAddressType): Promise<string>;
     getOperationTracker(): IOperationTracker;
+    getTacExplorerClient(): ITacExplorerClient;
+    prepareCrossChainTransactionPayload(evmProxyMsg: EvmProxyMsg, senderAddress: string, assets?: AssetLike[], options?: CrossChainTransactionOptions): Promise<CrossChainPayloadResult[]>;
+    getTACGasPrice(): Promise<TacGasPrice>;
+    getTonContractOpener(): ContractOpener;
 }

package/dist/src/sdk/TacSdk.js

@@ -9,20 +9,24 @@ const Consts_1 = require("./Consts");
 const Logger_1 = require("./Logger");
 const OperationTracker_1 = require("./OperationTracker");
 const Simulator_1 = require("./Simulator");
+const TacExplorerClient_1 = require("./TacExplorerClient");
 const TACTransactionManager_1 = require("./TACTransactionManager");
 const TONTransactionManager_1 = require("./TONTransactionManager");
 const Utils_1 = require("./Utils");
 class TacSdk {
-    constructor(config, simulator, tonTransactionManager, tacTransactionManager, operationTracker) {
+    constructor(config, simulator, tonTransactionManager, tacTransactionManager, operationTracker, explorerClient) {
         this.config = config;
+        this.contactOpener = config.TONParams.contractOpener;
         this.simulator = simulator;
         this.tonTransactionManager = tonTransactionManager;
         this.tacTransactionManager = tacTransactionManager;
         this.operationTracker = operationTracker;
+        this.explorerClient = explorerClient;
     }
     static async create(sdkParams, logger = new Logger_1.NoopLogger()) {
         const network = sdkParams.network;
         const delay = sdkParams.delay ?? Consts_1.DEFAULT_DELAY;
+        const passLoggerToOpeners = sdkParams.passLoggerToOpeners ?? true;
         let artifacts;
         switch (network) {
             case Struct_1.Network.MAINNET:
@@ -37,12 +41,13 @@ class TacSdk {
             default:
                 throw new Error(`Unsupported network: ${network}`);
         }
-        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 config = await Configuration_1.Configuration.create(network, artifacts, sdkParams.TONParams, sdkParams.TACParams, sdkParams.customLiteSequencerEndpoints, delay, logger, passLoggerToOpeners);
+        const operationTracker = new OperationTracker_1.OperationTracker(network, config.liteSequencerEndpoints, logger);
+        const explorerClient = new TacExplorerClient_1.TacExplorerClient(artifacts.TAC_EXPLORER_API_ENDPOINT);
         const simulator = new Simulator_1.Simulator(config, operationTracker, logger);
         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);
+        return new TacSdk(config, simulator, tonTransactionManager, tacTransactionManager, operationTracker, explorerClient);
     }
     closeConnections() {
         return this.config.closeConnections();
@@ -177,5 +182,23 @@ class TacSdk {
     getOperationTracker() {
         return this.operationTracker;
     }
+    getTacExplorerClient() {
+        return this.explorerClient;
+    }
+    async prepareCrossChainTransactionPayload(evmProxyMsg, senderAddress, assets = [], options) {
+        const normalizedAssets = await (0, Utils_1.normalizeAssets)(this.config, assets);
+        return this.tonTransactionManager.prepareCrossChainTransactionPayload(evmProxyMsg, senderAddress, normalizedAssets, options);
+    }
+    async getTACGasPrice() {
+        const response = await this.explorerClient.getTACGasPrice();
+        return {
+            average: response.gasPrices.average,
+            fast: response.gasPrices.fast,
+            slow: response.gasPrices.slow,
+        };
+    }
+    getTonContractOpener() {
+        return this.contactOpener;
+    }
 }
 exports.TacSdk = TacSdk;

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

@@ -1,11 +1,12 @@
 import { IHttpClient, ILogger } from '../interfaces';
+import { ITxFinalizer } from '../interfaces/ITxFinalizer';
 import { TxFinalizerConfig } from '../structs/InternalStruct';
-export declare class TonTxFinalizer {
+import { TrackTransactionTreeParams } from '../structs/Struct';
+export declare class TonTxFinalizer 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?: TrackTransactionTreeParams): Promise<void>;
 }

package/dist/src/sdk/TxFinalizer.js

@@ -1,43 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TonTxFinalizer = void 0;
+const errors_1 = require("../errors");
 const AxiosHttpClient_1 = require("./AxiosHttpClient");
+const Consts_1 = require("./Consts");
 const Logger_1 = require("./Logger");
 const Utils_1 = require("./Utils");
-const IGNORE_OPCODE = [
-    '0xd53276db', // Excess
-    '0x7362d09c', // Jetton Notify
-];
 class TonTxFinalizer {
     constructor(apiConfig, logger = new Logger_1.NoopLogger(), httpClient = new AxiosHttpClient_1.AxiosHttpClient()) {
         this.apiConfig = apiConfig;
         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');
-        }
-        else {
-            base64 = hash;
-            const buffer = Buffer.from(base64, 'base64');
-            hex = '0x' + buffer.toString('hex');
-        }
-        return { hex: hex, base64: base64 };
-    }
     // Fetches adjacent transactions from toncenter
-    async fetchAdjacentTransactions(hash, retries = 5, delay = 1000) {
+    async fetchAdjacentTransactions(hash, retries = Consts_1.DEFAULT_RETRY_MAX_COUNT, delay = Consts_1.DEFAULT_RETRY_DELAY_MS) {
         for (let i = retries; i >= 0; i--) {
             try {
                 const url = this.apiConfig.urlBuilder(hash);
+                const authHeaders = this.apiConfig.authorization
+                    ? { [this.apiConfig.authorization.header]: this.apiConfig.authorization.value }
+                    : undefined;
                 const response = await this.httpClient.get(url, {
-                    headers: {
-                        [this.apiConfig.authorization.header]: this.apiConfig.authorization.value,
-                    },
+                    ...(authHeaders ? { headers: authHeaders } : {}),
                     transformResponse: [Utils_1.toCamelCaseTransformer],
                 });
                 return response.data.transactions || [];
@@ -54,7 +38,7 @@ class TonTxFinalizer {
                 // Log all errors except 404 Not Found
                 if (!errorMessage.includes('404')) {
                     const logMessage = error instanceof Error ? error.message : error;
-                    console.warn(`Failed to fetch adjacent transactions for ${hash}:`, logMessage);
+                    this.logger.warn(`Failed to fetch adjacent transactions for ${hash}:`, logMessage);
                 }
                 if (i > 0) {
                     await (0, Utils_1.sleep)(delay);
@@ -64,7 +48,8 @@ class TonTxFinalizer {
         return [];
     }
     // Checks if all transactions in the tree are successful
-    async trackTransactionTree(hash, maxDepth = 10) {
+    async trackTransactionTree(_, hash, params = { maxDepth: Consts_1.DEFAULT_FIND_TX_MAX_DEPTH, ignoreOpcodeList: Consts_1.IGNORE_OPCODE }) {
+        const { maxDepth = Consts_1.DEFAULT_FIND_TX_MAX_DEPTH, ignoreOpcodeList = Consts_1.IGNORE_OPCODE } = params;
         const visitedHashes = new Set();
         const queue = [{ hash, depth: 0 }];
         while (queue.length > 0) {
@@ -73,25 +58,40 @@ 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) {
-                    const { aborted, computePh: compute_ph, action } = tx.description;
-                    if (aborted ||
-                        !compute_ph.success ||
-                        !action.success ||
-                        compute_ph.exitCode !== 0 ||
-                        action.resultCode !== 0) {
-                        throw new Error(`Transaction failed:\n` +
-                            `hash = ${currentHash}, ` +
-                            `aborted = ${aborted}, ` +
-                            `compute_ph.success = ${compute_ph.success}, ` +
-                            `compute_ph.exit_code = ${compute_ph.exitCode}, ` +
-                            `action.success = ${action.success}, ` +
-                            `action.result_code = ${action.resultCode}`);
+                if (tx.inMsg.value === Consts_1.IGNORE_MSG_VALUE_1_NANO.toString())
+                    continue; // we ignore messages with 1 nanoton value as they are for notification purpose only
+                if (!ignoreOpcodeList.includes(Number(tx.inMsg.opcode)) && tx.inMsg.opcode !== null) {
+                    const { aborted, computePh, action } = tx.description;
+                    const failureCase = (() => {
+                        if (aborted) {
+                            return 'Transaction was aborted';
+                        }
+                        if (!computePh) {
+                            return 'computePh not present';
+                        }
+                        if (!computePh.success) {
+                            return 'computePh not successful';
+                        }
+                        if (computePh.exitCode !== 0) {
+                            return `computePh.exitCode was not zero`;
+                        }
+                        if (action && !action.success) {
+                            return 'action not successful';
+                        }
+                        if (action && action.resultCode !== 0) {
+                            return `action.resultCode was not zero`;
+                        }
+                        return null;
+                    })();
+                    if (failureCase) {
+                        const exitCode = computePh ? computePh.exitCode : 'N/A';
+                        const resultCode = action ? action.resultCode : 'N/A';
+                        throw (0, errors_1.txFinalizationError)(`${tx.hash}: ${failureCase} (exitCode=${exitCode}, resultCode=${resultCode})`);
                     }
                     if (currentDepth + 1 < maxDepth) {
                         if (tx.outMsgs.length > 0) {
@@ -100,7 +100,7 @@ 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}`);
                 }
             }
         }