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

package/dist/sdk/Configuration.js

@@ -0,0 +1,92 @@
+"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();
+        const smartAccountFactory = artifacts.tac.wrappers.TacSAFactory_factoryTAC.connect(artifacts.TAC_SMART_ACCOUNT_FACTORY_ADDRESS, provider);
+        return {
+            provider,
+            settings,
+            tokenUtils,
+            crossChainLayer,
+            trustedTACExecutors,
+            trustedTONExecutors,
+            abiCoder: new ethers_1.ethers.AbiCoder(),
+            smartAccountFactory,
+        };
+    }
+    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/{src/sdk → sdk}/Consts.d.ts

@@ -10,6 +10,3 @@ export declare const MAX_HIGHLOAD_GROUP_MSG_NUM = 254;
 export declare const MAX_MSG_DEPTH = 512;
 export declare const TON_SYMBOL = "TON";
 export declare const TAC_SYMBOL = "TAC";
-export declare const FIFTEEN_MINUTES: number;
-export declare const TON_DECIMALS = 9;
-export declare const TAC_DECIMALS = 18;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TAC_DECIMALS = exports.TON_DECIMALS = exports.FIFTEEN_MINUTES = exports.TAC_SYMBOL = exports.TON_SYMBOL = exports.MAX_MSG_DEPTH = exports.MAX_HIGHLOAD_GROUP_MSG_NUM = exports.MAX_EXT_MSG_SIZE = exports.SOLIDITY_METHOD_NAME_REGEX = exports.SOLIDITY_SIGNATURE_REGEX = exports.DEFAULT_DELAY = exports.MAX_ITERATION_COUNT = exports.NFT_TRANSFER_FORWARD_TON_AMOUNT = exports.JETTON_TRANSFER_FORWARD_TON_AMOUNT = exports.TRANSACTION_TON_AMOUNT = void 0;
+exports.TAC_SYMBOL = exports.TON_SYMBOL = exports.MAX_MSG_DEPTH = exports.MAX_HIGHLOAD_GROUP_MSG_NUM = exports.MAX_EXT_MSG_SIZE = exports.SOLIDITY_METHOD_NAME_REGEX = exports.SOLIDITY_SIGNATURE_REGEX = exports.DEFAULT_DELAY = exports.MAX_ITERATION_COUNT = exports.NFT_TRANSFER_FORWARD_TON_AMOUNT = exports.JETTON_TRANSFER_FORWARD_TON_AMOUNT = exports.TRANSACTION_TON_AMOUNT = void 0;
 const ton_1 = require("@ton/ton");
 exports.TRANSACTION_TON_AMOUNT = (0, ton_1.toNano)(0.55);
 exports.JETTON_TRANSFER_FORWARD_TON_AMOUNT = (0, ton_1.toNano)(0.2);
@@ -14,6 +14,3 @@ exports.MAX_HIGHLOAD_GROUP_MSG_NUM = 254;
 exports.MAX_MSG_DEPTH = 512;
 exports.TON_SYMBOL = 'TON';
 exports.TAC_SYMBOL = 'TAC';
-exports.FIFTEEN_MINUTES = 15 * 60 * 1000;
-exports.TON_DECIMALS = 9;
-exports.TAC_DECIMALS = 18;

package/dist/sdk/LiteSequencerClient.d.ts

@@ -0,0 +1,13 @@
+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/{src/sdk → sdk}/LiteSequencerClient.js

@@ -1,35 +1,38 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LiteSequencerClient = void 0;
+const axios_1 = __importDefault(require("axios"));
 const errors_1 = require("../errors");
-const instances_1 = require("../errors/instances");
-const AxiosHttpClient_1 = require("./AxiosHttpClient");
 const Utils_1 = require("./Utils");
 class LiteSequencerClient {
-    constructor(endpoint, maxChunkSize = 100, httpClient = new AxiosHttpClient_1.AxiosHttpClient()) {
+    constructor(endpoint, maxChunkSize = 100) {
         this.endpoint = endpoint;
         this.maxChunkSize = maxChunkSize;
-        this.httpClient = httpClient;
     }
     async getOperationIdByTransactionHash(transactionHash) {
         const isEthHash = /^0x[a-fA-F0-9]{64}$/.test(transactionHash);
         const path = isEthHash ? 'tac/operation-id' : 'ton/operation-id';
         try {
-            const response = await this.httpClient.get(new URL(path, this.endpoint).toString(), {
+            const response = await axios_1.default.get(new URL(path, this.endpoint).toString(), {
                 params: { transactionHash },
             });
             return response.data.response || '';
         }
         catch (error) {
-            if (error?.response?.status === 404) {
-                return '';
+            if (axios_1.default.isAxiosError(error)) {
+                if (error.response?.status === 404) {
+                    return '';
+                }
             }
             throw (0, errors_1.operationFetchError)(`endpoint ${this.endpoint} failed to complete request`, error);
         }
     }
     async getOperationType(operationId) {
         try {
-            const response = await this.httpClient.get(new URL('operation-type', this.endpoint).toString(), {
+            const response = await axios_1.default.get(new URL('operation-type', this.endpoint).toString(), {
                 params: {
                     operationId,
                 },
@@ -48,12 +51,14 @@ class LiteSequencerClient {
             timestamp: transactionLinker.timestamp,
         };
         try {
-            const response = await this.httpClient.post(new URL('ton/operation-id', this.endpoint).toString(), requestBody);
+            const response = await axios_1.default.post(new URL('ton/operation-id', this.endpoint).toString(), requestBody);
             return response.data.response || '';
         }
         catch (error) {
-            if (error?.response?.status === 404) {
-                return '';
+            if (axios_1.default.isAxiosError(error)) {
+                if (error.response?.status === 404) {
+                    return '';
+                }
             }
             throw (0, errors_1.operationFetchError)(`endpoint ${this.endpoint} failed to complete request`, error);
         }
@@ -64,7 +69,7 @@ class LiteSequencerClient {
         }
         try {
             const response = await this.processChunkedRequest(shardsKeys, async (chunk) => {
-                const response = await this.httpClient.post(new URL('operation-ids-by-shards-keys', this.endpoint).toString(), {
+                const response = await axios_1.default.post(new URL('operation-ids-by-shards-keys', this.endpoint).toString(), {
                     shardsKeys: chunk,
                     caller: caller,
                 });
@@ -82,7 +87,7 @@ class LiteSequencerClient {
         }
         try {
             const response = await this.processChunkedRequest(operationIds, async (chunk) => {
-                const response = await this.httpClient.post(new URL('stage-profiling', this.endpoint).toString(), {
+                const response = await axios_1.default.post(new URL('stage-profiling', this.endpoint).toString(), {
                     operationIds: chunk,
                 }, {
                     transformResponse: [Utils_1.toCamelCaseTransformer],
@@ -101,7 +106,7 @@ class LiteSequencerClient {
         }
         try {
             const response = await this.processChunkedRequest(operationIds, async (chunk) => {
-                const response = await this.httpClient.post(new URL('status', this.endpoint).toString(), {
+                const response = await axios_1.default.post(new URL('status', this.endpoint).toString(), {
                     operationIds: chunk,
                 }, {
                     transformResponse: [Utils_1.toCamelCaseTransformer],
@@ -114,63 +119,10 @@ class LiteSequencerClient {
             throw (0, errors_1.statusFetchError)(`endpoint ${this.endpoint} failed to complete request`, error);
         }
     }
-    async convertCurrency(params) {
-        try {
-            const payload = {
-                currency: params.currency,
-                value: params.value.toString(),
-            };
-            const response = await this.httpClient.post(new URL('convert_currency', this.endpoint).toString(), payload, {
-                transformResponse: [Utils_1.toCamelCaseTransformer],
-            });
-            const raw = response.data.response;
-            return {
-                decimals: raw.decimals,
-                spotValue: BigInt(raw.spotValue),
-                emaValue: BigInt(raw.emaValue),
-                currency: raw.currency,
-                tacPrice: {
-                    spot: BigInt(raw.tacPrice.spot),
-                    ema: BigInt(raw.tacPrice.ema),
-                    decimals: raw.tacPrice.decimals,
-                },
-                tonPrice: {
-                    spot: BigInt(raw.tonPrice.spot),
-                    ema: BigInt(raw.tonPrice.ema),
-                    decimals: raw.tonPrice.decimals,
-                },
-            };
-        }
-        catch (error) {
-            throw (0, instances_1.convertCurrencyFetchError)(`endpoint ${this.endpoint} failed to complete request`, error);
-        }
-    }
-    async simulateTACMessage(params) {
-        try {
-            const response = await this.httpClient.post(new URL('tac/simulator/simulate-message', this.endpoint).toString(), params, {
-                transformResponse: [Utils_1.toCamelCaseTransformer],
-            });
-            return response.data.response;
-        }
-        catch (error) {
-            throw (0, instances_1.simulationFetchError)(`endpoint ${this.endpoint} failed to complete request`, error);
-        }
-    }
-    async getTVMExecutorFee(params) {
-        try {
-            const response = await this.httpClient.post(new URL('/ton/calculator/ton-executor-fee', this.endpoint).toString(), params, {
-                transformResponse: [Utils_1.toCamelCaseTransformer],
-            });
-            return response.data.response;
-        }
-        catch (error) {
-            throw (0, instances_1.getTONFeeInfoFetchError)(`endpoint ${this.endpoint} failed to complete request`, error);
-        }
-    }
-    async processChunkedRequest(identifiers, requestFn, chunkSize = this.maxChunkSize) {
+    async processChunkedRequest(identificators, requestFn, chunkSize = this.maxChunkSize) {
         const results = [];
-        for (let i = 0; i < identifiers.length; i += chunkSize) {
-            const chunk = identifiers.slice(i, i + chunkSize);
+        for (let i = 0; i < identificators.length; i += chunkSize) {
+            const chunk = identificators.slice(i, i + chunkSize);
             const result = await requestFn(chunk);
             results.push(result);
         }

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

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

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

@@ -1,5 +1,16 @@
-import { ILiteSequencerClient, ILiteSequencerClientFactory, ILogger, IOperationTracker } from '../interfaces';
-import { ConvertCurrencyParams, ConvertedCurrencyResult, ExecutionStages, ExecutionStagesByOperationId, GetTVMExecutorFeeParams, Network, OperationIdsByShardsKey, OperationType, SimplifiedStatuses, StatusInfo, StatusInfosByOperationId, SuggestedTVMExecutorFee, TACSimulationParams, TACSimulationResult, TransactionLinker, WaitOptions } from '../structs/Struct';
+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>;
+    getOperationIdByTransactionHash(transactionHash: string): 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>;
+}
 export declare class DefaultLiteSequencerClientFactory implements ILiteSequencerClientFactory {
     createClients(endpoints: string[]): ILiteSequencerClient[];
 }
@@ -16,7 +27,4 @@ export declare class OperationTracker implements IOperationTracker {
     getOperationStatuses(operationIds: string[], waitOptions?: WaitOptions<StatusInfosByOperationId>, chunkSize?: number): Promise<StatusInfosByOperationId>;
     getOperationStatus(operationId: string, waitOptions?: WaitOptions<StatusInfo>): Promise<StatusInfo>;
     getSimplifiedOperationStatus(transactionLinker: TransactionLinker): Promise<SimplifiedStatuses>;
-    convertCurrency(params: ConvertCurrencyParams, waitOptions?: WaitOptions<ConvertedCurrencyResult>): Promise<ConvertedCurrencyResult>;
-    simulateTACMessage(params: TACSimulationParams, waitOptions?: WaitOptions<TACSimulationResult>): Promise<TACSimulationResult>;
-    getTVMExecutorFee(params: GetTVMExecutorFeeParams, waitOptions?: WaitOptions<SuggestedTVMExecutorFee>): Promise<SuggestedTVMExecutorFee>;
 }

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

@@ -1,34 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OperationTracker = exports.DefaultLiteSequencerClientFactory = void 0;
-const artifacts_1 = require("../../artifacts");
+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");
-const Validator_1 = require("./Validator");
 class DefaultLiteSequencerClientFactory {
     createClients(endpoints) {
-        return endpoints.map((endpoint) => new LiteSequencerClient_1.LiteSequencerClient(endpoint));
+        return endpoints.map(endpoint => new LiteSequencerClient_1.LiteSequencerClient(endpoint));
     }
 }
 exports.DefaultLiteSequencerClientFactory = DefaultLiteSequencerClientFactory;
 class OperationTracker {
     constructor(network, customLiteSequencerEndpoints, logger = new Logger_1.NoopLogger(), clientFactory = new DefaultLiteSequencerClientFactory()) {
-        let endpoints;
-        if (network === Struct_1.Network.DEV) {
-            if (!customLiteSequencerEndpoints || customLiteSequencerEndpoints.length === 0) {
-                throw new Error('For DEV network, custom lite sequencer endpoints must be provided');
-            }
-            endpoints = customLiteSequencerEndpoints;
-        }
-        else {
-            const artifacts = network === Struct_1.Network.MAINNET ? artifacts_1.mainnet : artifacts_1.testnet;
-            endpoints = customLiteSequencerEndpoints && customLiteSequencerEndpoints.length !== 0 ?
-                customLiteSequencerEndpoints :
-                artifacts.PUBLIC_LITE_SEQUENCER_ENDPOINTS;
-        }
+        const endpoints = customLiteSequencerEndpoints ??
+            (network === Struct_1.Network.TESTNET
+                ? artifacts_1.testnet.PUBLIC_LITE_SEQUENCER_ENDPOINTS
+                : artifacts_1.mainnet.PUBLIC_LITE_SEQUENCER_ENDPOINTS);
         this.clients = clientFactory.createClients(endpoints);
         this.logger = logger;
     }
@@ -50,7 +40,7 @@ class OperationTracker {
             this.logger.error('All endpoints failed to get operation id by transactionHash');
             throw (0, errors_1.allEndpointsFailedError)(lastError);
         };
-        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, "OperationTracker: Getting operation ID by transaction hash") : await requestFn();
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : await requestFn();
     }
     async getOperationType(operationId, waitOptions) {
         this.logger.debug(`Getting operation type for ${(0, Utils_1.formatObjectForLogging)(operationId)}`);
@@ -70,7 +60,7 @@ class OperationTracker {
             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, "OperationTracker: Getting operation type") : await requestFn();
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : await requestFn();
     }
     async getOperationId(transactionLinker, waitOptions) {
         this.logger.debug(`Getting operation ID for transaction linker: ${(0, Utils_1.formatObjectForLogging)(transactionLinker)}`);
@@ -90,7 +80,7 @@ class OperationTracker {
             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, "OperationTracker: Getting operation ID by transaction linker") : await requestFn();
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : await requestFn();
     }
     async getOperationIdsByShardsKeys(shardsKeys, caller, waitOptions, chunkSize = 100) {
         this.logger.debug(`Getting operation IDs for shards keys: ${(0, Utils_1.formatObjectForLogging)(shardsKeys)}`);
@@ -111,7 +101,7 @@ class OperationTracker {
             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, "OperationTracker: Getting operation IDs by shards keys") : await requestFn();
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : await requestFn();
     }
     async getStageProfiling(operationId, waitOptions) {
         this.logger.debug(`Getting stage profiling for operation ${operationId}`);
@@ -136,7 +126,7 @@ class OperationTracker {
             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, "OperationTracker: Getting stage profiling") : await requestFn();
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : await requestFn();
     }
     async getStageProfilings(operationIds, waitOptions, chunkSize = 100) {
         this.logger.debug(`Getting stage profilings for operations: ${operationIds.join(', ')}`);
@@ -157,7 +147,7 @@ class OperationTracker {
             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, "OperationTracker: Getting stage profilings") : await requestFn();
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : await requestFn();
     }
     async getOperationStatuses(operationIds, waitOptions, chunkSize = 100) {
         this.logger.debug(`Getting operation statuses for operations: ${(0, Utils_1.formatObjectForLogging)(operationIds)}`);
@@ -178,7 +168,7 @@ class OperationTracker {
             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, "OperationTracker: Getting operation statuses") : await requestFn();
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : await requestFn();
     }
     async getOperationStatus(operationId, waitOptions) {
         this.logger.debug(`Getting operation status for ${(0, Utils_1.formatObjectForLogging)(operationId)}`);
@@ -203,7 +193,7 @@ class OperationTracker {
             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, "OperationTracker: Getting operation status") : await requestFn();
+        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)}`);
@@ -212,7 +202,9 @@ class OperationTracker {
             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;
         }
@@ -221,66 +213,5 @@ class OperationTracker {
         }
         return Struct_1.SimplifiedStatuses.SUCCESSFUL;
     }
-    async convertCurrency(params, waitOptions) {
-        this.logger.debug(`Converting currency: ${(0, Utils_1.formatObjectForLogging)(params)}`);
-        const requestFn = async () => {
-            let lastError;
-            for (const client of this.clients) {
-                try {
-                    const result = await client.convertCurrency(params);
-                    this.logger.debug(`Conversion result retrieved successfully`);
-                    return result;
-                }
-                catch (error) {
-                    this.logger.warn(`Failed to convert currency using one of the endpoints`);
-                    lastError = error;
-                }
-            }
-            this.logger.error('All endpoints failed to convert currency');
-            throw (0, errors_1.allEndpointsFailedError)(lastError);
-        };
-        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, "OperationTracker: Converting currency") : await requestFn();
-    }
-    async simulateTACMessage(params, waitOptions) {
-        Validator_1.Validator.validateTACSimulationParams(params);
-        this.logger.debug(`Simulating TAC message: ${(0, Utils_1.formatObjectForLogging)(params)}`);
-        const requestFn = async () => {
-            let lastError;
-            for (const client of this.clients) {
-                try {
-                    const result = await client.simulateTACMessage(params);
-                    this.logger.debug(`Simulation result retrieved successfully`);
-                    return result;
-                }
-                catch (error) {
-                    this.logger.warn(`Failed to simulate TAC message using one of the endpoints`);
-                    lastError = error;
-                }
-            }
-            this.logger.error('All endpoints failed to simulate TAC message');
-            throw (0, errors_1.allEndpointsFailedError)(lastError);
-        };
-        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, "OperationTracker: Simulating TAC message") : await requestFn();
-    }
-    async getTVMExecutorFee(params, waitOptions) {
-        this.logger.debug(`get TVM executor fee: ${(0, Utils_1.formatObjectForLogging)(params)}`);
-        const requestFn = async () => {
-            let lastError;
-            for (const client of this.clients) {
-                try {
-                    const result = await client.getTVMExecutorFee(params);
-                    this.logger.debug(`Suggested TVM executor fee retrieved successfully`);
-                    return result;
-                }
-                catch (error) {
-                    this.logger.warn(`Failed to get TVM executor fee using one of the endpoints`);
-                    lastError = error;
-                }
-            }
-            this.logger.error('All endpoints failed to get TVM executor fee');
-            throw (0, errors_1.allEndpointsFailedError)(lastError);
-        };
-        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, "OperationTracker: Getting TVM executor fee") : await requestFn();
-    }
 }
 exports.OperationTracker = OperationTracker;

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>;
+}