@tonappchain/sdk 0.7.0-rc9 → 0.7.1

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

@@ -1,38 +1,43 @@
 "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) {
+    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 axios_1.default.get(new URL(path, this.endpoint).toString(), {
-                params: { transactionHash },
-            });
-            return response.data.response || '';
+            if (isEthHash) {
+                const response = await this.httpClient.get(new URL(path, this.endpoint).toString(), {
+                    params: { transactionHash },
+                });
+                return response.data.response?.operationId || '';
+            }
+            else {
+                const response = await this.httpClient.get(new URL(path, this.endpoint).toString(), {
+                    params: { transactionHash },
+                });
+                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);
         }
     }
     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,
                 },
@@ -51,14 +56,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);
         }
@@ -69,7 +72,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,
                 });
@@ -87,7 +90,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],
@@ -106,7 +109,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],
@@ -119,10 +122,63 @@ class LiteSequencerClient {
             throw (0, errors_1.statusFetchError)(`endpoint ${this.endpoint} failed to complete request`, error);
         }
     }
-    async processChunkedRequest(identificators, requestFn, chunkSize = this.maxChunkSize) {
+    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) {
         const results = [];
-        for (let i = 0; i < identificators.length; i += chunkSize) {
-            const chunk = identificators.slice(i, i + chunkSize);
+        for (let i = 0; i < identifiers.length; i += chunkSize) {
+            const chunk = identifiers.slice(i, i + chunkSize);
             const result = await requestFn(chunk);
             results.push(result);
         }

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

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

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

@@ -17,9 +17,17 @@ class ConsoleLogger {
 }
 exports.ConsoleLogger = ConsoleLogger;
 class NoopLogger {
-    debug() { }
-    info() { }
-    warn() { }
-    error() { }
+    debug(..._arg) {
+        void _arg;
+    }
+    info(..._arg) {
+        void _arg;
+    }
+    warn(..._arg) {
+        void _arg;
+    }
+    error(..._arg) {
+        void _arg;
+    }
 }
 exports.NoopLogger = NoopLogger;

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

@@ -1,16 +1,5 @@
-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>;
-}
+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';
 export declare class DefaultLiteSequencerClientFactory implements ILiteSequencerClientFactory {
     createClients(endpoints: string[]): ILiteSequencerClient[];
 }
@@ -27,4 +16,7 @@ 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/{sdk → src/sdk}/OperationTracker.js

@@ -1,24 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OperationTracker = exports.DefaultLiteSequencerClientFactory = void 0;
-const artifacts_1 = require("@tonappchain/artifacts");
+const artifacts_1 = require("../../artifacts");
 const errors_1 = require("../errors");
+const instances_1 = require("../errors/instances");
 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()) {
-        const endpoints = customLiteSequencerEndpoints ??
-            (network === Struct_1.Network.TESTNET
-                ? artifacts_1.testnet.PUBLIC_LITE_SEQUENCER_ENDPOINTS
-                : artifacts_1.mainnet.PUBLIC_LITE_SEQUENCER_ENDPOINTS);
+        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;
+        }
         this.clients = clientFactory.createClients(endpoints);
         this.logger = logger;
     }
@@ -40,7 +52,9 @@ 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) : await requestFn();
+        return waitOptions
+            ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, 'OperationTracker: Getting operation ID by transaction hash')
+            : await requestFn();
     }
     async getOperationType(operationId, waitOptions) {
         this.logger.debug(`Getting operation type for ${(0, Utils_1.formatObjectForLogging)(operationId)}`);
@@ -60,7 +74,9 @@ 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) : await requestFn();
+        return waitOptions
+            ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, 'OperationTracker: Getting operation type')
+            : await requestFn();
     }
     async getOperationId(transactionLinker, waitOptions) {
         this.logger.debug(`Getting operation ID for transaction linker: ${(0, Utils_1.formatObjectForLogging)(transactionLinker)}`);
@@ -80,7 +96,9 @@ 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) : await requestFn();
+        return waitOptions
+            ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, 'OperationTracker: Getting operation ID by transaction linker')
+            : await requestFn();
     }
     async getOperationIdsByShardsKeys(shardsKeys, caller, waitOptions, chunkSize = 100) {
         this.logger.debug(`Getting operation IDs for shards keys: ${(0, Utils_1.formatObjectForLogging)(shardsKeys)}`);
@@ -101,7 +119,9 @@ 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) : await requestFn();
+        return waitOptions
+            ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, 'OperationTracker: Getting operation IDs by shards keys')
+            : await requestFn();
     }
     async getStageProfiling(operationId, waitOptions) {
         this.logger.debug(`Getting stage profiling for operation ${operationId}`);
@@ -126,7 +146,9 @@ 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) : await requestFn();
+        return waitOptions
+            ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, 'OperationTracker: Getting stage profiling')
+            : await requestFn();
     }
     async getStageProfilings(operationIds, waitOptions, chunkSize = 100) {
         this.logger.debug(`Getting stage profilings for operations: ${operationIds.join(', ')}`);
@@ -147,7 +169,9 @@ 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) : await requestFn();
+        return waitOptions
+            ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, 'OperationTracker: Getting stage profilings')
+            : await requestFn();
     }
     async getOperationStatuses(operationIds, waitOptions, chunkSize = 100) {
         this.logger.debug(`Getting operation statuses for operations: ${(0, Utils_1.formatObjectForLogging)(operationIds)}`);
@@ -168,7 +192,9 @@ 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) : await requestFn();
+        return waitOptions
+            ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, 'OperationTracker: Getting operation statuses')
+            : await requestFn();
     }
     async getOperationStatus(operationId, waitOptions) {
         this.logger.debug(`Getting operation status for ${(0, Utils_1.formatObjectForLogging)(operationId)}`);
@@ -193,7 +219,9 @@ 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) : await requestFn();
+        return waitOptions
+            ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, 'OperationTracker: Getting operation status')
+            : await requestFn();
     }
     async getSimplifiedOperationStatus(transactionLinker) {
         this.logger.debug(`Getting simplified operation status for transaction linker: ${(0, Utils_1.formatObjectForLogging)(transactionLinker)}`);
@@ -202,9 +230,7 @@ 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;
         }
@@ -213,5 +239,75 @@ class OperationTracker {
         }
         return Struct_1.SimplifiedStatuses.SUCCESSFUL;
     }
+    async convertCurrency(params, waitOptions) {
+        if (params.value <= 0n) {
+            throw instances_1.convertCurrencyNegativeOrZeroValueError;
+        }
+        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/src/sdk/Simulator.d.ts

@@ -0,0 +1,11 @@
+import { IConfiguration, ILogger, IOperationTracker, ISimulator } from '../interfaces';
+import type { SenderAbstraction } from '../sender';
+import { CrosschainTx, ExecutionFeeEstimationResult } from '../structs/Struct';
+export declare class Simulator implements ISimulator {
+    private readonly config;
+    private readonly operationTracker;
+    private readonly logger;
+    constructor(config: IConfiguration, operationTracker: IOperationTracker, logger?: ILogger);
+    getSimulationsInfo(sender: SenderAbstraction, txs: CrosschainTx[]): Promise<ExecutionFeeEstimationResult[]>;
+    getSimulationInfo(sender: SenderAbstraction, tx: CrosschainTx): Promise<ExecutionFeeEstimationResult>;
+}

package/dist/src/sdk/Simulator.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Simulator = void 0;
+const ton_1 = require("@ton/ton");
+const Logger_1 = require("./Logger");
+const Utils_1 = require("./Utils");
+const Validator_1 = require("./Validator");
+class Simulator {
+    constructor(config, operationTracker, logger = new Logger_1.NoopLogger()) {
+        this.config = config;
+        this.operationTracker = operationTracker;
+        this.logger = logger;
+    }
+    async getSimulationsInfo(sender, txs) {
+        this.logger.debug(`Simulating ${txs.length} TAC messages`);
+        const results = [];
+        for (const tx of txs) {
+            const result = await this.getSimulationInfo(sender, tx);
+            results.push(result);
+        }
+        return results;
+    }
+    async getSimulationInfo(sender, tx) {
+        this.logger.debug('Getting simulation info');
+        const { evmProxyMsg, assets = [], options = {} } = tx;
+        const { evmValidExecutors = this.config.TACParams.trustedTACExecutors, tvmValidExecutors = this.config.TACParams.trustedTONExecutors, calculateRollbackFee = true, allowSimulationError = false, } = options;
+        Validator_1.Validator.validateEVMAddress(evmProxyMsg.evmTargetAddress);
+        Validator_1.Validator.validateEVMAddresses(evmValidExecutors);
+        Validator_1.Validator.validateTVMAddresses(tvmValidExecutors);
+        const aggregatedData = (0, Utils_1.aggregateTokens)(assets);
+        const shardCount = aggregatedData.jettons.length || 1;
+        const transactionLinker = (0, Utils_1.generateTransactionLinker)(sender.getSenderAddress(), shardCount);
+        const tacSimulationParams = {
+            tacCallParams: {
+                arguments: evmProxyMsg.encodedParameters ?? '0x',
+                methodName: (0, Utils_1.formatSolidityMethodName)(evmProxyMsg.methodName),
+                target: evmProxyMsg.evmTargetAddress,
+            },
+            evmValidExecutors,
+            tvmValidExecutors,
+            extraData: '0x',
+            shardsKey: transactionLinker.shardsKey,
+            tonAssets: (0, Utils_1.mapAssetsToTonAssets)(assets),
+            tonCaller: transactionLinker.caller,
+            calculateRollbackFee,
+        };
+        const simulation = await this.operationTracker.simulateTACMessage(tacSimulationParams);
+        this.logger.debug(`TAC simulation ${simulation.simulationStatus ? 'success' : 'failed'}`);
+        const isRoundTrip = options.isRoundTrip ?? (assets.length !== 0 || simulation.outMessages?.length !== 0);
+        const CrossChainLayerC = this.config.artifacts.ton.wrappers.CrossChainLayer;
+        const crossChainLayer = this.config.TONParams.contractOpener.open(CrossChainLayerC.createFromAddress(ton_1.Address.parse(this.config.TONParams.crossChainLayerAddress)));
+        const fullStateCCL = await crossChainLayer.getFullData();
+        const feeParams = {
+            isRoundTrip,
+            gasLimit: simulation.simulationStatus ? simulation.estimatedGas : 0n,
+            protocolFee: BigInt((0, ton_1.toNano)(fullStateCCL.tacProtocolFee)) +
+                BigInt(isRoundTrip) * BigInt((0, ton_1.toNano)(fullStateCCL.tonProtocolFee)),
+            evmExecutorFee: BigInt(simulation.suggestedTacExecutionFee),
+            tvmExecutorFee: BigInt(simulation.suggestedTonExecutionFee) * BigInt(isRoundTrip),
+        };
+        if (!simulation.simulationStatus && !allowSimulationError) {
+            throw simulation;
+        }
+        if (allowSimulationError && !simulation.simulationStatus) {
+            this.logger.info('Simulation failed but allowSimulationError is true, returning partial fee params');
+        }
+        return { feeParams, simulation };
+    }
+}
+exports.Simulator = Simulator;

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

@@ -1,5 +1,5 @@
+import { ILogger } from '../interfaces';
 import { TxFinalizerConfig } from '../structs/InternalStruct';
-import { ILogger } from '../structs/Services';
 import { ExecutionStages, Network, TransactionLinker } from '../structs/Struct';
 export declare function startTracking(transactionLinker: TransactionLinker, network: Network, options?: {
     customLiteSequencerEndpoints?: string[];

package/dist/src/sdk/TACTransactionManager.d.ts

@@ -0,0 +1,10 @@
+import { Wallet } from 'ethers';
+import { Asset, IConfiguration, ILogger, IOperationTracker, ITACTransactionManager } from '../interfaces';
+export declare class TACTransactionManager implements ITACTransactionManager {
+    private readonly config;
+    private readonly operationTracker;
+    private readonly logger;
+    constructor(config: IConfiguration, operationTracker: IOperationTracker, logger?: ILogger);
+    private approveAsset;
+    bridgeTokensToTON(signer: Wallet, value: bigint, tonTarget: string, assets?: Asset[], tvmExecutorFee?: bigint, tvmValidExecutors?: string[]): Promise<string>;
+}

package/dist/src/sdk/TACTransactionManager.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TACTransactionManager = void 0;
+const ethers_1 = require("ethers");
+const assets_1 = require("../assets");
+const Struct_1 = require("../structs/Struct");
+const Consts_1 = require("./Consts");
+const Logger_1 = require("./Logger");
+const Utils_1 = require("./Utils");
+const Validator_1 = require("./Validator");
+class TACTransactionManager {
+    constructor(config, operationTracker, logger = new Logger_1.NoopLogger()) {
+        this.config = config;
+        this.operationTracker = operationTracker;
+        this.logger = logger;
+    }
+    async approveAsset(asset, signer, spenderAddress) {
+        const evmAddress = await asset.getEVMAddress();
+        if (asset.type === Struct_1.AssetType.FT) {
+            this.logger.debug(`Approving FT ${evmAddress} for ${spenderAddress}`);
+            const erc20Abi = this.config.artifacts.tac.compilationArtifacts.IERC20WithDecimals.abi;
+            const contract = new ethers_1.ethers.Contract(evmAddress, erc20Abi, this.config.TACParams.provider);
+            const tx = await contract.connect(signer).approve(spenderAddress, asset.rawAmount);
+            await tx.wait();
+        }
+        else if (asset.type === Struct_1.AssetType.NFT) {
+            this.logger.debug(`Approving NFT ${evmAddress} for ${spenderAddress}`);
+            const erc721Abi = this.config.artifacts.tac.compilationArtifacts.IERC721.abi;
+            const contract = new ethers_1.ethers.Contract(evmAddress, erc721Abi, this.config.TACParams.provider);
+            const tx = await contract.connect(signer).approve(spenderAddress, asset.addresses.index);
+            await tx.wait();
+        }
+        this.logger.debug(`Approved ${evmAddress} for ${spenderAddress}`);
+    }
+    async bridgeTokensToTON(signer, value, tonTarget, assets = [], tvmExecutorFee, tvmValidExecutors) {
+        this.logger.debug('Bridging tokens to TON');
+        Validator_1.Validator.validateTVMAddress(tonTarget);
+        // Add native TAC asset if value > 0
+        const tonAssets = [...assets];
+        if (value > 0n) {
+            tonAssets.push((await assets_1.AssetFactory.from(this.config, {
+                address: await this.config.nativeTACAddress(),
+                tokenType: Struct_1.AssetType.FT,
+            })).withRawAmount(value));
+        }
+        // Calculate executor fee if not provided
+        if (!tvmExecutorFee) {
+            const feeParams = {
+                tonAssets: (0, Utils_1.mapAssetsToTonAssets)(tonAssets),
+                feeSymbol: Consts_1.TAC_SYMBOL,
+                tvmValidExecutors: tvmValidExecutors ?? [],
+            };
+            const suggestedFee = await this.operationTracker.getTVMExecutorFee(feeParams);
+            this.logger.debug(`Suggested TON executor fee: ${(0, Utils_1.formatObjectForLogging)(suggestedFee)}`);
+            tvmExecutorFee = BigInt(suggestedFee.inTAC);
+        }
+        // Approve all assets
+        const crossChainLayerAddress = await this.config.TACParams.crossChainLayer.getAddress();
+        for (const asset of assets) {
+            await this.approveAsset(asset, signer, crossChainLayerAddress);
+        }
+        const protocolFee = await this.config.TACParams.crossChainLayer.getProtocolFee();
+        const shardsKey = BigInt(Math.round(Math.random() * 1e18));
+        this.logger.debug(`Shards key: ${shardsKey}, Protocol fee: ${protocolFee}`);
+        // Prepare bridge data
+        const [toBridge, toBridgeNFT] = await Promise.all([
+            Promise.all(assets
+                .filter((a) => a.type === Struct_1.AssetType.FT)
+                .map(async (a) => ({
+                evmAddress: await a.getEVMAddress(),
+                amount: a.rawAmount,
+            }))),
+            Promise.all(assets
+                .filter((a) => a.type === Struct_1.AssetType.NFT)
+                .map(async (a) => ({
+                evmAddress: await a.getEVMAddress(),
+                amount: 1n,
+                tokenId: a.addresses.index,
+            }))),
+        ]);
+        const outMessage = {
+            shardsKey,
+            tvmTarget: tonTarget,
+            tvmPayload: '',
+            tvmProtocolFee: protocolFee,
+            tvmExecutorFee,
+            tvmValidExecutors: this.config.getTrustedTONExecutors,
+            toBridge,
+            toBridgeNFT,
+        };
+        const totalValue = value + BigInt(outMessage.tvmProtocolFee) + BigInt(outMessage.tvmExecutorFee);
+        this.logger.debug(`Total value: ${totalValue}`);
+        const tx = await this.config.TACParams.crossChainLayer
+            .connect(signer)
+            .sendMessage(1n, this.config.artifacts.tac.utils.encodeOutMessageV1(outMessage), { value: totalValue });
+        await tx.wait();
+        this.logger.debug(`Transaction hash: ${tx.hash}`);
+        return tx.hash;
+    }
+}
+exports.TACTransactionManager = TACTransactionManager;