@tonappchain/sdk 0.7.0-rc24-test-8 → 0.7.0-rc24-test-9

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/{src/sdk → sdk}/StartTracking.d.ts

@@ -1,5 +1,5 @@
-import { ILogger } from '../interfaces';
 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[];

package/dist/sdk/TacSdk.d.ts

@@ -0,0 +1,25 @@
+import { Wallet } from 'ethers';
+import type { SenderAbstraction } from '../sender';
+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 config: IConfiguration;
+    private readonly simulator;
+    private readonly transactionManager;
+    private constructor();
+    static create(sdkParams: SDKParams, logger?: ILogger): Promise<TacSdk>;
+    closeConnections(): unknown;
+    get nativeTONAddress(): string;
+    nativeTACAddress(): Promise<string>;
+    get getTrustedTACExecutors(): string[];
+    get getTrustedTONExecutors(): 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>;
+    getTacSmartAccountAddress(tvmUserAddress: string, evmApplicationAddress: string): Promise<string>;
+    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[]>;
+}

package/dist/sdk/TacSdk.js

@@ -0,0 +1,104 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TacSdk = void 0;
+const Struct_1 = require("../structs/Struct");
+const Configuration_1 = require("./Configuration");
+const Consts_1 = require("./Consts");
+const Logger_1 = require("./Logger");
+const OperationTracker_1 = require("./OperationTracker");
+const Simulator_1 = require("./Simulator");
+const TransactionManager_1 = require("./TransactionManager");
+class TacSdk {
+    constructor(config, simulator, transactionManager) {
+        this.config = config;
+        this.simulator = simulator;
+        this.transactionManager = transactionManager;
+    }
+    static async create(sdkParams, logger = new Logger_1.NoopLogger()) {
+        const network = sdkParams.network;
+        const delay = sdkParams.delay ?? Consts_1.DEFAULT_DELAY;
+        const { testnet, mainnet } = await Promise.resolve().then(() => __importStar(require('@tonappchain/artifacts')));
+        const artifacts = network === Struct_1.Network.TESTNET ? testnet : mainnet;
+        const config = await Configuration_1.Configuration.create(network, artifacts, sdkParams.TONParams, sdkParams.TACParams, sdkParams.customLiteSequencerEndpoints, delay);
+        const simulator = new Simulator_1.Simulator(config, logger);
+        const operationTracker = new OperationTracker_1.OperationTracker(network, config.liteSequencerEndpoints);
+        const transactionManager = new TransactionManager_1.TransactionManager(config, simulator, operationTracker, logger);
+        return new TacSdk(config, simulator, transactionManager);
+    }
+    closeConnections() {
+        return this.config.closeConnections();
+    }
+    get nativeTONAddress() {
+        return this.config.nativeTONAddress;
+    }
+    async nativeTACAddress() {
+        return this.config.nativeTACAddress();
+    }
+    get getTrustedTACExecutors() {
+        return this.config.getTrustedTACExecutors;
+    }
+    get getTrustedTONExecutors() {
+        return this.config.getTrustedTONExecutors;
+    }
+    async getTransactionSimulationInfo(evmProxyMsg, sender, assets) {
+        return this.simulator.getTransactionSimulationInfo(evmProxyMsg, sender, assets);
+    }
+    async getTVMExecutorFeeInfo(assets, feeSymbol) {
+        return this.simulator.getTVMExecutorFeeInfo(assets, feeSymbol);
+    }
+    async sendCrossChainTransaction(evmProxyMsg, sender, assets, options, waitOptions) {
+        return this.transactionManager.sendCrossChainTransaction(evmProxyMsg, sender, assets, options, waitOptions);
+    }
+    async getTacSmartAccountAddress(tvmUserAddress, evmApplicationAddress) {
+        return await this.config.TACParams.smartAccountFactory.getSmartAccountForApplication(tvmUserAddress, evmApplicationAddress);
+    }
+    async sendCrossChainTransactions(sender, txs, waitOptions) {
+        return this.transactionManager.sendCrossChainTransactions(sender, txs, waitOptions);
+    }
+    async bridgeTokensToTON(signer, value, tonTarget, assets, tvmExecutorFee) {
+        return this.transactionManager.bridgeTokensToTON(signer, value, tonTarget, assets, tvmExecutorFee);
+    }
+    async isContractDeployedOnTVM(address) {
+        return this.config.isContractDeployedOnTVM(address);
+    }
+    async simulateTACMessage(req) {
+        return this.simulator.simulateTACMessage(req);
+    }
+    async simulateTransactions(sender, txs) {
+        return this.simulator.simulateTransactions(sender, txs);
+    }
+}
+exports.TacSdk = TacSdk;

package/dist/sdk/TransactionManager.d.ts

@@ -0,0 +1,22 @@
+import { Cell } from '@ton/ton';
+import { Wallet } from 'ethers';
+import type { SenderAbstraction } from '../sender';
+import { IConfiguration, ILogger, IOperationTracker, ISimulator } from '../structs/Services';
+import { Asset, CrossChainTransactionOptions, CrosschainTx, EvmProxyMsg, OperationIdsByShardsKey, TransactionLinker, TransactionLinkerWithOperationId, ValidExecutors, WaitOptions } from '../structs/Struct';
+export declare class TransactionManager {
+    private readonly config;
+    private readonly simulator;
+    private readonly operationTracker;
+    private readonly logger;
+    private readonly evmDataCellBuilder;
+    constructor(config: IConfiguration, simulator: ISimulator, operationTracker: IOperationTracker, logger?: ILogger, options?: {
+        evmDataCellBuilder?: (transactionLinker: TransactionLinker, evmProxyMsg: EvmProxyMsg, validExecutors: ValidExecutors) => Cell;
+    });
+    private prepareCrossChainTransaction;
+    private generateCrossChainMessages;
+    sendCrossChainTransaction(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: Asset[], options?: CrossChainTransactionOptions, waitOptions?: WaitOptions<string>): Promise<TransactionLinkerWithOperationId>;
+    sendCrossChainTransactions(sender: SenderAbstraction, txs: CrosschainTx[], waitOptions?: WaitOptions<OperationIdsByShardsKey>): Promise<TransactionLinkerWithOperationId[]>;
+    private prepareCrossChainTransactions;
+    private waitForOperationIds;
+    bridgeTokensToTON(signer: Wallet, value: bigint, tonTarget: string, assets?: Asset[], tvmExecutorFee?: bigint): Promise<string>;
+}

package/dist/sdk/TransactionManager.js

@@ -0,0 +1,269 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionManager = void 0;
+const assets_1 = require("../assets");
+const Struct_1 = require("../structs/Struct");
+const Consts_1 = require("./Consts");
+const Logger_1 = require("./Logger");
+const Utils_1 = require("./Utils");
+const Validator_1 = require("./Validator");
+class TransactionManager {
+    constructor(config, simulator, operationTracker, logger = new Logger_1.NoopLogger(), options) {
+        this.config = config;
+        this.simulator = simulator;
+        this.operationTracker = operationTracker;
+        this.logger = logger;
+        this.evmDataCellBuilder = options?.evmDataCellBuilder ?? Utils_1.buildEvmDataCell;
+    }
+    async prepareCrossChainTransaction(evmProxyMsg, caller, assets, options) {
+        this.logger.debug('Preparing cross-chain transaction');
+        const { allowSimulationError = false, isRoundTrip = undefined, protocolFee = undefined, evmExecutorFee = undefined, tvmExecutorFee = undefined, } = options || {};
+        let { evmValidExecutors = [], tvmValidExecutors = [] } = options || {};
+        Validator_1.Validator.validateEVMAddress(evmProxyMsg.evmTargetAddress);
+        Validator_1.Validator.validateEVMAddresses(options?.evmValidExecutors);
+        Validator_1.Validator.validateTVMAddresses(options?.tvmValidExecutors);
+        const aggregatedData = await (0, Utils_1.aggregateTokens)(assets);
+        await Promise.all(aggregatedData.jettons.map((jetton) => jetton.checkCanBeTransferedBy(caller)));
+        await Promise.all(aggregatedData.nfts.map((nft) => nft.checkCanBeTransferedBy(caller)));
+        await aggregatedData.ton?.checkCanBeTransferedBy(caller);
+        const tokensLength = aggregatedData.jettons.length + aggregatedData.nfts.length;
+        this.logger.debug(`Tokens length: ${tokensLength}`);
+        const transactionLinkerShardCount = tokensLength == 0 ? 1 : tokensLength;
+        this.logger.debug(`Transaction linker shard count: ${transactionLinkerShardCount}`);
+        const transactionLinker = (0, Utils_1.generateTransactionLinker)(caller, transactionLinkerShardCount);
+        this.logger.debug(`Generated transaction linker: ${(0, Utils_1.formatObjectForLogging)(transactionLinker)}`);
+        if (evmValidExecutors.length == 0) {
+            evmValidExecutors = this.config.getTrustedTACExecutors;
+        }
+        if (tvmValidExecutors.length == 0) {
+            tvmValidExecutors = this.config.getTrustedTONExecutors;
+        }
+        const { feeParams } = await this.simulator.getSimulationInfoForTransaction(evmProxyMsg, transactionLinker, assets ?? [], allowSimulationError, isRoundTrip, evmValidExecutors, tvmValidExecutors);
+        if (evmProxyMsg.gasLimit == undefined) {
+            evmProxyMsg.gasLimit = feeParams.gasLimit;
+        }
+        if (evmExecutorFee != undefined) {
+            feeParams.evmExecutorFee = evmExecutorFee;
+        }
+        if (feeParams.isRoundTrip && tvmExecutorFee != undefined) {
+            feeParams.tvmExecutorFee = tvmExecutorFee;
+        }
+        if (protocolFee != undefined) {
+            feeParams.protocolFee = protocolFee;
+        }
+        this.logger.debug(`Resulting fee params: ${(0, Utils_1.formatObjectForLogging)(feeParams)}`);
+        const validExecutors = {
+            tac: evmValidExecutors,
+            ton: tvmValidExecutors,
+        };
+        this.logger.debug(`Valid executors: ${(0, Utils_1.formatObjectForLogging)(validExecutors)}`);
+        const evmData = this.evmDataCellBuilder(transactionLinker, evmProxyMsg, validExecutors);
+        const messages = await this.generateCrossChainMessages(caller, evmData, aggregatedData, feeParams);
+        const transaction = {
+            validUntil: +new Date() + 15 * 60 * 1000,
+            messages,
+            network: this.config.network,
+        };
+        this.logger.debug('Transaction prepared');
+        return { transaction, transactionLinker };
+    }
+    async generateCrossChainMessages(caller, evmData, aggregatedData, feeParams) {
+        this.logger.debug(`Generating cross-chain messages`);
+        const { jettons, nfts, ton = assets_1.TON.create(this.config) } = aggregatedData;
+        let crossChainTonAmount = ton.rawAmount;
+        let feeTonAmount = feeParams.protocolFee + feeParams.evmExecutorFee + feeParams.tvmExecutorFee;
+        this.logger.debug(`Crosschain ton amount: ${crossChainTonAmount}`);
+        this.logger.debug(`Fee ton amount: ${feeTonAmount}`);
+        if (jettons.length == 0 && nfts.length == 0) {
+            return [
+                {
+                    address: this.config.TONParams.crossChainLayerAddress,
+                    value: crossChainTonAmount + feeTonAmount + Consts_1.TRANSACTION_TON_AMOUNT,
+                    payload: await ton.generatePayload({
+                        excessReceiver: caller,
+                        evmData,
+                        feeParams,
+                    }),
+                },
+            ];
+        }
+        const messages = [];
+        let currentFeeParams = feeParams;
+        for (const jetton of aggregatedData.jettons) {
+            const payload = await jetton.generatePayload({
+                excessReceiver: caller,
+                evmData,
+                crossChainTonAmount,
+                forwardFeeTonAmount: feeTonAmount,
+                feeParams: currentFeeParams,
+            });
+            const jettonWalletAddress = await jetton.getUserWalletAddress(caller);
+            messages.push({
+                address: jettonWalletAddress,
+                value: crossChainTonAmount + feeTonAmount + Consts_1.TRANSACTION_TON_AMOUNT,
+                payload,
+            });
+            crossChainTonAmount = 0n;
+            feeTonAmount = 0n;
+            currentFeeParams = undefined;
+        }
+        for (const nft of aggregatedData.nfts) {
+            const payload = await nft.generatePayload({
+                excessReceiver: caller,
+                evmData,
+                crossChainTonAmount,
+                forwardFeeTonAmount: feeTonAmount,
+                feeParams: currentFeeParams,
+            });
+            messages.push({
+                address: nft.address,
+                value: crossChainTonAmount + feeTonAmount + Consts_1.TRANSACTION_TON_AMOUNT,
+                payload,
+            });
+            crossChainTonAmount = 0n;
+            feeTonAmount = 0n;
+            currentFeeParams = undefined;
+        }
+        this.logger.debug('Generating cross-chain messages success');
+        return messages;
+    }
+    async sendCrossChainTransaction(evmProxyMsg, sender, assets, options, waitOptions) {
+        const caller = sender.getSenderAddress();
+        this.logger.debug(`Caller: ${caller}`);
+        const { transaction, transactionLinker } = await this.prepareCrossChainTransaction(evmProxyMsg, caller, assets, options);
+        await assets_1.TON.checkBalance(sender, this.config, [transaction]);
+        this.logger.debug(`*****Sending transaction: ${(0, Utils_1.formatObjectForLogging)(transaction)}`);
+        const sendTransactionResult = await sender.sendShardTransaction(transaction, this.config.network, this.config.TONParams.contractOpener);
+        return waitOptions
+            ? {
+                sendTransactionResult,
+                operationId: await this.operationTracker
+                    .getOperationId(transactionLinker, {
+                    ...waitOptions,
+                    successCheck: (operationId) => !!operationId,
+                    logger: this.logger,
+                })
+                    .catch((error) => {
+                    this.logger.error(`Error while waiting for operation ID: ${error}`);
+                    return undefined;
+                }),
+                ...transactionLinker,
+            }
+            : { sendTransactionResult, ...transactionLinker };
+    }
+    async sendCrossChainTransactions(sender, txs, waitOptions) {
+        const caller = sender.getSenderAddress();
+        this.logger.debug(`Caller: ${caller}`);
+        this.logger.debug('Preparing multiple cross-chain transactions');
+        const { transactions, transactionLinkers } = await this.prepareCrossChainTransactions(txs, caller);
+        await assets_1.TON.checkBalance(sender, this.config, transactions);
+        this.logger.debug(`*****Sending transactions: ${(0, Utils_1.formatObjectForLogging)(transactions)}`);
+        await sender.sendShardTransactions(transactions, this.config.network, this.config.TONParams.contractOpener);
+        if (!waitOptions) {
+            return transactionLinkers;
+        }
+        return await this.waitForOperationIds(transactionLinkers, caller, waitOptions);
+    }
+    async prepareCrossChainTransactions(txs, caller) {
+        const transactions = [];
+        const transactionLinkers = [];
+        for (const { options, assets, evmProxyMsg } of txs) {
+            const { transaction, transactionLinker } = await this.prepareCrossChainTransaction(evmProxyMsg, caller, assets, options);
+            transactions.push(transaction);
+            transactionLinkers.push(transactionLinker);
+        }
+        return { transactions, transactionLinkers };
+    }
+    async waitForOperationIds(transactionLinkers, caller, waitOptions) {
+        this.logger.debug(`Waiting for operation IDs`);
+        try {
+            const operationIds = await this.operationTracker.getOperationIdsByShardsKeys(transactionLinkers.map((linker) => linker.shardsKey), caller, {
+                ...waitOptions,
+                logger: this.logger,
+                successCheck: (operationIds) => Object.keys(operationIds).length == transactionLinkers.length &&
+                    Object.values(operationIds).every((ids) => ids.operationIds.length > 0),
+            });
+            this.logger.debug(`Operation IDs: ${(0, Utils_1.formatObjectForLogging)(operationIds)}`);
+            return transactionLinkers.map((linker) => ({
+                ...linker,
+                operationId: operationIds[linker.shardsKey].operationIds.at(0),
+            }));
+        }
+        catch (error) {
+            this.logger.error(`Error while waiting for operation IDs: ${error}`);
+            return transactionLinkers;
+        }
+    }
+    async bridgeTokensToTON(signer, value, tonTarget, assets, tvmExecutorFee) {
+        this.logger.debug('Bridging tokens to TON');
+        if (assets == undefined) {
+            assets = [];
+        }
+        const tonAssets = [...assets];
+        if (value > 0n) {
+            tonAssets.push(await (await assets_1.AssetFactory.from(this.config, {
+                address: await this.config.nativeTACAddress(),
+                tokenType: Struct_1.AssetType.FT,
+            })).withAmount({ rawAmount: value }));
+        }
+        Validator_1.Validator.validateTVMAddress(tonTarget);
+        const suggestedTONExecutorFee = await this.simulator.getTVMExecutorFeeInfo(tonAssets, Consts_1.TAC_SYMBOL);
+        this.logger.debug(`Suggested TON executor fee: ${(0, Utils_1.formatObjectForLogging)(suggestedTONExecutorFee)}`);
+        const crossChainLayerAddress = await this.config.TACParams.crossChainLayer.getAddress();
+        for (const asset of assets) {
+            const evmAddress = await asset.getEVMAddress();
+            if (asset.type == Struct_1.AssetType.FT) {
+                this.logger.debug(`Approving token ${evmAddress} for ${crossChainLayerAddress}`);
+                const tokenContract = this.config.artifacts.tac.wrappers.ERC20FactoryTAC.connect(evmAddress, this.config.TACParams.provider);
+                const tx = await tokenContract.connect(signer).approve(crossChainLayerAddress, asset.rawAmount);
+                await tx.wait();
+                this.logger.debug(`Approved ${evmAddress} for ${crossChainLayerAddress}`);
+            }
+            if (asset.type == Struct_1.AssetType.NFT) {
+                this.logger.debug(`Approving collection ${evmAddress} for ${crossChainLayerAddress}`);
+                const tokenContract = this.config.artifacts.tac.wrappers.ERC721FactoryTAC.connect(evmAddress, this.config.TACParams.provider);
+                const tx = await tokenContract
+                    .connect(signer)
+                    .approve(crossChainLayerAddress, asset.addresses.index);
+                await tx.wait();
+                this.logger.debug(`Approved ${asset.address} for ${crossChainLayerAddress}`);
+            }
+        }
+        const shardsKey = BigInt(Math.round(Math.random() * 1e18));
+        this.logger.debug(`Shards key: ${shardsKey}`);
+        const protocolFee = await this.config.TACParams.crossChainLayer.getProtocolFee();
+        this.logger.debug(`Protocol fee: ${protocolFee}`);
+        const outMessage = {
+            shardsKey: shardsKey,
+            tvmTarget: tonTarget,
+            tvmPayload: '',
+            tvmProtocolFee: protocolFee,
+            tvmExecutorFee: tvmExecutorFee ?? BigInt(suggestedTONExecutorFee.inTAC),
+            tvmValidExecutors: this.config.getTrustedTONExecutors,
+            toBridge: await Promise.all(assets
+                .filter((asset) => asset.type === Struct_1.AssetType.FT)
+                .map(async (asset) => ({
+                evmAddress: await asset.getEVMAddress(),
+                amount: asset.rawAmount,
+            }))),
+            toBridgeNFT: await Promise.all(assets
+                .filter((asset) => asset.type === Struct_1.AssetType.NFT)
+                .map(async (asset) => ({
+                evmAddress: await asset.getEVMAddress(),
+                amount: 1n,
+                tokenId: asset.addresses.index,
+            }))),
+        };
+        const encodedOutMessage = this.config.artifacts.tac.utils.encodeOutMessageV1(outMessage);
+        const outMsgVersion = 1n;
+        const totalValue = value + BigInt(outMessage.tvmProtocolFee) + BigInt(outMessage.tvmExecutorFee);
+        this.logger.debug(`Total value: ${totalValue}`);
+        const tx = await this.config.TACParams.crossChainLayer
+            .connect(signer)
+            .sendMessage(outMsgVersion, encodedOutMessage, { value: totalValue });
+        await tx.wait();
+        this.logger.debug(`Transaction hash: ${tx.hash}`);
+        return tx.hash;
+    }
+}
+exports.TransactionManager = TransactionManager;

package/dist/{src/sdk → sdk}/TxFinalizer.d.ts

@@ -1,10 +1,9 @@
-import { IHttpClient, ILogger } from '../interfaces';
 import { TxFinalizerConfig } from '../structs/InternalStruct';
+import { ILogger } from '../structs/Services';
 export declare class TonTxFinalizer {
     private logger;
     private apiConfig;
-    private readonly httpClient;
-    constructor(apiConfig: TxFinalizerConfig, logger?: ILogger, httpClient?: IHttpClient);
+    constructor(apiConfig: TxFinalizerConfig, logger?: ILogger);
     private logHashFormats;
     private fetchAdjacentTransactions;
     trackTransactionTree(hash: string, maxDepth?: number): Promise<void>;

package/dist/{src/sdk → sdk}/TxFinalizer.js

@@ -1,7 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TonTxFinalizer = void 0;
-const AxiosHttpClient_1 = require("./AxiosHttpClient");
+const axios_1 = __importDefault(require("axios"));
 const Logger_1 = require("./Logger");
 const Utils_1 = require("./Utils");
 const IGNORE_OPCODE = [
@@ -9,10 +12,9 @@ const IGNORE_OPCODE = [
     '0x7362d09c', // Jetton Notify
 ];
 class TonTxFinalizer {
-    constructor(apiConfig, logger = new Logger_1.NoopLogger(), httpClient = new AxiosHttpClient_1.AxiosHttpClient()) {
+    constructor(apiConfig, logger = new Logger_1.NoopLogger()) {
         this.apiConfig = apiConfig;
         this.logger = logger;
-        this.httpClient = httpClient;
     }
     logHashFormats(hash) {
         let hex, base64;
@@ -32,9 +34,10 @@ class TonTxFinalizer {
     // Fetches adjacent transactions from toncenter
     async fetchAdjacentTransactions(hash, retries = 5, delay = 1000) {
         for (let i = retries; i >= 0; i--) {
+            await (0, Utils_1.sleep)(delay);
             try {
                 const url = this.apiConfig.urlBuilder(hash);
-                const response = await this.httpClient.get(url, {
+                const response = await axios_1.default.get(url, {
                     headers: {
                         [this.apiConfig.authorization.header]: this.apiConfig.authorization.value,
                     },
@@ -54,7 +57,6 @@ class TonTxFinalizer {
                     console.warn(`Failed to fetch adjacent transactions for ${hash}:`, logMessage);
                 }
             }
-            await (0, Utils_1.sleep)(delay);
         }
         return [];
     }
@@ -89,9 +91,7 @@ class TonTxFinalizer {
                             `action.result_code = ${action.resultCode}`);
                     }
                     if (currentDepth + 1 < maxDepth) {
-                        if (tx.outMsgs.length > 0) {
-                            queue.push({ hash: tx.hash, depth: currentDepth + 1 });
-                        }
+                        queue.push({ hash: tx.hash, depth: currentDepth + 1 });
                     }
                 }
                 else {