@tonappchain/sdk 0.6.6-mainnet-alpha → 0.7.0-rc10

package/dist/sdk/LiteSequencerClient.js

@@ -1,20 +1,34 @@
 "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 Utils_1 = require("./Utils");
+const AxiosHttpClient_1 = require("./AxiosHttpClient");
 class LiteSequencerClient {
-    constructor(endpoint, maxChunkSize = 100) {
+    constructor(endpoint, maxChunkSize = 100, httpClient = new AxiosHttpClient_1.AxiosHttpClient()) {
         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(), {
+                params: { transactionHash },
+            });
+            return response.data.response || '';
+        }
+        catch (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 axios_1.default.get(new URL('operation-type', this.endpoint).toString(), {
+            const response = await this.httpClient.get(new URL('operation-type', this.endpoint).toString(), {
                 params: {
                     operationId,
                 },
@@ -33,14 +47,12 @@ class LiteSequencerClient {
             timestamp: transactionLinker.timestamp,
         };
         try {
-            const response = await axios_1.default.post(new URL('ton/operation-id', this.endpoint).toString(), requestBody);
+            const response = await this.httpClient.post(new URL('ton/operation-id', this.endpoint).toString(), requestBody);
             return response.data.response || '';
         }
         catch (error) {
-            if (axios_1.default.isAxiosError(error)) {
-                if (error.response?.status === 404) {
-                    return '';
-                }
+            if (error?.response?.status === 404) {
+                return '';
             }
             throw (0, errors_1.operationFetchError)(`endpoint ${this.endpoint} failed to complete request`, error);
         }
@@ -51,7 +63,7 @@ class LiteSequencerClient {
         }
         try {
             const response = await this.processChunkedRequest(shardsKeys, async (chunk) => {
-                const response = await axios_1.default.post(new URL('operation-ids-by-shards-keys', this.endpoint).toString(), {
+                const response = await this.httpClient.post(new URL('operation-ids-by-shards-keys', this.endpoint).toString(), {
                     shardsKeys: chunk,
                     caller: caller,
                 });
@@ -69,7 +81,7 @@ class LiteSequencerClient {
         }
         try {
             const response = await this.processChunkedRequest(operationIds, async (chunk) => {
-                const response = await axios_1.default.post(new URL('stage-profiling', this.endpoint).toString(), {
+                const response = await this.httpClient.post(new URL('stage-profiling', this.endpoint).toString(), {
                     operationIds: chunk,
                 }, {
                     transformResponse: [Utils_1.toCamelCaseTransformer],
@@ -88,7 +100,7 @@ class LiteSequencerClient {
         }
         try {
             const response = await this.processChunkedRequest(operationIds, async (chunk) => {
-                const response = await axios_1.default.post(new URL('status', this.endpoint).toString(), {
+                const response = await this.httpClient.post(new URL('status', this.endpoint).toString(), {
                     operationIds: chunk,
                 }, {
                     transformResponse: [Utils_1.toCamelCaseTransformer],
@@ -101,6 +113,38 @@ class LiteSequencerClient {
             throw (0, errors_1.statusFetchError)(`endpoint ${this.endpoint} failed to complete request`, error);
         }
     }
+    async convertCurrency(params) {
+        try {
+            const payload = {
+                currencyType: params.currencyType,
+                rawValue: params.rawValue.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 {
+                spotRawValue: BigInt(raw.spotRawValue),
+                spotFriendlyValue: raw.spotFriendlyValue,
+                emaValue: BigInt(raw.emaValue),
+                emaFriendlyValue: raw.emaFriendlyValue,
+                spotValueInUSD: Number(raw.spotValueInUSD),
+                emaValueInUSD: Number(raw.emaValueInUSD),
+                currencyType: raw.currencyType,
+                tacPrice: {
+                    spot: BigInt(raw.tacPrice.spot),
+                    ema: BigInt(raw.tacPrice.ema),
+                },
+                tonPrice: {
+                    spot: BigInt(raw.tonPrice.spot),
+                    ema: BigInt(raw.tonPrice.ema),
+                },
+            };
+        }
+        catch (error) {
+            throw (0, errors_1.operationFetchError)(`endpoint ${this.endpoint} failed to complete request`, error);
+        }
+    }
     async processChunkedRequest(identificators, requestFn, chunkSize = this.maxChunkSize) {
         const results = [];
         for (let i = 0; i < identificators.length; i += chunkSize) {

package/dist/sdk/Logger.d.ts

@@ -0,0 +1,13 @@
+import { ILogger } from '../interfaces';
+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,9 +1,13 @@
-import { ExecutionStages, ExecutionStagesByOperationId, Network, OperationIdsByShardsKey, OperationType, SimplifiedStatuses, StatusInfo, StatusInfosByOperationId, TransactionLinker, WaitOptions } from '../structs/Struct';
-export declare class OperationTracker {
+import { ILogger, IOperationTracker, ILiteSequencerClientFactory, ILiteSequencerClient } from '../interfaces';
+import { ConvertCurrencyParams, ConvertedCurrencyResult, ExecutionStages, ExecutionStagesByOperationId, Network, OperationIdsByShardsKey, OperationType, SimplifiedStatuses, StatusInfo, StatusInfosByOperationId, TransactionLinker, WaitOptions } from '../structs/Struct';
+export declare class DefaultLiteSequencerClientFactory implements ILiteSequencerClientFactory {
+    createClients(endpoints: string[]): ILiteSequencerClient[];
+}
+export declare class OperationTracker implements IOperationTracker {
     private readonly clients;
-    private readonly debug;
-    constructor(network: Network, customLiteSequencerEndpoints?: string[], debug?: boolean);
-    private debugLog;
+    private readonly logger;
+    constructor(network: Network, customLiteSequencerEndpoints?: string[], logger?: ILogger, clientFactory?: ILiteSequencerClientFactory);
+    getOperationIdByTransactionHash(transactionHash: string, waitOptions?: WaitOptions<string>): Promise<string>;
     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>;
@@ -12,4 +16,5 @@ export declare class OperationTracker {
     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>;
 }

package/dist/sdk/OperationTracker.js

@@ -1,88 +1,110 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OperationTracker = void 0;
+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, debug = false) {
+    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.debug = debug;
+        this.clients = clientFactory.createClients(endpoints);
+        this.logger = logger;
     }
-    debugLog(message) {
-        if (this.debug) {
-            console.log(`[OperationTracker Debug] ${message}`);
-        }
+    async getOperationIdByTransactionHash(transactionHash, waitOptions) {
+        this.logger.debug(`Getting operation ID for transactionHash: ${(0, Utils_1.formatObjectForLogging)(transactionHash)}`);
+        const requestFn = async () => {
+            let lastError;
+            for (const client of this.clients) {
+                try {
+                    const id = await client.getOperationIdByTransactionHash(transactionHash);
+                    this.logger.debug(`Operation ID ${id == '' ? 'does not exist' : 'retrieved successfully'}`);
+                    return id;
+                }
+                catch (error) {
+                    this.logger.warn(`Failed to get OperationId by transactionHash using one of the endpoints`);
+                    lastError = error;
+                }
+            }
+            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) : await requestFn();
     }
     async getOperationType(operationId, waitOptions) {
-        this.debugLog(`Getting operation type for ${(0, Utils_1.formatObjectForLogging)(operationId)}`);
+        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.debugLog(`Operation retrieved successfully`);
+                    this.logger.debug(`Operation retrieved successfully`);
                     return type;
                 }
                 catch (error) {
-                    this.debugLog(`Failed to get operationType using one of the endpoints`);
+                    this.logger.warn(`Failed to get operationType using one of the endpoints`);
                     lastError = error;
                 }
             }
-            this.debugLog('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, waitOptions) {
-        this.debugLog(`Getting operation ID for transaction linker: ${(0, Utils_1.formatObjectForLogging)(transactionLinker)}`);
+        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.debugLog(`Operation ID ${id == '' ? 'does not exist' : 'retrieved successfully'}`);
+                    this.logger.debug(`Operation ID ${id == '' ? 'does not exist' : 'retrieved successfully'}`);
                     return id;
                 }
                 catch (error) {
-                    this.debugLog(`Failed to get OperationId using one of the endpoints`);
+                    this.logger.warn(`Failed to get OperationId using one of the endpoints`);
                     lastError = error;
                 }
             }
-            this.debugLog('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, waitOptions, chunkSize = 100) {
-        this.debugLog(`Getting operation IDs for shards keys: ${(0, Utils_1.formatObjectForLogging)(shardsKeys)}`);
-        this.debugLog(`Caller: ${caller}, Chunk size: ${chunkSize}`);
+        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.debugLog(`Operation IDs by shards keys retrieved successfully`);
+                    this.logger.debug(`Operation IDs by shards keys retrieved successfully`);
                     return result;
                 }
                 catch (error) {
-                    this.debugLog(`Failed to get OperationIds using one of the endpoints`);
+                    this.logger.warn(`Failed to get OperationIds using one of the endpoints`);
                     lastError = error;
                 }
             }
-            this.debugLog('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, waitOptions) {
-        this.debugLog(`Getting stage profiling for operation ${operationId}`);
+        this.logger.debug(`Getting stage profiling for operation ${operationId}`);
         const requestFn = async () => {
             let lastError;
             for (const client of this.clients) {
@@ -90,66 +112,66 @@ class OperationTracker {
                     const map = await client.getStageProfilings([operationId]);
                     const result = map[operationId];
                     if (!result) {
-                        this.debugLog(`No stageProfiling data for operationId=${operationId}`);
+                        this.logger.warn(`No stageProfiling data for operationId=${operationId}`);
                         throw new Error(`No stageProfiling data for operationId=${operationId}`);
                     }
-                    this.debugLog(`Stage profiling retrieved successfully`);
+                    this.logger.debug(`Stage profiling retrieved successfully`);
                     return result;
                 }
                 catch (error) {
-                    this.debugLog(`Failed to get stage profiling using one of the endpoints`);
+                    this.logger.warn(`Failed to get stage profiling using one of the endpoints`);
                     lastError = error;
                 }
             }
-            this.debugLog('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, waitOptions, chunkSize = 100) {
-        this.debugLog(`Getting stage profilings for operations: ${operationIds.join(', ')}`);
-        this.debugLog(`Chunk size: ${chunkSize}`);
+        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.debugLog(`Stage profilings retrieved successfully`);
+                    this.logger.debug(`Stage profilings retrieved successfully`);
                     return result;
                 }
                 catch (error) {
-                    this.debugLog(`Failed to get stage profilings using one of the endpoints`);
+                    this.logger.warn(`Failed to get stage profilings using one of the endpoints`);
                     lastError = error;
                 }
             }
-            this.debugLog('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, waitOptions, chunkSize = 100) {
-        this.debugLog(`Getting operation statuses for operations: ${(0, Utils_1.formatObjectForLogging)(operationIds)}`);
-        this.debugLog(`Chunk size: ${chunkSize}`);
+        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.debugLog(`Operation statuses retrieved successfully`);
+                    this.logger.debug(`Operation statuses retrieved successfully`);
                     return result;
                 }
                 catch (error) {
-                    this.debugLog(`Failed to get operation statuses using one of the endpoints`);
+                    this.logger.warn(`Failed to get operation statuses using one of the endpoints`);
                     lastError = error;
                 }
             }
-            this.debugLog('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, waitOptions) {
-        this.debugLog(`Getting operation status for ${(0, Utils_1.formatObjectForLogging)(operationId)}`);
+        this.logger.debug(`Getting operation status for ${(0, Utils_1.formatObjectForLogging)(operationId)}`);
         const requestFn = async () => {
             let lastError;
             for (const client of this.clients) {
@@ -157,32 +179,32 @@ class OperationTracker {
                     const map = await client.getOperationStatuses([operationId]);
                     const result = map[operationId];
                     if (!result) {
-                        this.debugLog(`No operation status for operationId=${operationId}`);
+                        this.logger.warn(`No operation status for operationId=${operationId}`);
                         throw new Error(`No operation status for operationId=${operationId}`);
                     }
-                    this.debugLog(`Operation status retrieved successfully`);
+                    this.logger.debug(`Operation status retrieved successfully`);
                     return result;
                 }
                 catch (error) {
-                    this.debugLog(`Failed to get operation status using one of the endpoints`);
+                    this.logger.warn(`Failed to get operation status using one of the endpoints`);
                     lastError = error;
                 }
             }
-            this.debugLog('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.debugLog(`Getting simplified operation status for transaction linker: ${(0, Utils_1.formatObjectForLogging)(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.debugLog('Operation ID not found');
+            this.logger.warn('Operation ID not found');
             return Struct_1.SimplifiedStatuses.OPERATION_ID_NOT_FOUND;
         }
-        this.debugLog(`Operation ID: ${operationId}`);
+        this.logger.debug(`Operation ID: ${operationId}`);
         const operationType = await this.getOperationType(operationId);
-        this.debugLog(`Operation type: ${operationType}`);
+        this.logger.debug(`Operation type: ${operationType}`);
         if (operationType == Struct_1.OperationType.PENDING || operationType == Struct_1.OperationType.UNKNOWN) {
             return Struct_1.SimplifiedStatuses.PENDING;
         }
@@ -191,5 +213,25 @@ 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) : await requestFn();
+    }
 }
 exports.OperationTracker = OperationTracker;

package/dist/sdk/Simulator.d.ts

@@ -0,0 +1,17 @@
+import type { ISender } from '../sender';
+import { IConfiguration, ILogger, ISimulator } from '../interfaces';
+import { IAsset, CrosschainTx, EvmProxyMsg, ExecutionFeeEstimationResult, SuggestedTONExecutorFee, TACSimulationRequest, TACSimulationResult, TransactionLinker } from '../structs/Struct';
+import { IHttpClient } from '../interfaces';
+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: ISender, txs: CrosschainTx[]): Promise<TACSimulationResult[]>;
+    private buildTACSimulationRequest;
+    getTVMExecutorFeeInfo(assets: IAsset[], feeSymbol: string, tvmValidExecutors?: string[]): Promise<SuggestedTONExecutorFee>;
+    private getFeeInfo;
+    getTransactionSimulationInfo(evmProxyMsg: EvmProxyMsg, sender: ISender, assets?: IAsset[]): Promise<ExecutionFeeEstimationResult>;
+    getSimulationInfoForTransaction(evmProxyMsg: EvmProxyMsg, transactionLinker: TransactionLinker, assets: IAsset[], allowSimulationError?: boolean, isRoundTrip?: boolean, evmValidExecutors?: string[], tvmValidExecutors?: string[], calculateRollbackFee?: boolean): Promise<ExecutionFeeEstimationResult>;
+}

package/dist/sdk/Simulator.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Simulator = void 0;
+const ton_1 = require("@ton/ton");
+const errors_1 = require("../errors");
+const Logger_1 = require("./Logger");
+const Utils_1 = require("./Utils");
+const Validator_1 = require("./Validator");
+const AxiosHttpClient_1 = require("./AxiosHttpClient");
+class Simulator {
+    constructor(config, logger = new Logger_1.NoopLogger(), httpClient = new AxiosHttpClient_1.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, calculateRollbackFee = true, } = 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,
+            calculateRollbackFee: calculateRollbackFee,
+        };
+    }
+    async getTVMExecutorFeeInfo(assets, feeSymbol, tvmValidExecutors = this.config.TACParams.trustedTONExecutors) {
+        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,
+            tvmValidExecutors: tvmValidExecutors,
+        };
+        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, calculateRollbackFee = true) {
+        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,
+            calculateRollbackFee: calculateRollbackFee,
+        };
+        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, calculateRollbackFee) {
+        return await this.getFeeInfo(evmProxyMsg, transactionLinker, assets, allowSimulationError, isRoundTrip, evmValidExecutors, tvmValidExecutors, calculateRollbackFee);
+    }
+}
+exports.Simulator = Simulator;