@tonappchain/sdk 0.7.0-rc14 → 0.7.0-rc15

package/dist/interfaces/IOperationTracker.d.ts

@@ -1,4 +1,4 @@
-import { ConvertCurrencyParams, ConvertedCurrencyResult, ExecutionStages, ExecutionStagesByOperationId, OperationIdsByShardsKey, OperationType, SimplifiedStatuses, StatusInfo, StatusInfosByOperationId, TransactionLinker, WaitOptions } from '../structs/Struct';
+import { ConvertCurrencyParams, ConvertedCurrencyResult, ExecutionStages, ExecutionStagesByOperationId, GetTVMExecutorFeeParams, OperationIdsByShardsKey, OperationType, SimplifiedStatuses, StatusInfo, StatusInfosByOperationId, SuggestedTVMExecutorFee, TACSimulationParams, TACSimulationResult, TransactionLinker, WaitOptions } from '../structs/Struct';
 export interface IOperationTracker {
     /**
      * Returns the operation type for the given id, optionally waiting according to the provided policy.
@@ -63,4 +63,19 @@ export interface IOperationTracker {
      * @param waitOptions Optional waiting settings.
      */
     convertCurrency(params: ConvertCurrencyParams, waitOptions?: WaitOptions<ConvertedCurrencyResult>): Promise<ConvertedCurrencyResult>;
+    /**
+     * Simulates execution of a TAC message without broadcasting it, optionally waiting until the result is available.
+     * Useful to validate inputs and estimate effects before sending a real transaction.
+     * @param params Simulation parameters and context.
+     * @param waitOptions Optional waiting settings (polling/timeout policy).
+     * @returns Promise with detailed simulation result.
+     */
+    simulateTACMessage(params: TACSimulationParams, waitOptions?: WaitOptions<TACSimulationResult>): Promise<TACSimulationResult>;
+    /**
+     * Suggests/calculates a TVM executor fee for the provided parameters, optionally waiting for completion.
+     * @param params Parameters affecting fee calculation.
+     * @param waitOptions Optional waiting settings (polling/timeout policy).
+     * @returns Promise with suggested fee information.
+     */
+    getTVMExecutorFee(params: GetTVMExecutorFeeParams, waitOptions?: WaitOptions<SuggestedTVMExecutorFee>): Promise<SuggestedTVMExecutorFee>;
 }

package/dist/interfaces/ISimulator.d.ts

@@ -1,47 +1,18 @@
 import type { SenderAbstraction } from '../sender';
-import { CrosschainTx, EvmProxyMsg, ExecutionFeeEstimationResult, SuggestedTONExecutorFee, TACSimulationRequest, TACSimulationResult, TransactionLinker } from '../structs/Struct';
-import { Asset } from './Asset';
+import { CrosschainTx, ExecutionFeeEstimationResult } from '../structs/Struct';
 export interface ISimulator {
-    /**
-     * Simulates a TAC message execution without sending it to the chain.
-     * @param req Simulation request that encapsulates the message and context.
-     * @returns Promise with detailed simulation output.
-     */
-    simulateTACMessage(req: TACSimulationRequest): Promise<TACSimulationResult>;
     /**
      * Simulates a list of cross-chain transactions for a given sender.
      * @param sender Sender abstraction used to provide context (e.g., wallet state).
      * @param txs Cross-chain transactions to simulate.
-     * @returns Promise with results, one for each input transaction.
-     */
-    simulateTransactions(sender: SenderAbstraction, txs: CrosschainTx[]): Promise<TACSimulationResult[]>;
-    /**
-     * Suggests the TON executor fee for a given set of assets and target fee symbol.
-     * @param assets Assets involved in execution.
-     * @param feeSymbol Symbol that represents the fee denomination (e.g., TON).
-     * @param tvmValidExecutors Whitelist of permitted TVM executors (optional).
-     * @returns Promise with suggested fee information.
+     * @returns Promise with fee estimation results, one for each input transaction.
      */
-    getTVMExecutorFeeInfo(assets: Asset[], feeSymbol: string, tvmValidExecutors?: string[]): Promise<SuggestedTONExecutorFee>;
+    getSimulationsInfo(sender: SenderAbstraction, txs: CrosschainTx[]): Promise<ExecutionFeeEstimationResult[]>;
     /**
-     * Computes simulation info and fees for a single transaction, using the provided sender context.
-     * @param evmProxyMsg Encoded EVM proxy message.
-     * @param sender Sender abstraction.
-     * @param assets Optional list of assets to attach to the transaction.
-     * @returns Promise with execution fee estimation details.
-     */
-    getTransactionSimulationInfo(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: Asset[]): Promise<ExecutionFeeEstimationResult>;
-    /**
-     * Computes simulation info for a transaction tied to an existing TransactionLinker.
-     * @param evmProxyMsg Encoded EVM proxy message.
-     * @param transactionLinker Linker referencing the originating transaction.
-     * @param assets Assets to be included in the transaction.
-     * @param allowSimulationError If true, returns partial info even if simulation fails.
-     * @param isRoundTrip If true, includes round-trip (rollback) considerations.
-     * @param evmValidExecutors Optional whitelist of EVM-side executors.
-     * @param tvmValidExecutors Optional whitelist of TVM-side executors.
-     * @param calculateRollbackFee If true, includes rollback fee in estimation.
+     * Get tvm fees and simulation info for a tvm transaction using sender abstraction.
+     * @param sender Sender abstraction used to provide context (e.g., wallet state).
+     * @param tx Cross-chain transaction to simulate.
      * @returns Promise with fee estimation and execution info.
      */
-    getSimulationInfoForTransaction(evmProxyMsg: EvmProxyMsg, transactionLinker: TransactionLinker, assets: Asset[], allowSimulationError?: boolean, isRoundTrip?: boolean, evmValidExecutors?: string[], tvmValidExecutors?: string[], calculateRollbackFee?: boolean): Promise<ExecutionFeeEstimationResult>;
+    getSimulationInfo(sender: SenderAbstraction, tx: CrosschainTx): Promise<ExecutionFeeEstimationResult>;
 }

package/dist/interfaces/ITACTransactionManager.d.ts

@@ -0,0 +1,15 @@
+import { Wallet } from 'ethers';
+import { Asset } from './Asset';
+export interface ITACTransactionManager {
+    /**
+     * Bridges native EVM value and optional assets to TON chain via executor.
+     * @param signer Ethers Wallet used to sign EVM transaction.
+     * @param value Amount of native EVM currency (wei as bigint).
+     * @param tonTarget Recipient TVM address on TON.
+     * @param assets Optional list of TAC assets to include.
+     * @param tvmExecutorFee Optional explicit TON-side executor fee.
+     * @param tvmValidExecutors Optional whitelist of allowed TVM executors.
+     * @returns EVM transaction hash or bridge identifier.
+     */
+    bridgeTokensToTON(signer: Wallet, value: bigint, tonTarget: string, assets?: Asset[], tvmExecutorFee?: bigint, tvmValidExecutors?: string[]): Promise<string>;
+}

package/dist/interfaces/ITONTransactionManager.d.ts

@@ -0,0 +1,21 @@
+import type { SenderAbstraction } from '../sender';
+import { CrosschainTx, EvmProxyMsg, OperationIdsByShardsKey, TransactionLinkerWithOperationId, WaitOptions } from '../structs/Struct';
+export interface ITONTransactionManager {
+    /**
+     * Sends a single cross-chain transaction.
+     * @param evmProxyMsg Encoded EVM proxy message to bridge.
+     * @param sender Sender abstraction for TVM message sending.
+     * @param tx cross-chain transaction to bridge.
+     * @param waitOptions Optional policy to wait for operation id resolution.
+     * @returns Transaction linker with operation id for tracking.
+     */
+    sendCrossChainTransaction(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, tx: CrosschainTx, waitOptions?: WaitOptions<string>): Promise<TransactionLinkerWithOperationId>;
+    /**
+     * Sends multiple cross-chain transactions in a batch.
+     * @param sender Sender abstraction for TVM message sending.
+     * @param txs List of cross-chain transactions to bridge.
+     * @param waitOptions Optional policy for waiting on operation ids by shard keys.
+     * @returns Array of transaction linkers, one per submitted transaction.
+     */
+    sendCrossChainTransactions(sender: SenderAbstraction, txs: CrosschainTx[], waitOptions?: WaitOptions<OperationIdsByShardsKey>): Promise<TransactionLinkerWithOperationId[]>;
+}

package/dist/interfaces/ITONTransactionManager.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/ITacSDK.d.ts

@@ -1,10 +1,11 @@
 import { Wallet } from 'ethers';
 import { FT, NFT } from '../assets';
 import type { SenderAbstraction } from '../sender';
-import { AssetFromFTArg, AssetFromNFTCollectionArg, AssetFromNFTItemArg, CrossChainTransactionOptions, CrosschainTx, EVMAddress, EvmProxyMsg, ExecutionFeeEstimationResult, NFTAddressType, NFTItemData, OperationIdsByShardsKey, SuggestedTONExecutorFee, TACSimulationRequest, TACSimulationResult, TransactionLinkerWithOperationId, TVMAddress, UserWalletBalanceExtended, WaitOptions } from '../structs/Struct';
+import { AssetFromFTArg, AssetFromNFTCollectionArg, AssetFromNFTItemArg, AssetLike, CrossChainTransactionOptions, CrosschainTx, CrosschainTxWithAssetLike, EVMAddress, EvmProxyMsg, ExecutionFeeEstimationResult, NFTAddressType, NFTItemData, OperationIdsByShardsKey, SuggestedTVMExecutorFee, TACSimulationParams, TACSimulationResult, TransactionLinkerWithOperationId, TVMAddress, UserWalletBalanceExtended, WaitOptions } from '../structs/Struct';
 import { JettonMasterData } from '../wrappers/JettonMaster';
 import { Asset } from './Asset';
 import { IConfiguration } from './IConfiguration';
+import { IOperationTracker } from './IOperationTracker';
 export interface ITacSDK {
     readonly config: IConfiguration;
     /**
@@ -58,22 +59,23 @@ export interface ITacSDK {
      * @param req Simulation request with encoded message and context.
      * @returns Promise with the detailed simulation result.
      */
-    simulateTACMessage(req: TACSimulationRequest): Promise<TACSimulationResult>;
+    simulateTACMessage(req: TACSimulationParams): Promise<TACSimulationResult>;
     /**
      * Simulates a batch of cross-chain transactions from a given sender.
      * @param sender Abstracted sender used for simulation context (not broadcasting).
      * @param txs Array of cross-chain transactions to simulate.
-     * @returns Promise with an array of results matching the input order.
+     * @returns Promise with an array of fee estimation results matching the input order.
      */
-    simulateTransactions(sender: SenderAbstraction, txs: CrosschainTx[]): Promise<TACSimulationResult[]>;
+    simulateTransactions(sender: SenderAbstraction, txs: CrosschainTx[]): Promise<ExecutionFeeEstimationResult[]>;
     /**
-     * Computes fee and execution information for a prospective transaction.
+     * Get tvm fees and simulation info for a tvm transaction using sender abstraction.
      * @param evmProxyMsg Encoded EVM proxy message.
-     * @param sender Sender abstraction providing context (e.g., seqno, wallet info).
-     * @param assets Optional list of assets attached to the transaction.
-     * @returns Promise with the fee estimation and execution breakdown.
+     * @param sender Sender abstraction used to provide context (e.g., wallet state).
+     * @param assets Assets to be included in the transaction.
+     * @param options Optional transaction configuration including error handling and executor settings.
+     * @returns Promise with fee estimation and execution info.
      */
-    getTransactionSimulationInfo(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: Asset[]): Promise<ExecutionFeeEstimationResult>;
+    getSimulationInfo(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: AssetLike[], options?: CrossChainTransactionOptions): Promise<ExecutionFeeEstimationResult>;
     /**
      * Suggests optimal TON-side executor fee for a given asset set and fee symbol.
      * @param assets Assets to be processed on TON side.
@@ -81,7 +83,7 @@ export interface ITacSDK {
      * @param tvmValidExecutors Optional whitelist of allowed TVM executors.
      * @returns Promise with suggested fee details.
      */
-    getTVMExecutorFeeInfo(assets: Asset[], feeSymbol: string, tvmValidExecutors?: string[]): Promise<SuggestedTONExecutorFee>;
+    getTVMExecutorFeeInfo(assets: AssetLike[], feeSymbol: string, tvmValidExecutors?: string[]): Promise<SuggestedTVMExecutorFee>;
     /**
      * Sends a single cross-chain transaction and optionally waits for tracking information.
      * @param evmProxyMsg Encoded EVM proxy message to be bridged.
@@ -91,7 +93,7 @@ export interface ITacSDK {
      * @param waitOptions Optional waiting policy for operation id resolution.
      * @returns Promise with a TransactionLinkerWithOperationId to track the operation across chains.
      */
-    sendCrossChainTransaction(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: Asset[], options?: CrossChainTransactionOptions, waitOptions?: WaitOptions<string>): Promise<TransactionLinkerWithOperationId>;
+    sendCrossChainTransaction(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: AssetLike[], options?: CrossChainTransactionOptions, waitOptions?: WaitOptions<string>): Promise<TransactionLinkerWithOperationId>;
     /**
      * Sends multiple cross-chain transactions in one batch and optionally waits for tracking info.
      * @param sender Sender abstraction for signing/sending TVM messages.
@@ -99,7 +101,7 @@ export interface ITacSDK {
      * @param waitOptions Optional waiting policy for operation ids by shard keys.
      * @returns Promise with an array of TransactionLinkerWithOperationId for each submitted transaction.
      */
-    sendCrossChainTransactions(sender: SenderAbstraction, txs: CrosschainTx[], waitOptions?: WaitOptions<OperationIdsByShardsKey>): Promise<TransactionLinkerWithOperationId[]>;
+    sendCrossChainTransactions(sender: SenderAbstraction, txs: CrosschainTxWithAssetLike[], waitOptions?: WaitOptions<OperationIdsByShardsKey>): Promise<TransactionLinkerWithOperationId[]>;
     /**
      * Bridges tokens/value from EVM to TON chain via the executor.
      * @param signer Ethers Wallet used to sign the EVM-side transaction.
@@ -110,7 +112,7 @@ export interface ITacSDK {
      * @param tvmValidExecutors Optional whitelist of allowed TVM executors.
      * @returns Promise resolving to the EVM transaction hash or bridge identifier.
      */
-    bridgeTokensToTON(signer: Wallet, value: bigint, tonTarget: string, assets?: Asset[], tvmExecutorFee?: bigint, tvmValidExecutors?: string[]): Promise<string>;
+    bridgeTokensToTON(signer: Wallet, value: bigint, tonTarget: string, assets?: AssetLike[], tvmExecutorFee?: bigint, tvmValidExecutors?: string[]): Promise<string>;
     /**
      * Returns the user's Jetton wallet address for a given Jetton master (token) address.
      * @param userAddress TVM user address.
@@ -138,10 +140,46 @@ export interface ITacSDK {
      * @returns Promise resolving to JettonMasterData.
      */
     getJettonData(itemAddress: TVMAddress): Promise<JettonMasterData>;
+    /**
+     * Returns NFT item data for the specified TVM address.
+     * @param itemAddress TVM address of the NFT item.
+     * @returns Promise resolving to the NFT item data.
+     */
     getNFTItemData(itemAddress: TVMAddress): Promise<NFTItemData>;
+    /**
+     * Resolves the EVM token address that corresponds to the provided TVM token address.
+     * @param tvmTokenAddress TVM token (Jetton) master address.
+     * @returns Promise resolving to the EVM token address.
+     */
     getEVMTokenAddress(tvmTokenAddress: string): Promise<string>;
+    /**
+     * Resolves the TVM token address that corresponds to the provided EVM token address.
+     * @param evmTokenAddress EVM token contract address (checksum string).
+     * @returns Promise resolving to the TVM token (Jetton) master address.
+     */
     getTVMTokenAddress(evmTokenAddress: string): Promise<string>;
+    /**
+     * Resolves the TVM NFT address for a given EVM NFT contract and optional token id.
+     * @param evmNFTAddress EVM NFT contract address.
+     * @param tokenId Optional NFT token id; when omitted, returns the collection address if applicable.
+     * @returns Promise resolving to the TVM NFT address.
+     */
     getTVMNFTAddress(evmNFTAddress: string, tokenId?: number | bigint): Promise<string>;
+    /**
+     * Resolves the EVM NFT address for a given TVM NFT address and desired address type.
+     * @param tvmNFTAddress TVM NFT item or collection address.
+     * @param addressType Desired address type on EVM side (collection or item).
+     * @returns Promise resolving to the EVM NFT address.
+     */
     getEVMNFTAddress(tvmNFTAddress: string, addressType: NFTAddressType): Promise<string>;
+    /**
+     * Checks whether a contract is deployed at the provided TVM address on the current network.
+     * @param address TVM address to check.
+     * @returns Promise resolving to true if deployed, false otherwise.
+     */
     isContractDeployedOnTVM(address: string): Promise<boolean>;
+    /**
+     * Returns the operation tracker instance used for querying operation statuses and utilities.
+     */
+    getOperationTracker(): IOperationTracker;
 }

package/dist/interfaces/index.d.ts

@@ -8,6 +8,7 @@ export * from './ILogger';
 export * from './IOperationTracker';
 export * from './ISimulator';
 export * from './ITacSDK';
-export * from './ITransactionManager';
+export * from './ITACTransactionManager';
+export * from './ITONTransactionManager';
 export * from './SenderAbstraction';
 export * from './WalletInstanse';

package/dist/interfaces/index.js

@@ -24,6 +24,7 @@ __exportStar(require("./ILogger"), exports);
 __exportStar(require("./IOperationTracker"), exports);
 __exportStar(require("./ISimulator"), exports);
 __exportStar(require("./ITacSDK"), exports);
-__exportStar(require("./ITransactionManager"), exports);
+__exportStar(require("./ITACTransactionManager"), exports);
+__exportStar(require("./ITONTransactionManager"), exports);
 __exportStar(require("./SenderAbstraction"), exports);
 __exportStar(require("./WalletInstanse"), exports);

package/dist/sdk/Configuration.d.ts

@@ -12,6 +12,7 @@ export declare class Configuration implements IConfiguration {
     static create(network: Network, artifacts: typeof testnet | typeof mainnet, TONParams?: TONParams, TACParams?: TACParams, customLiteSequencerEndpoints?: string[], delay?: number): Promise<Configuration>;
     private static prepareTONParams;
     private static prepareTACParams;
+    private static loadSettingsViaMulticall;
     get nativeTONAddress(): string;
     nativeTACAddress(): Promise<string>;
     get getTrustedTACExecutors(): string[];

package/dist/sdk/Configuration.js

@@ -57,22 +57,70 @@ class Configuration {
         const settingsAddress = TACParams?.settingsAddress?.toString() ?? artifacts.TAC_SETTINGS_ADDRESS;
         Validator_1.Validator.validateEVMAddress(settingsAddress);
         const settings = artifacts.tac.wrappers.SettingsFactoryTAC.connect(settingsAddress, provider);
-        const crossChainLayerAddress = await settings.getAddressSetting((0, ethers_1.keccak256)((0, ethers_1.toUtf8Bytes)('CrossChainLayerAddress')));
+        const loaded = await this.loadSettingsViaMulticall(artifacts, provider, settingsAddress, TACParams);
+        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 crossChainLayer = artifacts.tac.wrappers.CrossChainLayerFactoryTAC.connect(crossChainLayerAddress, provider);
-        const tokenUtilsAddress = await settings.getAddressSetting((0, ethers_1.keccak256)((0, ethers_1.toUtf8Bytes)('TokenUtilsAddress')));
         const tokenUtils = artifacts.tac.wrappers.TokenUtilsFactoryTAC.connect(tokenUtilsAddress, provider);
-        const trustedTACExecutors = await settings.getTrustedEVMExecutors();
-        const trustedTONExecutors = await settings.getTrustedTVMExecutors();
+        const smartAccountFactory = artifacts.tac.wrappers.TacSAFactory_factoryTAC.connect(artifacts.TAC_SMART_ACCOUNT_FACTORY_ADDRESS, provider);
         return {
             provider,
             settings,
             tokenUtils,
+            smartAccountFactory,
             crossChainLayer,
             trustedTACExecutors,
             trustedTONExecutors,
             abiCoder: new ethers_1.ethers.AbiCoder(),
         };
     }
+    static async loadSettingsViaMulticall(artifacts, provider, settingsAddress, TACParams) {
+        const multicallAddress = TACParams?.multicallAddress?.toString() ?? artifacts.MULTICALL_3_ADDRESS;
+        const multicallAbi = TACParams?.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';
     }

package/dist/sdk/Consts.d.ts

@@ -10,3 +10,4 @@ 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;

package/dist/sdk/Consts.js

@@ -1,10 +1,10 @@
 "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.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);
-exports.NFT_TRANSFER_FORWARD_TON_AMOUNT = (0, ton_1.toNano)(0.3);
+exports.TRANSACTION_TON_AMOUNT = (0, ton_1.toNano)(0.01);
+exports.JETTON_TRANSFER_FORWARD_TON_AMOUNT = (0, ton_1.toNano)(0.06);
+exports.NFT_TRANSFER_FORWARD_TON_AMOUNT = (0, ton_1.toNano)(0.06);
 exports.MAX_ITERATION_COUNT = 120;
 exports.DEFAULT_DELAY = 0;
 exports.SOLIDITY_SIGNATURE_REGEX = /^[a-zA-Z_][a-zA-Z0-9_]*(\((bytes,bytes)\))?$/;
@@ -14,3 +14,4 @@ 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;

package/dist/sdk/LiteSequencerClient.d.ts

@@ -1,6 +1,6 @@
-import { IHttpClient } from '../interfaces';
-import { ConvertCurrencyParams, ConvertedCurrencyResult, ExecutionStagesByOperationId, OperationIdsByShardsKey, OperationType, StatusInfosByOperationId, TransactionLinker } from '../structs/Struct';
-export declare class LiteSequencerClient {
+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;
@@ -12,5 +12,7 @@ export declare class LiteSequencerClient {
     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/LiteSequencerClient.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LiteSequencerClient = void 0;
 const errors_1 = require("../errors");
+const instances_1 = require("../errors/instances");
 const AxiosHttpClient_1 = require("./AxiosHttpClient");
 const Utils_1 = require("./Utils");
 class LiteSequencerClient {
@@ -141,13 +142,35 @@ class LiteSequencerClient {
             };
         }
         catch (error) {
-            throw (0, errors_1.operationFetchError)(`endpoint ${this.endpoint} failed to complete request`, 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(identificators, requestFn, chunkSize = this.maxChunkSize) {
+    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/OperationTracker.d.ts

@@ -1,5 +1,5 @@
 import { ILiteSequencerClient, ILiteSequencerClientFactory, ILogger, IOperationTracker } from '../interfaces';
-import { ConvertCurrencyParams, ConvertedCurrencyResult, ExecutionStages, ExecutionStagesByOperationId, Network, OperationIdsByShardsKey, OperationType, SimplifiedStatuses, StatusInfo, StatusInfosByOperationId, TransactionLinker, WaitOptions } from '../structs/Struct';
+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[];
 }
@@ -17,4 +17,6 @@ export declare class OperationTracker implements IOperationTracker {
     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/OperationTracker.js

@@ -7,6 +7,7 @@ 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));
@@ -40,7 +41,7 @@ class OperationTracker {
             this.logger.error('All endpoints failed to get operation id by transactionHash');
             throw (0, errors_1.allEndpointsFailedError)(lastError);
         };
-        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : 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 +61,7 @@ class OperationTracker {
             this.logger.error('All endpoints failed to get operation type');
             throw (0, errors_1.allEndpointsFailedError)(lastError);
         };
-        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : 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 +81,7 @@ class OperationTracker {
             this.logger.error('All endpoints failed to get operation id');
             throw (0, errors_1.allEndpointsFailedError)(lastError);
         };
-        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : 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 +102,7 @@ class OperationTracker {
             this.logger.error('All endpoints failed to get operation ids by shards keys');
             throw (0, errors_1.allEndpointsFailedError)(lastError);
         };
-        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : 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 +127,7 @@ class OperationTracker {
             this.logger.error('All endpoints failed to get stage profiling');
             throw (0, errors_1.allEndpointsFailedError)(lastError);
         };
-        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : 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 +148,7 @@ class OperationTracker {
             this.logger.error('All endpoints failed to get stage profilings');
             throw (0, errors_1.allEndpointsFailedError)(lastError);
         };
-        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : 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 +169,7 @@ class OperationTracker {
             this.logger.error('All endpoints failed to get operation statuses');
             throw (0, errors_1.allEndpointsFailedError)(lastError);
         };
-        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : 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 +194,7 @@ class OperationTracker {
             this.logger.error('All endpoints failed to get operation status');
             throw (0, errors_1.allEndpointsFailedError)(lastError);
         };
-        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : 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 +203,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;
         }
@@ -231,7 +230,48 @@ class OperationTracker {
             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();
+        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;