@tonappchain/sdk 0.7.0-rc8 → 0.7.0

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

@@ -0,0 +1,12 @@
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+import { IHttpClient } from '../interfaces';
+/**
+ * Axios-based HTTP client that isolates SDK traffic from any global axios configuration.
+ * It uses its own axios instance, so external/global interceptors and defaults won't affect SDK requests.
+ */
+export declare class AxiosHttpClient implements IHttpClient {
+    private readonly instance;
+    constructor(config?: AxiosRequestConfig);
+    get<T>(url: string, config?: AxiosRequestConfig): Promise<AxiosResponse<T>>;
+    post<T>(url: string, data: unknown, config?: AxiosRequestConfig): Promise<AxiosResponse<T>>;
+}

package/dist/src/sdk/AxiosHttpClient.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AxiosHttpClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+/**
+ * Axios-based HTTP client that isolates SDK traffic from any global axios configuration.
+ * It uses its own axios instance, so external/global interceptors and defaults won't affect SDK requests.
+ */
+class AxiosHttpClient {
+    constructor(config) {
+        this.instance = axios_1.default.create(config);
+    }
+    async get(url, config) {
+        return this.instance.get(url, config);
+    }
+    async post(url, data, config) {
+        return this.instance.post(url, data, config);
+    }
+}
+exports.AxiosHttpClient = AxiosHttpClient;

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

@@ -1,17 +1,18 @@
-import { mainnet, testnet } from '@tonappchain/artifacts';
+import { dev, mainnet, testnet } from '../../artifacts';
+import { IConfiguration } from '../interfaces';
 import { InternalTACParams, InternalTONParams } from '../structs/InternalStruct';
-import { IConfiguration } from '../structs/Services';
 import { Network, TACParams, TONParams } from '../structs/Struct';
 export declare class Configuration implements IConfiguration {
     readonly network: Network;
-    readonly artifacts: typeof testnet | typeof mainnet;
+    readonly artifacts: typeof testnet | typeof mainnet | typeof dev;
     readonly TONParams: InternalTONParams;
     readonly TACParams: InternalTACParams;
     readonly liteSequencerEndpoints: string[];
-    constructor(network: Network, artifacts: typeof testnet | typeof mainnet, TONParams: InternalTONParams, TACParams: InternalTACParams, liteSequencerEndpoints: string[]);
-    static create(network: Network, artifacts: typeof testnet | typeof mainnet, TONParams?: TONParams, TACParams?: TACParams, customLiteSequencerEndpoints?: string[], delay?: number): Promise<Configuration>;
+    constructor(network: Network, artifacts: typeof testnet | typeof mainnet | typeof dev, TONParams: InternalTONParams, TACParams: InternalTACParams, liteSequencerEndpoints: string[]);
+    static create(network: Network, artifacts: typeof testnet | typeof mainnet | typeof dev, TONParams?: TONParams, TACParams?: TACParams, customLiteSequencerEndpoints?: string[], delay?: number): Promise<Configuration>;
     private static prepareTONParams;
     private static prepareTACParams;
+    private static loadTACSettingsViaMulticall;
     get nativeTONAddress(): string;
     nativeTACAddress(): Promise<string>;
     get getTrustedTACExecutors(): string[];

package/dist/src/sdk/Configuration.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Configuration = void 0;
+const ton_1 = require("@ton/ton");
+const ethers_1 = require("ethers");
+const artifacts_1 = require("../../artifacts");
+const adapters_1 = require("../adapters");
+const Struct_1 = require("../structs/Struct");
+const Utils_1 = require("./Utils");
+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, internalTACParams] = await Promise.all([
+            this.prepareTONParams(network, TONParams, delay),
+            this.prepareTACParams(network, TACParams),
+        ]);
+        let liteSequencerEndpoints;
+        if (network === Struct_1.Network.DEV) {
+            if (!customLiteSequencerEndpoints || customLiteSequencerEndpoints.length === 0) {
+                throw new Error('For dev network, custom lite sequencer endpoints must be provided');
+            }
+            liteSequencerEndpoints = customLiteSequencerEndpoints;
+        }
+        else {
+            liteSequencerEndpoints = customLiteSequencerEndpoints ?? artifacts.PUBLIC_LITE_SEQUENCER_ENDPOINTS;
+        }
+        return new Configuration(network, artifacts, internalTONParams, internalTACParams, liteSequencerEndpoints);
+    }
+    static async prepareTONParams(network, TONParams, delay) {
+        let contractOpener;
+        let settingsAddress;
+        const artifacts = network === Struct_1.Network.MAINNET ? artifacts_1.mainnet : network === Struct_1.Network.TESTNET ? artifacts_1.testnet : artifacts_1.dev;
+        if (network === Struct_1.Network.DEV) {
+            if (!TONParams || !TONParams.contractOpener) {
+                throw new Error('For dev network, a custom contract opener must be provided in TONParams');
+            }
+            contractOpener = TONParams.contractOpener;
+            if (!TONParams.settingsAddress) {
+                throw new Error('For dev network, a custom settings address must be provided in TONParams');
+            }
+            settingsAddress = TONParams.settingsAddress;
+        }
+        else {
+            contractOpener =
+                TONParams?.contractOpener ??
+                    (await (0, adapters_1.createDefaultRetryableOpener)(artifacts.TON_RPC_ENDPOINT_BY_TAC, network, 5, delay));
+            settingsAddress = TONParams?.settingsAddress ?? artifacts.TON_SETTINGS_ADDRESS;
+        }
+        const settings = contractOpener.open(artifacts.ton.wrappers.Settings.createFromAddress(ton_1.Address.parse(settingsAddress)));
+        const allSettingsSlice = (await settings.getAll()).beginParse();
+        const allSettings = allSettingsSlice.loadDictDirect(ton_1.Dictionary.Keys.BigUint(256), ton_1.Dictionary.Values.Cell());
+        const crossChainLayerAddress = (0, Utils_1.getAddressString)(allSettings.get((0, Utils_1.sha256toBigInt)('CrossChainLayerAddress')));
+        const jettonProxyAddress = (0, Utils_1.getAddressString)(allSettings.get((0, Utils_1.sha256toBigInt)('JettonProxyAddress')));
+        const nftProxyAddress = (0, Utils_1.getAddressString)(allSettings.get((0, Utils_1.sha256toBigInt)('NFTProxyAddress')));
+        const jettonWalletCode = allSettings.get((0, Utils_1.sha256toBigInt)('JettonWalletCode'));
+        const jettonMinterCode = allSettings.get((0, Utils_1.sha256toBigInt)('JettonMinterCode'));
+        const nftItemCode = allSettings.get((0, Utils_1.sha256toBigInt)('NFTItemCode'));
+        const nftCollectionCode = allSettings.get((0, Utils_1.sha256toBigInt)('NFTCollectionCode'));
+        return {
+            contractOpener,
+            jettonProxyAddress,
+            crossChainLayerAddress,
+            jettonMinterCode,
+            jettonWalletCode,
+            nftProxyAddress,
+            nftItemCode,
+            nftCollectionCode,
+        };
+    }
+    static async prepareTACParams(network, TACParams) {
+        const artifacts = network === Struct_1.Network.MAINNET ? artifacts_1.mainnet : network === Struct_1.Network.TESTNET ? artifacts_1.testnet : artifacts_1.dev;
+        let provider;
+        let settingsAddress;
+        let saFactoryAddress;
+        if (network === Struct_1.Network.DEV) {
+            if (!TACParams || !TACParams.provider) {
+                throw new Error('For dev network, a custom provider must be provided in TACParams');
+            }
+            provider = TACParams.provider;
+            if (!TACParams.settingsAddress) {
+                throw new Error('For dev network, a custom settings address must be provided in TACParams');
+            }
+            settingsAddress = TACParams.settingsAddress;
+            if (!TACParams.saFactoryAddress) {
+                throw new Error('For dev network, a custom smart account factory address must be provided in TACParams');
+            }
+            saFactoryAddress = TACParams.saFactoryAddress;
+        }
+        else {
+            provider = TACParams?.provider ?? ethers_1.ethers.getDefaultProvider(artifacts.TAC_RPC_ENDPOINT);
+            settingsAddress = TACParams?.settingsAddress ?? artifacts.TAC_SETTINGS_ADDRESS;
+            saFactoryAddress = TACParams?.saFactoryAddress ?? artifacts.TAC_SMART_ACCOUNT_FACTORY_ADDRESS;
+        }
+        Validator_1.Validator.validateEVMAddress(settingsAddress);
+        const settingsAbi = artifacts.tac.compilationArtifacts.ISettings.abi;
+        const settings = new ethers_1.ethers.Contract(settingsAddress, settingsAbi, provider);
+        const loaded = await this.loadTACSettingsViaMulticall(network, provider, settingsAddress);
+        let crossChainLayerAddress;
+        let tokenUtilsAddress;
+        let trustedTACExecutors;
+        let trustedTONExecutors;
+        if (loaded) {
+            crossChainLayerAddress = loaded.crossChainLayerAddress;
+            tokenUtilsAddress = loaded.tokenUtilsAddress;
+            trustedTACExecutors = loaded.trustedTACExecutors;
+            trustedTONExecutors = loaded.trustedTONExecutors;
+        }
+        else {
+            crossChainLayerAddress = await settings.getAddressSetting((0, ethers_1.keccak256)((0, ethers_1.toUtf8Bytes)('CrossChainLayerAddress')));
+            tokenUtilsAddress = await settings.getAddressSetting((0, ethers_1.keccak256)((0, ethers_1.toUtf8Bytes)('TokenUtilsAddress')));
+            trustedTACExecutors = await settings.getTrustedEVMExecutors();
+            trustedTONExecutors = await settings.getTrustedTVMExecutors();
+        }
+        const crossChainLayerAbi = artifacts.tac.compilationArtifacts.ICrossChainLayer.abi;
+        const crossChainLayer = new ethers_1.ethers.Contract(crossChainLayerAddress, crossChainLayerAbi, provider);
+        const tokenUtilsAbi = artifacts.tac.compilationArtifacts.ITokenUtils.abi;
+        const tokenUtils = new ethers_1.ethers.Contract(tokenUtilsAddress, tokenUtilsAbi, provider);
+        const TacSAFactoryAbi = artifacts.tac.compilationArtifacts.ISAFactory.abi;
+        const smartAccountFactory = new ethers_1.ethers.Contract(saFactoryAddress, TacSAFactoryAbi, provider);
+        return {
+            provider,
+            settings,
+            tokenUtils,
+            smartAccountFactory,
+            crossChainLayer,
+            trustedTACExecutors,
+            trustedTONExecutors,
+            abiCoder: new ethers_1.ethers.AbiCoder(),
+        };
+    }
+    static async loadTACSettingsViaMulticall(network, provider, settingsAddress) {
+        if (network === Struct_1.Network.DEV) {
+            // skip multicall in dev, because it's not guaranteed that multicall contract is deployed
+            return null;
+        }
+        const artifacts = network === Struct_1.Network.MAINNET ? artifacts_1.mainnet : artifacts_1.testnet;
+        const multicallAddress = artifacts.MULTICALL_3_ADDRESS;
+        const multicallAbi = artifacts.tac.multicall.MULTICALL_ABI_ETHERS;
+        try {
+            Validator_1.Validator.validateEVMAddress(multicallAddress);
+            const multicall = new ethers_1.ethers.Contract(multicallAddress, multicallAbi, provider);
+            const abiCoder = new ethers_1.ethers.AbiCoder();
+            const selectorGetAddressSetting = ethers_1.ethers.id('getAddressSetting(bytes32)').slice(0, 10);
+            const selectorGetTrustedEVMExecutors = ethers_1.ethers.id('getTrustedEVMExecutors()').slice(0, 10);
+            const selectorGetTrustedTVMExecutors = ethers_1.ethers.id('getTrustedTVMExecutors()').slice(0, 10);
+            const crossChainLayerKey = (0, ethers_1.keccak256)((0, ethers_1.toUtf8Bytes)('CrossChainLayerAddress'));
+            const tokenUtilsKey = (0, ethers_1.keccak256)((0, ethers_1.toUtf8Bytes)('TokenUtilsAddress'));
+            const encodeGetAddressSetting = (key) => selectorGetAddressSetting + abiCoder.encode(['bytes32'], [key]).slice(2);
+            const calls = [
+                { target: settingsAddress, allowFailure: false, callData: encodeGetAddressSetting(crossChainLayerKey) },
+                { target: settingsAddress, allowFailure: false, callData: encodeGetAddressSetting(tokenUtilsKey) },
+                { target: settingsAddress, allowFailure: false, callData: selectorGetTrustedEVMExecutors },
+                { target: settingsAddress, allowFailure: false, callData: selectorGetTrustedTVMExecutors },
+            ];
+            const results = (await multicall.aggregate3.staticCall(calls));
+            if (results.some((result) => !result.success))
+                return null;
+            return {
+                crossChainLayerAddress: abiCoder.decode(['address'], results[0].returnData)[0],
+                tokenUtilsAddress: abiCoder.decode(['address'], results[1].returnData)[0],
+                trustedTACExecutors: abiCoder.decode(['address[]'], results[2].returnData)[0],
+                trustedTONExecutors: abiCoder.decode(['string[]'], results[3].returnData)[0],
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    get nativeTONAddress() {
+        return 'NONE';
+    }
+    async nativeTACAddress() {
+        return this.TACParams.crossChainLayer.NATIVE_TOKEN_ADDRESS.staticCall();
+    }
+    get getTrustedTACExecutors() {
+        return this.TACParams.trustedTACExecutors;
+    }
+    get getTrustedTONExecutors() {
+        return this.TACParams.trustedTONExecutors;
+    }
+    closeConnections() {
+        return this.TONParams.contractOpener.closeConnections?.();
+    }
+    async isContractDeployedOnTVM(address) {
+        return (await this.TONParams.contractOpener.getContractState(ton_1.Address.parse(address))).state === 'active';
+    }
+}
+exports.Configuration = Configuration;

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

@@ -10,3 +10,6 @@ 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/{sdk → src/sdk}/Consts.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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_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;
 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,3 +14,6 @@ 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/src/sdk/LiteSequencerClient.d.ts

@@ -0,0 +1,18 @@
+import { IHttpClient, ILiteSequencerClient } from '../interfaces';
+import { ConvertCurrencyParams, ConvertedCurrencyResult, ExecutionStagesByOperationId, GetTVMExecutorFeeParams, OperationIdsByShardsKey, OperationType, StatusInfosByOperationId, SuggestedTVMExecutorFee, TACSimulationParams, TACSimulationResult, TransactionLinker } from '../structs/Struct';
+export declare class LiteSequencerClient implements ILiteSequencerClient {
+    private readonly endpoint;
+    private readonly maxChunkSize;
+    private readonly httpClient;
+    constructor(endpoint: string, maxChunkSize?: number, httpClient?: IHttpClient);
+    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>;
+    convertCurrency(params: ConvertCurrencyParams): Promise<ConvertedCurrencyResult>;
+    simulateTACMessage(params: TACSimulationParams): Promise<TACSimulationResult>;
+    getTVMExecutorFee(params: GetTVMExecutorFeeParams): Promise<SuggestedTVMExecutorFee>;
+    private processChunkedRequest;
+}

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