@tonappchain/sdk 0.6.5-mainnet-alpha → 0.7.0-rc7

package/dist/sdk/Simulator.js

@@ -0,0 +1,169 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Simulator = exports.AxiosHttpClient = void 0;
+const ton_1 = require("@ton/ton");
+const axios_1 = __importDefault(require("axios"));
+const errors_1 = require("../errors");
+const Logger_1 = require("./Logger");
+const Utils_1 = require("./Utils");
+const Validator_1 = require("./Validator");
+class AxiosHttpClient {
+    async post(url, data, config) {
+        return axios_1.default.post(url, data, config);
+    }
+}
+exports.AxiosHttpClient = AxiosHttpClient;
+class Simulator {
+    constructor(config, logger = new Logger_1.NoopLogger(), httpClient = new AxiosHttpClient()) {
+        this.config = config;
+        this.logger = logger;
+        this.httpClient = httpClient;
+    }
+    async simulateTACMessage(req) {
+        Validator_1.Validator.validateTACSimulationRequest(req);
+        this.logger.debug('Simulating TAC message');
+        let lastError;
+        for (const endpoint of this.config.liteSequencerEndpoints) {
+            try {
+                const response = await this.httpClient.post(new URL('tac/simulator/simulate-message', endpoint).toString(), req, {
+                    transformResponse: [Utils_1.toCamelCaseTransformer],
+                });
+                this.logger.debug('TAC message simulation success');
+                return response.data.response;
+            }
+            catch (error) {
+                this.logger.error(`Error while simulating with ${endpoint}: ${error}`);
+                lastError = error;
+            }
+        }
+        throw (0, errors_1.simulationError)(lastError);
+    }
+    async simulateTransactions(sender, txs) {
+        this.logger.debug(`Simulating ${txs.length} TAC messages`);
+        const results = [];
+        for (const tx of txs) {
+            const req = await this.buildTACSimulationRequest(sender, tx);
+            const result = await this.simulateTACMessage(req);
+            results.push(result);
+        }
+        return results;
+    }
+    async buildTACSimulationRequest(sender, tx) {
+        const { evmProxyMsg, assets = [], options = {} } = tx;
+        const { evmValidExecutors = this.config.TACParams.trustedTACExecutors, tvmValidExecutors = this.config.TACParams.trustedTONExecutors, } = options;
+        Validator_1.Validator.validateEVMAddresses(evmValidExecutors);
+        Validator_1.Validator.validateTVMAddresses(tvmValidExecutors);
+        const aggregatedData = await (0, Utils_1.aggregateTokens)(assets);
+        const transactionLinkerShardCount = aggregatedData.jettons.length == 0 ? 1 : aggregatedData.jettons.length;
+        const transactionLinker = (0, Utils_1.generateTransactionLinker)(sender.getSenderAddress(), transactionLinkerShardCount);
+        return {
+            tacCallParams: {
+                arguments: evmProxyMsg.encodedParameters ?? '0x',
+                methodName: (0, Utils_1.formatSolidityMethodName)(evmProxyMsg.methodName),
+                target: evmProxyMsg.evmTargetAddress,
+            },
+            evmValidExecutors: evmValidExecutors,
+            tvmValidExecutors: tvmValidExecutors,
+            extraData: '0x',
+            shardsKey: transactionLinker.shardsKey,
+            tonAssets: assets.map((asset) => ({
+                amount: asset.rawAmount.toString(),
+                tokenAddress: asset.address || '',
+                assetType: asset.type,
+            })),
+            tonCaller: transactionLinker.caller,
+        };
+    }
+    async getTVMExecutorFeeInfo(assets, feeSymbol) {
+        this.logger.debug('Getting TVM executor fee info');
+        const requestBody = {
+            tonAssets: assets.map((asset) => ({
+                amount: asset.rawAmount.toString(),
+                tokenAddress: asset.address || '',
+                assetType: asset.type,
+            })),
+            feeSymbol: feeSymbol,
+        };
+        let lastError;
+        for (const endpoint of this.config.liteSequencerEndpoints) {
+            try {
+                const response = await this.httpClient.post(`${endpoint}/ton/calculator/ton-executor-fee`, requestBody);
+                return response.data.response;
+            }
+            catch (error) {
+                this.logger.error(`Error while calculating tvm executor fee ${endpoint}: ${error}`);
+                lastError = error;
+            }
+        }
+        this.logger.error('Error while calculating tvm executor fee on all endpoints');
+        throw (0, errors_1.simulationError)(lastError);
+    }
+    async getFeeInfo(evmProxyMsg, transactionLinker, assets, allowSimulationError = false, isRoundTrip = true, evmValidExecutors = this.config.TACParams.trustedTACExecutors, tvmValidExecutors = this.config.TACParams.trustedTONExecutors) {
+        this.logger.debug('Getting fee info');
+        Validator_1.Validator.validateEVMAddress(evmProxyMsg.evmTargetAddress);
+        Validator_1.Validator.validateEVMAddresses(evmValidExecutors);
+        Validator_1.Validator.validateTVMAddresses(tvmValidExecutors);
+        const crossChainLayer = this.config.TONParams.contractOpener.open(this.config.artifacts.ton.wrappers.CrossChainLayer.createFromAddress(ton_1.Address.parse(this.config.TONParams.crossChainLayerAddress)));
+        const fullStateCCL = await crossChainLayer.getFullData();
+        this.logger.debug(`Full state CCL: ${(0, Utils_1.formatObjectForLogging)(fullStateCCL)}`);
+        const tacSimulationBody = {
+            tacCallParams: {
+                arguments: evmProxyMsg.encodedParameters ?? '0x',
+                methodName: (0, Utils_1.formatSolidityMethodName)(evmProxyMsg.methodName),
+                target: evmProxyMsg.evmTargetAddress,
+            },
+            evmValidExecutors: evmValidExecutors,
+            tvmValidExecutors: tvmValidExecutors,
+            extraData: '0x',
+            shardsKey: transactionLinker.shardsKey,
+            tonAssets: assets.map((asset) => ({
+                amount: asset.rawAmount.toString(),
+                tokenAddress: asset.address || '',
+                assetType: asset.type,
+            })),
+            tonCaller: transactionLinker.caller,
+        };
+        isRoundTrip = isRoundTrip ?? assets.length != 0;
+        this.logger.debug(`Is round trip: ${isRoundTrip}`);
+        const tacSimulationResult = await this.simulateTACMessage(tacSimulationBody);
+        this.logger.debug(`TAC simulation ${tacSimulationResult.simulationStatus ? 'success' : 'failed'}`);
+        const protocolFee = BigInt((0, ton_1.toNano)(fullStateCCL.tacProtocolFee)) +
+            BigInt(isRoundTrip) * BigInt((0, ton_1.toNano)(fullStateCCL.tonProtocolFee));
+        const feeParams = {
+            isRoundTrip: isRoundTrip,
+            gasLimit: !tacSimulationResult.simulationStatus ? 0n : tacSimulationResult.estimatedGas,
+            protocolFee: protocolFee,
+            evmExecutorFee: BigInt(tacSimulationResult.suggestedTacExecutionFee),
+            tvmExecutorFee: BigInt(tacSimulationResult.suggestedTonExecutionFee) * BigInt(isRoundTrip),
+        };
+        if (!tacSimulationResult.simulationStatus) {
+            if (allowSimulationError) {
+                this.logger.info('Force send is true, returning fee params');
+                return {
+                    feeParams,
+                    simulation: tacSimulationResult,
+                };
+            }
+            throw tacSimulationResult;
+        }
+        this.logger.debug(`Collected fee params: ${(0, Utils_1.formatObjectForLogging)(feeParams)}`);
+        return { feeParams, simulation: tacSimulationResult };
+    }
+    async getTransactionSimulationInfo(evmProxyMsg, sender, assets) {
+        this.logger.debug('Getting transaction simulation info');
+        Validator_1.Validator.validateEVMAddress(evmProxyMsg.evmTargetAddress);
+        const aggregatedData = await (0, Utils_1.aggregateTokens)(assets);
+        const transactionLinkerShardCount = aggregatedData.jettons.length == 0 ? 1 : aggregatedData.jettons.length;
+        this.logger.debug(`Transaction linker shard count: ${transactionLinkerShardCount}`);
+        const transactionLinker = (0, Utils_1.generateTransactionLinker)(sender.getSenderAddress(), transactionLinkerShardCount);
+        this.logger.debug(`Transaction linker: ${(0, Utils_1.formatObjectForLogging)(transactionLinker)}`);
+        return await this.getFeeInfo(evmProxyMsg, transactionLinker, assets ?? []);
+    }
+    async getSimulationInfoForTransaction(evmProxyMsg, transactionLinker, assets, allowSimulationError = false, isRoundTrip, evmValidExecutors, tvmValidExecutors) {
+        return await this.getFeeInfo(evmProxyMsg, transactionLinker, assets, allowSimulationError, isRoundTrip, evmValidExecutors, tvmValidExecutors);
+    }
+}
+exports.Simulator = Simulator;

package/dist/sdk/StartTracking.d.ts

@@ -1,3 +1,5 @@
+import { TxFinalizerConfig } from '../structs/InternalStruct';
+import { ILogger } from '../structs/Services';
 import { ExecutionStages, Network, TransactionLinker } from '../structs/Struct';
 export declare function startTracking(transactionLinker: TransactionLinker, network: Network, options?: {
     customLiteSequencerEndpoints?: string[];
@@ -5,6 +7,8 @@ export declare function startTracking(transactionLinker: TransactionLinker, netw
     maxIterationCount?: number;
     returnValue?: boolean;
     tableView?: boolean;
+    txFinalizerConfig?: TxFinalizerConfig;
+    logger?: ILogger;
 }): Promise<void | ExecutionStages>;
 export declare function startTrackingMultiple(transactionLinkers: TransactionLinker[], network: Network, options?: {
     customLiteSequencerEndpoints?: string[];
@@ -12,4 +16,6 @@ export declare function startTrackingMultiple(transactionLinkers: TransactionLin
     maxIterationCount?: number;
     returnValue?: boolean;
     tableView?: boolean;
+    txFinalizerConfig?: TxFinalizerConfig;
+    logger?: ILogger;
 }): Promise<void | ExecutionStages[]>;

package/dist/sdk/StartTracking.js

@@ -5,19 +5,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startTracking = startTracking;
 exports.startTrackingMultiple = startTrackingMultiple;
+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");
-const cli_table3_1 = __importDefault(require("cli-table3"));
 async function startTracking(transactionLinker, network, options) {
-    const { customLiteSequencerEndpoints, delay = 10, maxIterationCount = Consts_1.MAX_ITERATION_COUNT, returnValue = false, tableView = true, } = options || {};
-    const tracker = new OperationTracker_1.OperationTracker(network, customLiteSequencerEndpoints);
-    console.log('Start tracking operation');
-    console.log('caller: ', transactionLinker.caller);
-    console.log('shardsKey: ', transactionLinker.shardsKey);
-    console.log('shardCount: ', transactionLinker.shardCount);
-    console.log('timestamp: ', transactionLinker.timestamp);
+    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);
+    logger.debug('shardsKey: ' + transactionLinker.shardsKey);
+    logger.debug('shardCount: ' + transactionLinker.shardCount);
+    logger.debug('timestamp: ' + transactionLinker.timestamp);
     let operationId = '';
     let iteration = 0; // number of iterations
     let operationType = '';
@@ -31,11 +33,13 @@ async function startTracking(transactionLinker, network, options) {
             break;
         }
         if (operationId == '') {
-            console.log('request operationId');
+            logger.debug('request operationId');
             try {
                 operationId = await tracker.getOperationId(transactionLinker);
             }
-            catch (err) { }
+            catch {
+                // Ignore error and continue
+            }
         }
         else {
             try {
@@ -45,9 +49,9 @@ async function startTracking(transactionLinker, network, options) {
                 }
             }
             catch (err) {
-                console.log('failed to get operation type:', err);
+                logger.debug('failed to get operation type: ' + err);
             }
-            console.log(`
+            logger.debug(`
                 operationId: ${operationId}
                 operationType: ${operationType}
                 time: ${new Date().toISOString()} (${Math.floor(+new Date() / 1000)})
@@ -55,37 +59,63 @@ async function startTracking(transactionLinker, network, options) {
         }
         await (0, Utils_1.sleep)(delay * 1000);
     }
-    console.log('Tracking finished');
+    logger.debug('Tracking finished');
     if (!ok) {
         if (returnValue) {
             throw Error(errorMessage);
         }
-        console.log(errorMessage);
+        logger.debug(errorMessage);
     }
     const profilingData = await tracker.getStageProfiling(operationId);
+    // Check if EXECUTED_IN_TON stage exists and use TxFinalizer to verify transaction success
+    if (profilingData.executedInTON.exists && profilingData.executedInTON.stageData?.transactions) {
+        logger.debug('EXECUTED_IN_TON stage found, verifying transaction success in TON...');
+        if (txFinalizerConfig) {
+            const txFinalizer = new TxFinalizer_1.TonTxFinalizer(txFinalizerConfig, logger);
+            const transactions = profilingData.executedInTON.stageData.transactions;
+            for (const tx of transactions) {
+                try {
+                    logger.debug(`Verifying transaction: ${tx.hash}`);
+                    await txFinalizer.trackTransactionTree(tx.hash);
+                    logger.debug(`Transaction ${tx.hash} verified successfully in TON`);
+                }
+                catch (error) {
+                    logger.debug(`Transaction ${tx.hash} failed verification in TON: ${error}`);
+                    if (returnValue) {
+                        throw error;
+                    }
+                }
+            }
+        }
+        else {
+            logger.debug('TxFinalizer config not provided, skipping TON transaction verification');
+        }
+    }
     if (returnValue) {
         return profilingData;
     }
-    console.log(profilingData.operationType);
-    console.log(profilingData.metaInfo);
+    logger.debug(profilingData.operationType);
+    logger.debug(profilingData.metaInfo);
     if (tableView) {
-        printExecutionStagesTable(profilingData);
+        printExecutionStagesTable(profilingData, logger);
     }
     else {
-        console.log(formatExecutionStages(profilingData));
+        logger.debug(formatExecutionStages(profilingData));
     }
 }
 async function startTrackingMultiple(transactionLinkers, network, options) {
-    const { customLiteSequencerEndpoints, delay = 10, maxIterationCount = Consts_1.MAX_ITERATION_COUNT, returnValue = false, tableView = true, } = options || {};
-    console.log(`Start tracking ${transactionLinkers.length} operations`);
+    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) => {
-        console.log(`\nProcessing operation ${index + 1}/${transactionLinkers.length}`);
+        logger.debug(`\nProcessing operation ${index + 1}/${transactionLinkers.length}`);
         return startTracking(linker, network, {
             customLiteSequencerEndpoints,
             delay,
             maxIterationCount,
             returnValue: true,
             tableView: false,
+            txFinalizerConfig,
+            logger,
         });
     }));
     if (returnValue) {
@@ -93,20 +123,27 @@ async function startTrackingMultiple(transactionLinkers, network, options) {
     }
     if (tableView) {
         results.forEach((result, index) => {
-            console.log(`\nResults for operation ${index + 1}:`);
-            printExecutionStagesTable(result);
+            logger.debug(`\nResults for operation ${index + 1}:`);
+            printExecutionStagesTable(result, logger);
         });
     }
     else {
         results.forEach((result, index) => {
-            console.log(`\nResults for operation ${index + 1}:`);
-            console.log(formatExecutionStages(result));
+            logger.debug(`\nResults for operation ${index + 1}:`);
+            logger.debug(formatExecutionStages(result));
         });
     }
 }
 function formatExecutionStages(stages) {
-    const { operationType, metaInfo, ...stagesData } = stages;
-    return Object.entries(stagesData).map(([stage, data]) => ({
+    const { collectedInTAC, includedInTACConsensus, executedInTAC, collectedInTON, includedInTONConsensus, executedInTON, } = stages;
+    return Object.entries({
+        collectedInTAC,
+        includedInTACConsensus,
+        executedInTAC,
+        collectedInTON,
+        includedInTONConsensus,
+        executedInTON,
+    }).map(([stage, data]) => ({
         stage: stage,
         exists: data.exists ? 'Yes' : 'No',
         success: data.exists && data.stageData ? (data.stageData.success ? 'Yes' : 'No') : '-',
@@ -123,7 +160,7 @@ function formatExecutionStages(stages) {
         bytesError: data.exists && data.stageData && data.stageData.note != null ? data.stageData.note.internalBytesError : '-',
     }));
 }
-function printExecutionStagesTable(stages) {
+function printExecutionStagesTable(stages, logger) {
     const table = new cli_table3_1.default({
         head: [
             'Stage',
@@ -153,5 +190,5 @@ function printExecutionStagesTable(stages) {
             row.bytesError,
         ]);
     });
-    console.log(table.toString());
+    logger.debug(table.toString());
 }

package/dist/sdk/TacSdk.d.ts

@@ -1,53 +1,24 @@
 import { Wallet } from 'ethers';
 import type { SenderAbstraction } from '../sender';
-import { AssetBridgingData, EvmProxyMsg, Network, SDKParams, TransactionLinker, RawAssetBridgingData, UserWalletBalanceExtended, TACSimulationResult, TACSimulationRequest, SuggestedTONExecutorFee, CrossChainTransactionOptions, ExecutionFeeEstimationResult, CrosschainTx, WithAddressNFTCollectionItem, NFTAddressType, NFTItemData } from '../structs/Struct';
-import { InternalTONParams, InternalTACParams } from '../structs/InternalStruct';
-import { mainnet, testnet } from '@tonappchain/artifacts';
+import { IConfiguration, ILogger } from '../structs/Services';
+import { Asset, CrossChainTransactionOptions, CrosschainTx, EvmProxyMsg, ExecutionFeeEstimationResult, OperationIdsByShardsKey, SDKParams, SuggestedTONExecutorFee, TACSimulationRequest, TACSimulationResult, TransactionLinkerWithOperationId, WaitOptions } from '../structs/Struct';
 export declare class TacSdk {
-    readonly network: Network;
-    readonly delay: number;
-    readonly artifacts: typeof testnet | typeof mainnet;
-    readonly TONParams: InternalTONParams;
-    readonly TACParams: InternalTACParams;
-    readonly liteSequencerEndpoints: string[];
+    readonly config: IConfiguration;
+    private readonly simulator;
+    private readonly transactionManager;
     private constructor();
-    static create(sdkParams: SDKParams): Promise<TacSdk>;
-    private static prepareTONParams;
-    private static prepareTACParams;
+    static create(sdkParams: SDKParams, logger?: ILogger): Promise<TacSdk>;
     closeConnections(): unknown;
     get nativeTONAddress(): string;
     nativeTACAddress(): Promise<string>;
-    getUserJettonWalletAddress(userAddress: string, tokenAddress: string): Promise<string>;
-    getUserJettonBalance(userAddress: string, tokenAddress: string): Promise<bigint>;
-    getUserJettonBalanceExtended(userAddress: string, tokenAddress: string): Promise<UserWalletBalanceExtended>;
-    private getJettonTransferPayload;
-    private getJettonBurnPayload;
-    private getNFTBurnPayload;
-    private getNFTTransferPayload;
-    private getTonTransferPayload;
-    private getJettonOpType;
-    private getNFTOpType;
-    private getNFTItemAddressTON;
-    getNFTItemData(itemAddress: string): Promise<NFTItemData>;
-    private aggregateTokens;
-    private generateJettonPayload;
-    private generateNFTPayload;
-    private generateCrossChainMessages;
-    private getRawAmount;
-    private convertAssetsToRawFormat;
-    private getFeeInfo;
-    getTransactionSimulationInfo(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: AssetBridgingData[]): Promise<ExecutionFeeEstimationResult>;
-    getTVMExecutorFeeInfo(assets: AssetBridgingData[], feeSymbol: String): Promise<SuggestedTONExecutorFee>;
-    private prepareCrossChainTransaction;
-    sendCrossChainTransaction(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: AssetBridgingData[], options?: CrossChainTransactionOptions): Promise<TransactionLinker>;
-    sendCrossChainTransactions(sender: SenderAbstraction, txs: CrosschainTx[]): Promise<TransactionLinker[]>;
-    bridgeTokensToTON(signer: Wallet, value: bigint, tonTarget: string, assets?: RawAssetBridgingData<WithAddressNFTCollectionItem>[], tvmExecutorFee?: bigint): Promise<string>;
     get getTrustedTACExecutors(): string[];
     get getTrustedTONExecutors(): string[];
-    getEVMTokenAddress(tvmTokenAddress: string): Promise<string>;
-    getTVMTokenAddress(evmTokenAddress: string): Promise<string>;
-    getTVMNFTAddress(evmNFTAddress: string, tokenId?: number | bigint): Promise<string>;
-    getEVMNFTAddress(tvmNFTAddress: string, addressType: NFTAddressType): Promise<string>;
+    getTransactionSimulationInfo(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: Asset[]): Promise<ExecutionFeeEstimationResult>;
+    getTVMExecutorFeeInfo(assets: Asset[], feeSymbol: string): Promise<SuggestedTONExecutorFee>;
+    sendCrossChainTransaction(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: Asset[], options?: CrossChainTransactionOptions, waitOptions?: WaitOptions<string>): Promise<TransactionLinkerWithOperationId>;
+    sendCrossChainTransactions(sender: SenderAbstraction, txs: CrosschainTx[], waitOptions?: WaitOptions<OperationIdsByShardsKey>): Promise<TransactionLinkerWithOperationId[]>;
+    bridgeTokensToTON(signer: Wallet, value: bigint, tonTarget: string, assets?: Asset[], tvmExecutorFee?: bigint): Promise<string>;
     isContractDeployedOnTVM(address: string): Promise<boolean>;
     simulateTACMessage(req: TACSimulationRequest): Promise<TACSimulationResult>;
+    simulateTransactions(sender: SenderAbstraction, txs: CrosschainTx[]): Promise<TACSimulationResult[]>;
 }