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

package/dist/sdk/Simulator.js

@@ -1,169 +0,0 @@
-"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/TacSdk.d.ts

@@ -1,25 +0,0 @@
-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

@@ -1,104 +0,0 @@
-"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

@@ -1,22 +0,0 @@
-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

@@ -1,269 +0,0 @@
-"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/sender/SenderAbstraction.d.ts

@@ -1,22 +0,0 @@
-import type { Contract, ContractProvider, MessageRelaxed, SendMode } from '@ton/ton';
-import type { SendResult, ShardTransaction } from '../structs/InternalStruct';
-import type { Asset, ContractOpener } from '../structs/Struct';
-import { Network } from '../structs/Struct';
-export declare const sleep: (ms: number) => Promise<unknown>;
-export interface WalletInstance extends Contract {
-    getSeqno(provider: ContractProvider): Promise<number>;
-    sendTransfer(provider: ContractProvider, args: {
-        seqno: number;
-        secretKey: Buffer;
-        messages: MessageRelaxed[];
-        sendMode: SendMode;
-        timeout?: number;
-    }): Promise<void>;
-}
-export interface SenderAbstraction {
-    sendShardTransaction(shardTransaction: ShardTransaction, chain?: Network, contractOpener?: ContractOpener): Promise<SendResult>;
-    sendShardTransactions(shardTransactions: ShardTransaction[], chain?: Network, contractOpener?: ContractOpener): Promise<SendResult[]>;
-    getSenderAddress(): string;
-    getBalance(contractOpener: ContractOpener): Promise<bigint>;
-    getBalanceOf(asset: Asset): Promise<bigint>;
-}

package/dist/sender/SenderAbstraction.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sleep = void 0;
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-exports.sleep = sleep;

package/dist/structs/Services.d.ts

@@ -1,41 +0,0 @@
-import { mainnet, testnet } from '@tonappchain/artifacts';
-import type { SenderAbstraction } from '../sender';
-import { InternalTACParams, InternalTONParams } from './InternalStruct';
-import { Asset, CrosschainTx, EvmProxyMsg, ExecutionFeeEstimationResult, ExecutionStages, ExecutionStagesByOperationId, Network, OperationIdsByShardsKey, OperationType, SimplifiedStatuses, StatusInfo, StatusInfosByOperationId, SuggestedTONExecutorFee, TACSimulationRequest, TACSimulationResult, TransactionLinker, WaitOptions } from './Struct';
-export interface IConfiguration {
-    readonly network: Network;
-    readonly artifacts: typeof testnet | typeof mainnet;
-    readonly TONParams: InternalTONParams;
-    readonly TACParams: InternalTACParams;
-    readonly liteSequencerEndpoints: string[];
-    readonly nativeTONAddress: string;
-    nativeTACAddress(): Promise<string>;
-    readonly getTrustedTACExecutors: string[];
-    readonly getTrustedTONExecutors: string[];
-    closeConnections(): unknown;
-    isContractDeployedOnTVM(address: string): Promise<boolean>;
-}
-export interface ILogger {
-    debug(...arg: unknown[]): void;
-    info(...arg: unknown[]): void;
-    warn(...arg: unknown[]): void;
-    error(...arg: unknown[]): void;
-}
-export interface ISimulator {
-    simulateTACMessage(req: TACSimulationRequest): Promise<TACSimulationResult>;
-    simulateTransactions(sender: SenderAbstraction, txs: CrosschainTx[]): Promise<TACSimulationResult[]>;
-    getTVMExecutorFeeInfo(assets: Asset[], feeSymbol: string): Promise<SuggestedTONExecutorFee>;
-    getTransactionSimulationInfo(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: Asset[]): Promise<ExecutionFeeEstimationResult>;
-    getSimulationInfoForTransaction(evmProxyMsg: EvmProxyMsg, transactionLinker: TransactionLinker, assets: Asset[], allowSimulationError?: boolean, isRoundTrip?: boolean, evmValidExecutors?: string[], tvmValidExecutors?: string[]): Promise<ExecutionFeeEstimationResult>;
-}
-export interface IOperationTracker {
-    getOperationType(operationId: string, waitOptions?: WaitOptions<OperationType>): Promise<OperationType>;
-    getOperationId(transactionLinker: TransactionLinker, waitOptions?: WaitOptions<string>): Promise<string>;
-    getOperationIdByTransactionHash(transactionHash: string, waitOptions?: WaitOptions<string>): Promise<string>;
-    getOperationIdsByShardsKeys(shardsKeys: string[], caller: string, waitOptions?: WaitOptions<OperationIdsByShardsKey>, chunkSize?: number): Promise<OperationIdsByShardsKey>;
-    getStageProfiling(operationId: string, waitOptions?: WaitOptions<ExecutionStages>): Promise<ExecutionStages>;
-    getStageProfilings(operationIds: string[], waitOptions?: WaitOptions<ExecutionStagesByOperationId>, chunkSize?: number): Promise<ExecutionStagesByOperationId>;
-    getOperationStatuses(operationIds: string[], waitOptions?: WaitOptions<StatusInfosByOperationId>, chunkSize?: number): Promise<StatusInfosByOperationId>;
-    getOperationStatus(operationId: string, waitOptions?: WaitOptions<StatusInfo>): Promise<StatusInfo>;
-    getSimplifiedOperationStatus(transactionLinker: TransactionLinker): Promise<SimplifiedStatuses>;
-}