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

package/dist/src/sdk/OperationTracker.js

@@ -35,96 +35,78 @@ class OperationTracker {
         this.logger = logger;
     }
     async getOperationIdByTransactionHash(transactionHash, waitOptions) {
-        this.logger.debug(`Getting operation ID for transactionHash: ${(0, Utils_1.formatObjectForLogging)(transactionHash)}`);
         const requestFn = async () => {
             let lastError;
             for (const client of this.clients) {
                 try {
                     const id = await client.getOperationIdByTransactionHash(transactionHash);
-                    this.logger.debug(`Operation ID ${id == '' ? 'does not exist' : 'retrieved successfully'}`);
                     return id;
                 }
                 catch (error) {
-                    this.logger.warn(`Failed to get OperationId by transactionHash using one of the endpoints`);
                     lastError = error;
                 }
             }
-            this.logger.error('All endpoints failed to get operation id by transactionHash');
-            throw (0, errors_1.allEndpointsFailedError)(lastError);
+            throw (0, errors_1.allEndpointsFailedError)(lastError, waitOptions?.includeErrorTrace ?? false);
         };
-        return waitOptions
-            ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, 'OperationTracker: Getting operation ID by transaction hash')
-            : await requestFn();
+        return waitOptions === null
+            ? await requestFn()
+            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, `OperationTracker: Getting operation ID by transaction hash ${(0, Utils_1.formatObjectForLogging)(transactionHash)}`);
     }
     async getOperationType(operationId, waitOptions) {
-        this.logger.debug(`Getting operation type for ${(0, Utils_1.formatObjectForLogging)(operationId)}`);
         const requestFn = async () => {
             let lastError;
             for (const client of this.clients) {
                 try {
                     const type = await client.getOperationType(operationId);
-                    this.logger.debug(`Operation retrieved successfully`);
                     return type;
                 }
                 catch (error) {
-                    this.logger.warn(`Failed to get operationType using one of the endpoints`);
                     lastError = error;
                 }
             }
-            this.logger.error('All endpoints failed to get operation type');
-            throw (0, errors_1.allEndpointsFailedError)(lastError);
+            throw (0, errors_1.allEndpointsFailedError)(lastError, waitOptions?.includeErrorTrace ?? false);
         };
-        return waitOptions
-            ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, 'OperationTracker: Getting operation type')
-            : await requestFn();
+        return waitOptions === null
+            ? await requestFn()
+            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, `OperationTracker: Getting operation type for ${(0, Utils_1.formatObjectForLogging)(operationId)}`);
     }
     async getOperationId(transactionLinker, waitOptions) {
-        this.logger.debug(`Getting operation ID for transaction linker: ${(0, Utils_1.formatObjectForLogging)(transactionLinker)}`);
         const requestFn = async () => {
             let lastError;
             for (const client of this.clients) {
                 try {
                     const id = await client.getOperationId(transactionLinker);
-                    this.logger.debug(`Operation ID ${id == '' ? 'does not exist' : 'retrieved successfully'}`);
                     return id;
                 }
                 catch (error) {
-                    this.logger.warn(`Failed to get OperationId using one of the endpoints`);
                     lastError = error;
                 }
             }
-            this.logger.error('All endpoints failed to get operation id');
-            throw (0, errors_1.allEndpointsFailedError)(lastError);
+            throw (0, errors_1.allEndpointsFailedError)(lastError, waitOptions?.includeErrorTrace ?? false);
         };
-        return waitOptions
-            ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, 'OperationTracker: Getting operation ID by transaction linker')
-            : await requestFn();
+        return waitOptions === null
+            ? await requestFn()
+            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, `OperationTracker: Getting operation ID by transaction linker ${(0, Utils_1.formatObjectForLogging)(transactionLinker)}`);
     }
     async getOperationIdsByShardsKeys(shardsKeys, caller, waitOptions, chunkSize = 100) {
-        this.logger.debug(`Getting operation IDs for shards keys: ${(0, Utils_1.formatObjectForLogging)(shardsKeys)}`);
-        this.logger.debug(`Caller: ${caller}, Chunk size: ${chunkSize}`);
         const requestFn = async () => {
             let lastError;
             for (const client of this.clients) {
                 try {
                     const result = await client.getOperationIdsByShardsKeys(shardsKeys, caller, chunkSize);
-                    this.logger.debug(`Operation IDs by shards keys retrieved successfully`);
                     return result;
                 }
                 catch (error) {
-                    this.logger.warn(`Failed to get OperationIds using one of the endpoints`);
                     lastError = error;
                 }
             }
-            this.logger.error('All endpoints failed to get operation ids by shards keys');
-            throw (0, errors_1.allEndpointsFailedError)(lastError);
+            throw (0, errors_1.allEndpointsFailedError)(lastError, waitOptions?.includeErrorTrace ?? false);
         };
-        return waitOptions
-            ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, 'OperationTracker: Getting operation IDs by shards keys')
-            : await requestFn();
+        return waitOptions === null
+            ? await requestFn()
+            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, `OperationTracker: Getting operation IDs by shards keys ${(0, Utils_1.formatObjectForLogging)(shardsKeys)} caller=${caller} chunkSize=${chunkSize}`);
     }
     async getStageProfiling(operationId, waitOptions) {
-        this.logger.debug(`Getting stage profiling for operation ${operationId}`);
         const requestFn = async () => {
             let lastError;
             for (const client of this.clients) {
@@ -132,72 +114,57 @@ class OperationTracker {
                     const map = await client.getStageProfilings([operationId]);
                     const result = map[operationId];
                     if (!result) {
-                        this.logger.warn(`No stageProfiling data for operationId=${operationId}`);
                         throw new Error(`No stageProfiling data for operationId=${operationId}`);
                     }
-                    this.logger.debug(`Stage profiling retrieved successfully`);
                     return result;
                 }
                 catch (error) {
-                    this.logger.warn(`Failed to get stage profiling using one of the endpoints`);
                     lastError = error;
                 }
             }
-            this.logger.error('All endpoints failed to get stage profiling');
-            throw (0, errors_1.allEndpointsFailedError)(lastError);
+            throw (0, errors_1.allEndpointsFailedError)(lastError, waitOptions?.includeErrorTrace ?? false);
         };
-        return waitOptions
-            ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, 'OperationTracker: Getting stage profiling')
-            : await requestFn();
+        return waitOptions === null
+            ? await requestFn()
+            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, `OperationTracker: Getting stage profiling for operation ${operationId}`);
     }
     async getStageProfilings(operationIds, waitOptions, chunkSize = 100) {
-        this.logger.debug(`Getting stage profilings for operations: ${operationIds.join(', ')}`);
-        this.logger.debug(`Chunk size: ${chunkSize}`);
         const requestFn = async () => {
             let lastError;
             for (const client of this.clients) {
                 try {
                     const result = await client.getStageProfilings(operationIds, chunkSize);
-                    this.logger.debug(`Stage profilings retrieved successfully`);
                     return result;
                 }
                 catch (error) {
-                    this.logger.warn(`Failed to get stage profilings using one of the endpoints`);
                     lastError = error;
                 }
             }
-            this.logger.error('All endpoints failed to get stage profilings');
-            throw (0, errors_1.allEndpointsFailedError)(lastError);
+            throw (0, errors_1.allEndpointsFailedError)(lastError, waitOptions?.includeErrorTrace ?? false);
         };
-        return waitOptions
-            ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, 'OperationTracker: Getting stage profilings')
-            : await requestFn();
+        return waitOptions === null
+            ? await requestFn()
+            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, `OperationTracker: Getting stage profilings for operations: ${operationIds.join(', ')} chunkSize=${chunkSize}`);
     }
     async getOperationStatuses(operationIds, waitOptions, chunkSize = 100) {
-        this.logger.debug(`Getting operation statuses for operations: ${(0, Utils_1.formatObjectForLogging)(operationIds)}`);
-        this.logger.debug(`Chunk size: ${chunkSize}`);
         const requestFn = async () => {
             let lastError;
             for (const client of this.clients) {
                 try {
                     const result = await client.getOperationStatuses(operationIds, chunkSize);
-                    this.logger.debug(`Operation statuses retrieved successfully`);
                     return result;
                 }
                 catch (error) {
-                    this.logger.warn(`Failed to get operation statuses using one of the endpoints`);
                     lastError = error;
                 }
             }
-            this.logger.error('All endpoints failed to get operation statuses');
-            throw (0, errors_1.allEndpointsFailedError)(lastError);
+            throw (0, errors_1.allEndpointsFailedError)(lastError, waitOptions?.includeErrorTrace ?? false);
         };
-        return waitOptions
-            ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, 'OperationTracker: Getting operation statuses')
-            : await requestFn();
+        return waitOptions === null
+            ? await requestFn()
+            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, `OperationTracker: Getting operation statuses for operations: ${(0, Utils_1.formatObjectForLogging)(operationIds)} chunkSize=${chunkSize}`);
     }
     async getOperationStatus(operationId, waitOptions) {
-        this.logger.debug(`Getting operation status for ${(0, Utils_1.formatObjectForLogging)(operationId)}`);
         const requestFn = async () => {
             let lastError;
             for (const client of this.clients) {
@@ -205,26 +172,23 @@ class OperationTracker {
                     const map = await client.getOperationStatuses([operationId]);
                     const result = map[operationId];
                     if (!result) {
-                        this.logger.warn(`No operation status for operationId=${operationId}`);
                         throw new Error(`No operation status for operationId=${operationId}`);
                     }
-                    this.logger.debug(`Operation status retrieved successfully`);
                     return result;
                 }
                 catch (error) {
-                    this.logger.warn(`Failed to get operation status using one of the endpoints`);
                     lastError = error;
                 }
             }
-            this.logger.error('All endpoints failed to get operation status');
-            throw (0, errors_1.allEndpointsFailedError)(lastError);
+            throw (0, errors_1.allEndpointsFailedError)(lastError, waitOptions?.includeErrorTrace ?? false);
         };
-        return waitOptions
-            ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, 'OperationTracker: Getting operation status')
-            : await requestFn();
+        const status = waitOptions === null
+            ? await requestFn()
+            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, `OperationTracker: Getting operation status for ${(0, Utils_1.formatObjectForLogging)(operationId)}`);
+        this.logger.debug(`operation status resolved stage=${status.stage ?? 'unknown'} success=${String(status.success)}`);
+        return status;
     }
     async getSimplifiedOperationStatus(transactionLinker) {
-        this.logger.debug(`Getting simplified operation status for transaction linker: ${(0, Utils_1.formatObjectForLogging)(transactionLinker)}`);
         const operationId = await this.getOperationId(transactionLinker);
         if (operationId == '') {
             this.logger.warn('Operation ID not found');
@@ -243,71 +207,59 @@ class OperationTracker {
         if (params.value <= 0n) {
             throw instances_1.convertCurrencyNegativeOrZeroValueError;
         }
-        this.logger.debug(`Converting currency: ${(0, Utils_1.formatObjectForLogging)(params)}`);
         const requestFn = async () => {
             let lastError;
             for (const client of this.clients) {
                 try {
                     const result = await client.convertCurrency(params);
-                    this.logger.debug(`Conversion result retrieved successfully`);
                     return result;
                 }
                 catch (error) {
-                    this.logger.warn(`Failed to convert currency using one of the endpoints`);
                     lastError = error;
                 }
             }
-            this.logger.error('All endpoints failed to convert currency');
-            throw (0, errors_1.allEndpointsFailedError)(lastError);
+            throw (0, errors_1.allEndpointsFailedError)(lastError, waitOptions?.includeErrorTrace ?? false);
         };
-        return waitOptions
-            ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, 'OperationTracker: Converting currency')
-            : await requestFn();
+        return waitOptions === null
+            ? await requestFn()
+            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, `OperationTracker: Converting currency ${(0, Utils_1.formatObjectForLogging)(params)}`);
     }
     async simulateTACMessage(params, waitOptions) {
         Validator_1.Validator.validateTACSimulationParams(params);
-        this.logger.debug(`Simulating TAC message: ${(0, Utils_1.formatObjectForLogging)(params)}`);
         const requestFn = async () => {
             let lastError;
             for (const client of this.clients) {
                 try {
                     const result = await client.simulateTACMessage(params);
-                    this.logger.debug(`Simulation result retrieved successfully`);
                     return result;
                 }
                 catch (error) {
-                    this.logger.warn(`Failed to simulate TAC message using one of the endpoints`);
                     lastError = error;
                 }
             }
-            this.logger.error('All endpoints failed to simulate TAC message');
-            throw (0, errors_1.allEndpointsFailedError)(lastError);
+            throw (0, errors_1.allEndpointsFailedError)(lastError, waitOptions?.includeErrorTrace ?? false);
         };
-        return waitOptions
-            ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, 'OperationTracker: Simulating TAC message')
-            : await requestFn();
+        return waitOptions === null
+            ? await requestFn()
+            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, `OperationTracker: Simulating TAC message ${(0, Utils_1.formatObjectForLogging)(params)}`);
     }
     async getTVMExecutorFee(params, waitOptions) {
-        this.logger.debug(`get TVM executor fee: ${(0, Utils_1.formatObjectForLogging)(params)}`);
         const requestFn = async () => {
             let lastError;
             for (const client of this.clients) {
                 try {
                     const result = await client.getTVMExecutorFee(params);
-                    this.logger.debug(`Suggested TVM executor fee retrieved successfully`);
                     return result;
                 }
                 catch (error) {
-                    this.logger.warn(`Failed to get TVM executor fee using one of the endpoints`);
                     lastError = error;
                 }
             }
-            this.logger.error('All endpoints failed to get TVM executor fee');
-            throw (0, errors_1.allEndpointsFailedError)(lastError);
+            throw (0, errors_1.allEndpointsFailedError)(lastError, waitOptions?.includeErrorTrace ?? false);
         };
-        return waitOptions
-            ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, 'OperationTracker: Getting TVM executor fee')
-            : await requestFn();
+        return waitOptions === null
+            ? await requestFn()
+            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, `OperationTracker: Getting TVM executor fee ${(0, Utils_1.formatObjectForLogging)(params)}`);
     }
 }
 exports.OperationTracker = OperationTracker;

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,12 @@ 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;
+    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 Fees_1 = require("./Fees");
 const Logger_1 = require("./Logger");
 const Utils_1 = require("./Utils");
 const Validator_1 = require("./Validator");
@@ -66,5 +71,102 @@ class Simulator {
         }
         return { feeParams, simulation };
     }
+    calculateTONFees({ 
+    // Contract usage
+    accountBits, accountCells, timeDelta, 
+    // Message size
+    msgBits, msgCells, 
+    // Gas and computation
+    gasUsed, accountBitPrice, accountCellPrice, lumpPrice, gasPrice, firstFrac, ihrPriceFactor, msgBitPrice, msgCellPrice, }) {
+        // Storage Fee (nanotons)
+        const storageFee = Math.ceil(((accountBits * accountBitPrice + accountCells * accountCellPrice) * timeDelta) / Fees_1.FIXED_POINT_SHIFT);
+        // Computation Fee (nanotons)
+        const computeFee = (gasUsed * gasPrice) / Fees_1.FIXED_POINT_SHIFT;
+        // Forwarding Fee (nanotons)
+        const msgFwdFees = lumpPrice + Math.ceil((msgBitPrice * msgBits + msgCellPrice * msgCells) / Fees_1.FIXED_POINT_SHIFT);
+        const ihrFwdFees = Math.ceil((msgFwdFees * ihrPriceFactor) / Fees_1.FIXED_POINT_SHIFT);
+        const totalFwdFees = msgFwdFees + ihrFwdFees;
+        // Action Fee (nanotons)
+        const actionFee = Math.floor((msgFwdFees * firstFrac) / Fees_1.FIXED_POINT_SHIFT);
+        // Combine all fees
+        const totalFees = storageFee + computeFee + actionFee + totalFwdFees;
+        return BigInt(Math.ceil(totalFees));
+    }
+    calculateTransactionPipeline(steps) {
+        return steps.reduce((total, step) => total + this.calculateTONFees({ ...step, ...this.config.TONParams.feesParams }), 0n);
+    }
+    calculateTONCrosschainFee(msgBits, msgCells) {
+        return this.calculateTransactionPipeline([
+            (0, Fees_1.createCrossChainLayerTvmMsgToEvmStep)(this.config.TONParams.contractFeeUsageParams, msgBits, msgCells),
+        ]);
+    }
+    calculateJettonTransferCrosschainFee(msgBits, msgCells) {
+        return this.calculateTransactionPipeline([
+            (0, Fees_1.createJettonWalletInternalTransferStep)(this.config.TONParams.contractFeeUsageParams, msgBits, msgCells),
+            (0, Fees_1.createJettonWalletReceiveStep)(this.config.TONParams.contractFeeUsageParams, msgBits, msgCells),
+            (0, Fees_1.createJettonProxyOwnershipAssignedStep)(this.config.TONParams.contractFeeUsageParams, msgBits, msgCells),
+            (0, Fees_1.createCrossChainLayerTvmMsgToEvmStep)(this.config.TONParams.contractFeeUsageParams, msgBits, msgCells),
+            (0, Fees_1.createErrorNotificationGasStep)(this.config.TONParams.contractFeeUsageParams, msgBits, msgCells),
+            (0, Fees_1.createEstimatedSendTransferGasStep)(this.config.TONParams.contractFeeUsageParams, msgBits, msgCells),
+            (0, Fees_1.createEstimatedReceiveTransferGasStep)(this.config.TONParams.contractFeeUsageParams, msgBits, msgCells),
+        ]);
+    }
+    calculateJettonBurnCrosschainFee(msgBits, msgCells) {
+        return this.calculateTransactionPipeline([
+            (0, Fees_1.createJettonWalletBurnStep)(this.config.TONParams.contractFeeUsageParams, msgBits, msgCells),
+            (0, Fees_1.createJettonMinterBurnNotificationStep)(this.config.TONParams.contractFeeUsageParams, msgBits, msgCells),
+            (0, Fees_1.createCrossChainLayerTvmMsgToEvmStep)(this.config.TONParams.contractFeeUsageParams, msgBits, msgCells),
+            (0, Fees_1.createMintAfterErrorGasStep)(this.config.TONParams.contractFeeUsageParams, msgBits, msgCells),
+            (0, Fees_1.createJettonWalletReceiveStep)(this.config.TONParams.contractFeeUsageParams, msgBits, msgCells),
+        ]);
+    }
+    calculateNftTransferCrosschainFee(msgBits, msgCells) {
+        return this.calculateTransactionPipeline([
+            (0, Fees_1.createNftItemSendStep)(this.config.TONParams.contractFeeUsageParams, msgBits, msgCells),
+            (0, Fees_1.createNftProxyOwnershipAssignedStep)(this.config.TONParams.contractFeeUsageParams, msgBits, msgCells),
+            (0, Fees_1.createCrossChainLayerTvmMsgToEvmStep)(this.config.TONParams.contractFeeUsageParams, msgBits, msgCells),
+            (0, Fees_1.createNftProxyErrorNotificationStep)(this.config.TONParams.contractFeeUsageParams, msgBits, msgCells),
+            (0, Fees_1.createNftItemSendStep)(this.config.TONParams.contractFeeUsageParams, msgBits, msgCells),
+        ]);
+    }
+    calculateNftBurnCrosschainFee(msgBits, msgCells) {
+        return this.calculateTransactionPipeline([
+            (0, Fees_1.createNftItemBurnStep)(this.config.TONParams.contractFeeUsageParams, msgBits, msgCells),
+            (0, Fees_1.createCrossChainLayerTvmMsgToEvmStep)(this.config.TONParams.contractFeeUsageParams, msgBits, msgCells),
+            (0, Fees_1.createNftItemErrorNotificationStep)(this.config.TONParams.contractFeeUsageParams),
+        ]);
+    }
+    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,21 +1,26 @@
-import { ILogger } from '../interfaces';
-import { TxFinalizerConfig } from '../structs/InternalStruct';
-import { ExecutionStages, Network, TransactionLinker } from '../structs/Struct';
-export declare function startTracking(transactionLinker: TransactionLinker, network: Network, options?: {
+import { ContractOpener, ILogger } from '../interfaces';
+import { ITxFinalizer } from '../interfaces/ITxFinalizer';
+import { ExecutionStages, Network, TransactionLinkerWithOperationId } from '../structs/Struct';
+export declare function startTracking(transactionLinker: TransactionLinkerWithOperationId, network: Network, options?: {
     customLiteSequencerEndpoints?: string[];
     delay?: number;
     maxIterationCount?: number;
     returnValue?: boolean;
     tableView?: boolean;
-    txFinalizerConfig?: TxFinalizerConfig;
     logger?: ILogger;
+    txFinalizer?: ITxFinalizer;
+    contractOpener?: ContractOpener;
+    cclAddress?: string;
 }): Promise<void | ExecutionStages>;
-export declare function startTrackingMultiple(transactionLinkers: TransactionLinker[], network: Network, options?: {
+export declare function startTrackingMultiple(transactionLinkers: TransactionLinkerWithOperationId[], network: Network, options?: {
     customLiteSequencerEndpoints?: string[];
     delay?: number;
     maxIterationCount?: number;
     returnValue?: boolean;
     tableView?: boolean;
-    txFinalizerConfig?: TxFinalizerConfig;
     logger?: ILogger;
+    txFinalizer?: ITxFinalizer;
+    contractOpener?: ContractOpener;
+    cclAddress?: string;
 }): Promise<void | ExecutionStages[]>;
+export declare function printExecutionStagesTable(stages: ExecutionStages, logger: ILogger): void;