@tonappchain/sdk 0.7.0-rc13 → 0.7.0-rc15

package/dist/interfaces/Asset.d.ts

@@ -6,28 +6,33 @@ export interface Asset {
     rawAmount: bigint;
     clone: Asset;
     /**
-     * Returns a new asset instance with the specified transfer amount.
-     * Use { rawAmount } for base units (e.g., nano units), or { amount } for human-readable units if supported by the implementation.
+     * Returns a new asset instance with the specified transfer amount in human-readable units.
      * Does not mutate the current asset instance.
-     * @param amount Object specifying either rawAmount (bigint base units) or amount (number in human units).
-     * @returns Promise that resolves to a new Asset reflecting the requested amount.
+     * @param amount Amount in human units (e.g., 1.5 TON). Decimals are resolved during asset creation.
+     * @returns A new Asset reflecting the requested amount.
      */
-    withAmount(amount: {
-        rawAmount: bigint;
-    } | {
-        amount: number;
-    }): Promise<Asset>;
+    withAmount(amount: number): Asset;
     /**
-     * Increases the transfer amount by the specified value and returns a new asset instance.
+     * Returns a new asset instance with the specified transfer amount in raw base units.
      * Does not mutate the current asset instance.
-     * @param amount Object specifying either rawAmount (bigint base units) or amount (number in human units).
-     * @returns Promise that resolves to a new Asset with the increased amount.
+     * @param rawAmount Amount in raw base units (bigint).
+     * @returns A new Asset reflecting the requested raw amount.
      */
-    addAmount(amount: {
-        rawAmount: bigint;
-    } | {
-        amount: number;
-    }): Promise<Asset>;
+    withRawAmount(rawAmount: bigint): Asset;
+    /**
+     * Increases the transfer amount by the specified value (human-readable units) and returns a new asset instance.
+     * Does not mutate the current asset instance.
+     * @param amount Amount in human units (e.g., 1.5 TON). Decimals are resolved during asset creation.
+     * @returns A new Asset with the increased amount.
+     */
+    addAmount(amount: number): Asset;
+    /**
+     * Increases the transfer amount by the specified raw base units and returns a new asset instance.
+     * Does not mutate the current asset instance.
+     * @param rawAmount Amount in raw base units (bigint).
+     * @returns A new Asset with the increased amount in raw units.
+     */
+    addRawAmount(rawAmount: bigint): Asset;
     /**
      * Resolves the corresponding EVM token address for this asset.
      * Useful when bridging or interacting with EVM-compatible networks.

package/dist/interfaces/ILiteSequencerClient.d.ts

@@ -1,4 +1,4 @@
-import { ConvertCurrencyParams, ConvertedCurrencyResult, ExecutionStagesByOperationId, OperationIdsByShardsKey, OperationType, StatusInfosByOperationId, TransactionLinker } from '../structs/Struct';
+import { ConvertCurrencyParams, ConvertedCurrencyResult, ExecutionStagesByOperationId, GetTVMExecutorFeeParams, OperationIdsByShardsKey, OperationType, StatusInfosByOperationId, SuggestedTVMExecutorFee, TACSimulationParams, TACSimulationResult, TransactionLinker } from '../structs/Struct';
 export interface ILiteSequencerClient {
     /** Retrieves the operation type by id. */
     getOperationType(operationId: string): Promise<OperationType>;
@@ -27,4 +27,17 @@ export interface ILiteSequencerClient {
     getOperationStatuses(operationIds: string[], chunkSize?: number): Promise<StatusInfosByOperationId>;
     /** Converts currency amount using the sequencer-provided rate source. */
     convertCurrency(params: ConvertCurrencyParams): Promise<ConvertedCurrencyResult>;
+    /**
+     * Gets TVM executor fee information for cross-chain operations.
+     * @param params Parameters for fee calculation including assets and fee symbol.
+     * @returns Promise resolving to suggested TVM executor fee information.
+     */
+    getTVMExecutorFee(params: GetTVMExecutorFeeParams): Promise<SuggestedTVMExecutorFee>;
+    /**
+     * Simulates TAC message execution without broadcasting it on-chain.
+     * Useful for estimating fees and validating transaction inputs.
+     * @param params Simulation request with encoded message and context.
+     * @returns Promise resolving to detailed simulation result.
+     */
+    simulateTACMessage(params: TACSimulationParams): Promise<TACSimulationResult>;
 }

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

@@ -7,6 +7,7 @@ const ethers_1 = require("ethers");
 const retryableContractOpener_1 = require("../adapters/retryableContractOpener");
 const Struct_1 = require("../structs/Struct");
 const Settings_1 = require("../wrappers/Settings");
+const Utils_1 = require("./Utils");
 const Validator_1 = require("./Validator");
 class Configuration {
     constructor(network, artifacts, TONParams, TACParams, liteSequencerEndpoints) {
@@ -17,8 +18,10 @@ class Configuration {
         this.liteSequencerEndpoints = liteSequencerEndpoints;
     }
     static async create(network, artifacts, TONParams, TACParams, customLiteSequencerEndpoints, delay) {
-        const internalTONParams = await this.prepareTONParams(artifacts, TONParams, delay);
-        const internalTACParams = await this.prepareTACParams(artifacts, TACParams);
+        const [internalTONParams, internalTACParams] = await Promise.all([
+            this.prepareTONParams(artifacts, TONParams, delay),
+            this.prepareTACParams(artifacts, TACParams),
+        ]);
         const liteSequencerEndpoints = customLiteSequencerEndpoints ??
             (network === Struct_1.Network.TESTNET
                 ? artifacts_1.testnet.PUBLIC_LITE_SEQUENCER_ENDPOINTS
@@ -28,14 +31,16 @@ class Configuration {
     static async prepareTONParams(artifacts, TONParams, delay) {
         const contractOpener = TONParams?.contractOpener ?? (await (0, retryableContractOpener_1.createDefaultRetryableOpener)(artifacts, 3, delay));
         const settingsAddress = TONParams?.settingsAddress ?? artifacts.TON_SETTINGS_ADDRESS;
-        const settings = contractOpener.open(new Settings_1.Settings(ton_1.Address.parse(settingsAddress)));
-        const jettonProxyAddress = await settings.getAddressSetting('JettonProxyAddress');
-        const crossChainLayerAddress = await settings.getAddressSetting('CrossChainLayerAddress');
-        const jettonMinterCode = await settings.getCellSetting('JettonMinterCode');
-        const jettonWalletCode = await settings.getCellSetting('JettonWalletCode');
-        const nftProxyAddress = await settings.getAddressSetting('NFTProxyAddress');
-        const nftItemCode = await settings.getCellSetting('NFTItemCode');
-        const nftCollectionCode = await settings.getCellSetting('NFTCollectionCode');
+        const settings = contractOpener.open(Settings_1.Settings.create(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, Settings_1.getAddressString)(allSettings.get((0, Utils_1.sha256toBigInt)('CrossChainLayerAddress')));
+        const jettonProxyAddress = (0, Settings_1.getAddressString)(allSettings.get((0, Utils_1.sha256toBigInt)('JettonProxyAddress')));
+        const nftProxyAddress = (0, Settings_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,
@@ -52,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>;
 }