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

package/dist/sdk/Configuration.js

@@ -0,0 +1,90 @@
+"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,4 +1,4 @@
-import { TransactionLinker, StatusInfosByOperationId, OperationIdsByShardsKey, ExecutionStagesByOperationId, OperationType } from '../structs/Struct';
+import { ExecutionStagesByOperationId, OperationIdsByShardsKey, OperationType, StatusInfosByOperationId, TransactionLinker } from '../structs/Struct';
 export declare class LiteSequencerClient {
     private readonly endpoint;
     private readonly maxChunkSize;

package/dist/sdk/LiteSequencerClient.js

@@ -22,8 +22,7 @@ class LiteSequencerClient {
             return response.data.response || '';
         }
         catch (error) {
-            console.error(`Failed to get operationType with ${this.endpoint}:`, error);
-            throw errors_1.operationFetchError;
+            throw (0, errors_1.operationFetchError)(`endpoint ${this.endpoint} failed to complete request`, error);
         }
     }
     async getOperationId(transactionLinker) {
@@ -40,12 +39,10 @@ class LiteSequencerClient {
         catch (error) {
             if (axios_1.default.isAxiosError(error)) {
                 if (error.response?.status === 404) {
-                    console.warn(`404 Not Found: ${new URL('ton/operation-id', this.endpoint).toString()}`);
                     return '';
                 }
             }
-            console.error(`Failed to get OperationId with ${this.endpoint}:`, error);
-            throw errors_1.operationFetchError;
+            throw (0, errors_1.operationFetchError)(`endpoint ${this.endpoint} failed to complete request`, error);
         }
     }
     async getOperationIdsByShardsKeys(shardsKeys, caller, chunkSize = this.maxChunkSize) {
@@ -63,8 +60,7 @@ class LiteSequencerClient {
             return response.response;
         }
         catch (error) {
-            console.error(`Failed to get OperationIds with ${this.endpoint}:`, error);
-            throw errors_1.operationFetchError;
+            throw (0, errors_1.operationFetchError)(`endpoint ${this.endpoint} failed to complete request`, error);
         }
     }
     async getStageProfilings(operationIds, chunkSize = this.maxChunkSize) {
@@ -83,8 +79,7 @@ class LiteSequencerClient {
             return response.response;
         }
         catch (error) {
-            console.error(`Error fetching stage profiling with ${this.endpoint}:`, error);
-            throw (0, errors_1.profilingFetchError)('endpoint failed to complete request');
+            throw (0, errors_1.profilingFetchError)(`endpoint ${this.endpoint} failed to complete request`, error);
         }
     }
     async getOperationStatuses(operationIds, chunkSize = this.maxChunkSize) {
@@ -103,8 +98,7 @@ class LiteSequencerClient {
             return response.response;
         }
         catch (error) {
-            console.error(`Error fetching status transaction with ${this.endpoint}:`, error);
-            throw (0, errors_1.statusFetchError)('endpoint failed to complete request');
+            throw (0, errors_1.statusFetchError)(`endpoint ${this.endpoint} failed to complete request`, error);
         }
     }
     async processChunkedRequest(identificators, requestFn, chunkSize = this.maxChunkSize) {

package/dist/sdk/Logger.d.ts

@@ -0,0 +1,13 @@
+import { ILogger } from '../structs/Services';
+export declare class ConsoleLogger implements ILogger {
+    debug(...arg: unknown[]): void;
+    info(...arg: unknown[]): void;
+    warn(...arg: unknown[]): void;
+    error(...arg: unknown[]): void;
+}
+export declare class NoopLogger implements ILogger {
+    debug(): void;
+    info(): void;
+    warn(): void;
+    error(): void;
+}

package/dist/sdk/Logger.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoopLogger = exports.ConsoleLogger = void 0;
+class ConsoleLogger {
+    debug(...arg) {
+        console.debug(`[DEBUG]`, ...arg);
+    }
+    info(...arg) {
+        console.info(`[INFO]`, ...arg);
+    }
+    warn(...arg) {
+        console.warn(`[WARN]`, ...arg);
+    }
+    error(...arg) {
+        console.error(`[ERROR]`, ...arg);
+    }
+}
+exports.ConsoleLogger = ConsoleLogger;
+class NoopLogger {
+    debug() { }
+    info() { }
+    warn() { }
+    error() { }
+}
+exports.NoopLogger = NoopLogger;

package/dist/sdk/OperationTracker.d.ts

@@ -1,13 +1,28 @@
-import { Network, TransactionLinker, SimplifiedStatuses, OperationType, OperationIdsByShardsKey, ExecutionStages, ExecutionStagesByOperationId, StatusInfosByOperationId, StatusInfo } from '../structs/Struct';
-export declare class OperationTracker {
-    private readonly clients;
-    constructor(network: Network, customLiteSequencerEndpoints?: string[]);
+import { ILogger, IOperationTracker } from '../structs/Services';
+import { ExecutionStages, ExecutionStagesByOperationId, Network, OperationIdsByShardsKey, OperationType, SimplifiedStatuses, StatusInfo, StatusInfosByOperationId, TransactionLinker, WaitOptions } from '../structs/Struct';
+export interface ILiteSequencerClientFactory {
+    createClients(endpoints: string[]): ILiteSequencerClient[];
+}
+export interface ILiteSequencerClient {
     getOperationType(operationId: string): Promise<OperationType>;
     getOperationId(transactionLinker: TransactionLinker): Promise<string>;
     getOperationIdsByShardsKeys(shardsKeys: string[], caller: string, chunkSize?: number): Promise<OperationIdsByShardsKey>;
-    getStageProfiling(operationId: string): Promise<ExecutionStages>;
     getStageProfilings(operationIds: string[], chunkSize?: number): Promise<ExecutionStagesByOperationId>;
     getOperationStatuses(operationIds: string[], chunkSize?: number): Promise<StatusInfosByOperationId>;
-    getOperationStatus(operationId: string): Promise<StatusInfo>;
+}
+export declare class DefaultLiteSequencerClientFactory implements ILiteSequencerClientFactory {
+    createClients(endpoints: string[]): ILiteSequencerClient[];
+}
+export declare class OperationTracker implements IOperationTracker {
+    private readonly clients;
+    private readonly logger;
+    constructor(network: Network, customLiteSequencerEndpoints?: string[], logger?: ILogger, clientFactory?: ILiteSequencerClientFactory);
+    getOperationType(operationId: string, waitOptions?: WaitOptions<OperationType>): Promise<OperationType>;
+    getOperationId(transactionLinker: TransactionLinker, 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>;
 }

package/dist/sdk/OperationTracker.js

@@ -1,110 +1,190 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OperationTracker = void 0;
-const Struct_1 = require("../structs/Struct");
+exports.OperationTracker = exports.DefaultLiteSequencerClientFactory = void 0;
 const artifacts_1 = require("@tonappchain/artifacts");
+const errors_1 = require("../errors");
+const Struct_1 = require("../structs/Struct");
 const LiteSequencerClient_1 = require("./LiteSequencerClient");
+const Logger_1 = require("./Logger");
+const Utils_1 = require("./Utils");
+class DefaultLiteSequencerClientFactory {
+    createClients(endpoints) {
+        return endpoints.map(endpoint => new LiteSequencerClient_1.LiteSequencerClient(endpoint));
+    }
+}
+exports.DefaultLiteSequencerClientFactory = DefaultLiteSequencerClientFactory;
 class OperationTracker {
-    constructor(network, customLiteSequencerEndpoints) {
+    constructor(network, customLiteSequencerEndpoints, logger = new Logger_1.NoopLogger(), clientFactory = new DefaultLiteSequencerClientFactory()) {
         const endpoints = customLiteSequencerEndpoints ??
             (network === Struct_1.Network.TESTNET
                 ? artifacts_1.testnet.PUBLIC_LITE_SEQUENCER_ENDPOINTS
                 : artifacts_1.mainnet.PUBLIC_LITE_SEQUENCER_ENDPOINTS);
-        this.clients = endpoints.map((endpoint) => new LiteSequencerClient_1.LiteSequencerClient(endpoint));
+        this.clients = clientFactory.createClients(endpoints);
+        this.logger = logger;
     }
-    async getOperationType(operationId) {
-        for (const client of this.clients) {
-            try {
-                return await client.getOperationType(operationId);
-            }
-            catch (error) {
-                console.error('Failed to get operationType:', error);
+    async getOperationType(operationId, waitOptions) {
+        this.logger.debug(`Getting operation type for ${(0, Utils_1.formatObjectForLogging)(operationId)}`);
+        const requestFn = async () => {
+            let lastError;
+            for (const client of this.clients) {
+                try {
+                    const type = await client.getOperationType(operationId);
+                    this.logger.debug(`Operation retrieved successfully`);
+                    return type;
+                }
+                catch (error) {
+                    this.logger.warn(`Failed to get operationType using one of the endpoints`);
+                    lastError = error;
+                }
             }
-        }
-        throw new Error('All endpoints failed to get operation type');
+            this.logger.error('All endpoints failed to get operation type');
+            throw (0, errors_1.allEndpointsFailedError)(lastError);
+        };
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : await requestFn();
     }
-    async getOperationId(transactionLinker) {
-        for (const client of this.clients) {
-            try {
-                return await client.getOperationId(transactionLinker);
-            }
-            catch (error) {
-                console.error('Failed to get OperationId:', error);
+    async getOperationId(transactionLinker, waitOptions) {
+        this.logger.debug(`Getting operation ID for transaction linker: ${(0, Utils_1.formatObjectForLogging)(transactionLinker)}`);
+        const requestFn = async () => {
+            let lastError;
+            for (const client of this.clients) {
+                try {
+                    const id = await client.getOperationId(transactionLinker);
+                    this.logger.debug(`Operation ID ${id == '' ? 'does not exist' : 'retrieved successfully'}`);
+                    return id;
+                }
+                catch (error) {
+                    this.logger.warn(`Failed to get OperationId using one of the endpoints`);
+                    lastError = error;
+                }
             }
-        }
-        throw new Error('All endpoints failed to get operation id');
+            this.logger.error('All endpoints failed to get operation id');
+            throw (0, errors_1.allEndpointsFailedError)(lastError);
+        };
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : await requestFn();
     }
-    async getOperationIdsByShardsKeys(shardsKeys, caller, chunkSize = 100) {
-        for (const client of this.clients) {
-            try {
-                return await client.getOperationIdsByShardsKeys(shardsKeys, caller, chunkSize);
-            }
-            catch (error) {
-                console.error('Failed to get OperationIds:', error);
+    async getOperationIdsByShardsKeys(shardsKeys, caller, waitOptions, chunkSize = 100) {
+        this.logger.debug(`Getting operation IDs for shards keys: ${(0, Utils_1.formatObjectForLogging)(shardsKeys)}`);
+        this.logger.debug(`Caller: ${caller}, Chunk size: ${chunkSize}`);
+        const requestFn = async () => {
+            let lastError;
+            for (const client of this.clients) {
+                try {
+                    const result = await client.getOperationIdsByShardsKeys(shardsKeys, caller, chunkSize);
+                    this.logger.debug(`Operation IDs by shards keys retrieved successfully`);
+                    return result;
+                }
+                catch (error) {
+                    this.logger.warn(`Failed to get OperationIds using one of the endpoints`);
+                    lastError = error;
+                }
             }
-        }
-        throw new Error('All endpoints failed to get operation ids by shards keys');
+            this.logger.error('All endpoints failed to get operation ids by shards keys');
+            throw (0, errors_1.allEndpointsFailedError)(lastError);
+        };
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : await requestFn();
     }
-    async getStageProfiling(operationId) {
-        for (const client of this.clients) {
-            try {
-                const map = await client.getStageProfilings([operationId]);
-                const result = map[operationId];
-                if (!result) {
-                    throw new Error(`No stageProfiling data for operationId=${operationId}`);
+    async getStageProfiling(operationId, waitOptions) {
+        this.logger.debug(`Getting stage profiling for operation ${operationId}`);
+        const requestFn = async () => {
+            let lastError;
+            for (const client of this.clients) {
+                try {
+                    const map = await client.getStageProfilings([operationId]);
+                    const result = map[operationId];
+                    if (!result) {
+                        this.logger.warn(`No stageProfiling data for operationId=${operationId}`);
+                        throw new Error(`No stageProfiling data for operationId=${operationId}`);
+                    }
+                    this.logger.debug(`Stage profiling retrieved successfully`);
+                    return result;
+                }
+                catch (error) {
+                    this.logger.warn(`Failed to get stage profiling using one of the endpoints`);
+                    lastError = error;
                 }
-                return result;
-            }
-            catch (error) {
-                console.error('Failed to get stage profiling:', error);
             }
-        }
-        throw new Error('All endpoints failed to get stage profiling');
+            this.logger.error('All endpoints failed to get stage profiling');
+            throw (0, errors_1.allEndpointsFailedError)(lastError);
+        };
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : await requestFn();
     }
-    async getStageProfilings(operationIds, chunkSize = 100) {
-        for (const client of this.clients) {
-            try {
-                return await client.getStageProfilings(operationIds, chunkSize);
-            }
-            catch (error) {
-                console.error('Failed to get stage profilings:', error);
+    async getStageProfilings(operationIds, waitOptions, chunkSize = 100) {
+        this.logger.debug(`Getting stage profilings for operations: ${operationIds.join(', ')}`);
+        this.logger.debug(`Chunk size: ${chunkSize}`);
+        const requestFn = async () => {
+            let lastError;
+            for (const client of this.clients) {
+                try {
+                    const result = await client.getStageProfilings(operationIds, chunkSize);
+                    this.logger.debug(`Stage profilings retrieved successfully`);
+                    return result;
+                }
+                catch (error) {
+                    this.logger.warn(`Failed to get stage profilings using one of the endpoints`);
+                    lastError = error;
+                }
             }
-        }
-        throw new Error('All endpoints failed to get stage profilings');
+            this.logger.error('All endpoints failed to get stage profilings');
+            throw (0, errors_1.allEndpointsFailedError)(lastError);
+        };
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : await requestFn();
     }
-    async getOperationStatuses(operationIds, chunkSize = 100) {
-        for (const client of this.clients) {
-            try {
-                return await client.getOperationStatuses(operationIds, chunkSize);
-            }
-            catch (error) {
-                console.error('Failed to get operation statuses:', error);
+    async getOperationStatuses(operationIds, waitOptions, chunkSize = 100) {
+        this.logger.debug(`Getting operation statuses for operations: ${(0, Utils_1.formatObjectForLogging)(operationIds)}`);
+        this.logger.debug(`Chunk size: ${chunkSize}`);
+        const requestFn = async () => {
+            let lastError;
+            for (const client of this.clients) {
+                try {
+                    const result = await client.getOperationStatuses(operationIds, chunkSize);
+                    this.logger.debug(`Operation statuses retrieved successfully`);
+                    return result;
+                }
+                catch (error) {
+                    this.logger.warn(`Failed to get operation statuses using one of the endpoints`);
+                    lastError = error;
+                }
             }
-        }
-        throw new Error('All endpoints failed to get operation statuses');
+            this.logger.error('All endpoints failed to get operation statuses');
+            throw (0, errors_1.allEndpointsFailedError)(lastError);
+        };
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : await requestFn();
     }
-    async getOperationStatus(operationId) {
-        for (const client of this.clients) {
-            try {
-                const map = await client.getOperationStatuses([operationId]);
-                const result = map[operationId];
-                if (!result) {
-                    throw new Error(`No operation status for operationId=${operationId}`);
+    async getOperationStatus(operationId, waitOptions) {
+        this.logger.debug(`Getting operation status for ${(0, Utils_1.formatObjectForLogging)(operationId)}`);
+        const requestFn = async () => {
+            let lastError;
+            for (const client of this.clients) {
+                try {
+                    const map = await client.getOperationStatuses([operationId]);
+                    const result = map[operationId];
+                    if (!result) {
+                        this.logger.warn(`No operation status for operationId=${operationId}`);
+                        throw new Error(`No operation status for operationId=${operationId}`);
+                    }
+                    this.logger.debug(`Operation status retrieved successfully`);
+                    return result;
+                }
+                catch (error) {
+                    this.logger.warn(`Failed to get operation status using one of the endpoints`);
+                    lastError = error;
                 }
-                return result;
-            }
-            catch (error) {
-                console.error('Failed to get operation status:', error);
             }
-        }
-        throw new Error('All endpoints failed to get operation status');
+            this.logger.error('All endpoints failed to get operation status');
+            throw (0, errors_1.allEndpointsFailedError)(lastError);
+        };
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : await requestFn();
     }
     async getSimplifiedOperationStatus(transactionLinker) {
+        this.logger.debug(`Getting simplified operation status for transaction linker: ${(0, Utils_1.formatObjectForLogging)(transactionLinker)}`);
         const operationId = await this.getOperationId(transactionLinker);
         if (operationId == '') {
+            this.logger.warn('Operation ID not found');
             return Struct_1.SimplifiedStatuses.OPERATION_ID_NOT_FOUND;
         }
+        this.logger.debug(`Operation ID: ${operationId}`);
         const operationType = await this.getOperationType(operationId);
+        this.logger.debug(`Operation type: ${operationType}`);
         if (operationType == Struct_1.OperationType.PENDING || operationType == Struct_1.OperationType.UNKNOWN) {
             return Struct_1.SimplifiedStatuses.PENDING;
         }

package/dist/sdk/Simulator.d.ts

@@ -0,0 +1,23 @@
+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>;
+}