@tonappchain/sdk 0.7.0-rc8 → 0.7.0

package/dist/sdk/Configuration.js

@@ -1,90 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Configuration = void 0;
-const ton_1 = require("@ton/ton");
-const artifacts_1 = require("@tonappchain/artifacts");
-const ethers_1 = require("ethers");
-const retryableContractOpener_1 = require("../adapters/retryableContractOpener");
-const Struct_1 = require("../structs/Struct");
-const Settings_1 = require("../wrappers/Settings");
-const Validator_1 = require("./Validator");
-class Configuration {
-    constructor(network, artifacts, TONParams, TACParams, liteSequencerEndpoints) {
-        this.network = network;
-        this.artifacts = artifacts;
-        this.TONParams = TONParams;
-        this.TACParams = TACParams;
-        this.liteSequencerEndpoints = liteSequencerEndpoints;
-    }
-    static async create(network, artifacts, TONParams, TACParams, customLiteSequencerEndpoints, delay) {
-        const internalTONParams = await this.prepareTONParams(artifacts, TONParams, delay);
-        const internalTACParams = await this.prepareTACParams(artifacts, TACParams);
-        const liteSequencerEndpoints = customLiteSequencerEndpoints ??
-            (network === Struct_1.Network.TESTNET
-                ? artifacts_1.testnet.PUBLIC_LITE_SEQUENCER_ENDPOINTS
-                : artifacts_1.mainnet.PUBLIC_LITE_SEQUENCER_ENDPOINTS);
-        return new Configuration(network, artifacts, internalTONParams, internalTACParams, liteSequencerEndpoints);
-    }
-    static async prepareTONParams(artifacts, TONParams, delay) {
-        const contractOpener = TONParams?.contractOpener ?? (await (0, retryableContractOpener_1.createDefaultRetryableOpener)(artifacts, 3, delay));
-        const settingsAddress = TONParams?.settingsAddress ?? artifacts.TON_SETTINGS_ADDRESS;
-        const settings = contractOpener.open(new Settings_1.Settings(ton_1.Address.parse(settingsAddress)));
-        const jettonProxyAddress = await settings.getAddressSetting('JettonProxyAddress');
-        const crossChainLayerAddress = await settings.getAddressSetting('CrossChainLayerAddress');
-        const jettonMinterCode = await settings.getCellSetting('JettonMinterCode');
-        const jettonWalletCode = await settings.getCellSetting('JettonWalletCode');
-        const nftProxyAddress = await settings.getAddressSetting('NFTProxyAddress');
-        const nftItemCode = await settings.getCellSetting('NFTItemCode');
-        const nftCollectionCode = await settings.getCellSetting('NFTCollectionCode');
-        return {
-            contractOpener,
-            jettonProxyAddress,
-            crossChainLayerAddress,
-            jettonMinterCode,
-            jettonWalletCode,
-            nftProxyAddress,
-            nftItemCode,
-            nftCollectionCode,
-        };
-    }
-    static async prepareTACParams(artifacts, TACParams) {
-        const provider = TACParams?.provider ?? ethers_1.ethers.getDefaultProvider(artifacts.TAC_RPC_ENDPOINT);
-        const settingsAddress = TACParams?.settingsAddress?.toString() ?? artifacts.TAC_SETTINGS_ADDRESS;
-        Validator_1.Validator.validateEVMAddress(settingsAddress);
-        const settings = artifacts.tac.wrappers.SettingsFactoryTAC.connect(settingsAddress, provider);
-        const crossChainLayerAddress = await settings.getAddressSetting((0, ethers_1.keccak256)((0, ethers_1.toUtf8Bytes)('CrossChainLayerAddress')));
-        const crossChainLayer = artifacts.tac.wrappers.CrossChainLayerFactoryTAC.connect(crossChainLayerAddress, provider);
-        const tokenUtilsAddress = await settings.getAddressSetting((0, ethers_1.keccak256)((0, ethers_1.toUtf8Bytes)('TokenUtilsAddress')));
-        const tokenUtils = artifacts.tac.wrappers.TokenUtilsFactoryTAC.connect(tokenUtilsAddress, provider);
-        const trustedTACExecutors = await settings.getTrustedEVMExecutors();
-        const trustedTONExecutors = await settings.getTrustedTVMExecutors();
-        return {
-            provider,
-            settings,
-            tokenUtils,
-            crossChainLayer,
-            trustedTACExecutors,
-            trustedTONExecutors,
-            abiCoder: new ethers_1.ethers.AbiCoder(),
-        };
-    }
-    get nativeTONAddress() {
-        return 'NONE';
-    }
-    async nativeTACAddress() {
-        return this.TACParams.crossChainLayer.NATIVE_TOKEN_ADDRESS.staticCall();
-    }
-    get getTrustedTACExecutors() {
-        return this.TACParams.trustedTACExecutors;
-    }
-    get getTrustedTONExecutors() {
-        return this.TACParams.trustedTONExecutors;
-    }
-    closeConnections() {
-        return this.TONParams.contractOpener.closeConnections?.();
-    }
-    async isContractDeployedOnTVM(address) {
-        return (await this.TONParams.contractOpener.getContractState(ton_1.Address.parse(address))).state === 'active';
-    }
-}
-exports.Configuration = Configuration;

package/dist/sdk/LiteSequencerClient.d.ts

@@ -1,13 +0,0 @@
-import { ExecutionStagesByOperationId, OperationIdsByShardsKey, OperationType, StatusInfosByOperationId, TransactionLinker } from '../structs/Struct';
-export declare class LiteSequencerClient {
-    private readonly endpoint;
-    private readonly maxChunkSize;
-    constructor(endpoint: string, maxChunkSize?: number);
-    getOperationIdByTransactionHash(transactionHash: string): Promise<string>;
-    getOperationType(operationId: string): Promise<OperationType>;
-    getOperationId(transactionLinker: TransactionLinker): Promise<string>;
-    getOperationIdsByShardsKeys(shardsKeys: string[], caller: string, chunkSize?: number): Promise<OperationIdsByShardsKey>;
-    getStageProfilings(operationIds: string[], chunkSize?: number): Promise<ExecutionStagesByOperationId>;
-    getOperationStatuses(operationIds: string[], chunkSize?: number): Promise<StatusInfosByOperationId>;
-    private processChunkedRequest;
-}

package/dist/sdk/Simulator.d.ts

@@ -1,23 +0,0 @@
-import { AxiosRequestConfig, AxiosResponse } from 'axios';
-import type { SenderAbstraction } from '../sender';
-import { IConfiguration, ILogger, ISimulator } from '../structs/Services';
-import { Asset, CrosschainTx, EvmProxyMsg, ExecutionFeeEstimationResult, SuggestedTONExecutorFee, TACSimulationRequest, TACSimulationResult, TransactionLinker } from '../structs/Struct';
-export interface IHttpClient {
-    post<T>(url: string, data: unknown, config?: AxiosRequestConfig): Promise<AxiosResponse<T>>;
-}
-export declare class AxiosHttpClient implements IHttpClient {
-    post<T>(url: string, data: unknown, config?: AxiosRequestConfig): Promise<AxiosResponse<T>>;
-}
-export declare class Simulator implements ISimulator {
-    private readonly config;
-    private readonly logger;
-    private readonly httpClient;
-    constructor(config: IConfiguration, logger?: ILogger, httpClient?: IHttpClient);
-    simulateTACMessage(req: TACSimulationRequest): Promise<TACSimulationResult>;
-    simulateTransactions(sender: SenderAbstraction, txs: CrosschainTx[]): Promise<TACSimulationResult[]>;
-    private buildTACSimulationRequest;
-    getTVMExecutorFeeInfo(assets: Asset[], feeSymbol: string): Promise<SuggestedTONExecutorFee>;
-    private getFeeInfo;
-    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>;
-}

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,24 +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>;
-    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,101 +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 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>;
-}