@tonappchain/sdk 0.7.0-rc9 → 0.7.1

package/dist/src/interfaces/ITacSDK.d.ts

@@ -0,0 +1,185 @@
+import { Wallet } from 'ethers';
+import { JettonMinterData, NFTItemData } from '../../artifacts/tonTypes';
+import { FT, NFT } from '../assets';
+import type { SenderAbstraction } from '../sender';
+import { AssetFromFTArg, AssetFromNFTCollectionArg, AssetFromNFTItemArg, AssetLike, BatchCrossChainTxWithAssetLike, CrossChainTransactionOptions, CrossChainTransactionsOptions, CrosschainTx, EVMAddress, EvmProxyMsg, ExecutionFeeEstimationResult, NFTAddressType, SuggestedTVMExecutorFee, TACSimulationParams, TACSimulationResult, TransactionLinkerWithOperationId, TVMAddress, UserWalletBalanceExtended, WaitOptions } from '../structs/Struct';
+import { Asset } from './Asset';
+import { IConfiguration } from './IConfiguration';
+import { IOperationTracker } from './IOperationTracker';
+export interface ITacSDK {
+    readonly config: IConfiguration;
+    /**
+     * TON native token (TON coin) address configured for the current network.
+     * @returns TON address string.
+     */
+    get nativeTONAddress(): string;
+    /**
+     * Returns the TAC (TON App Chain) native token address for the current network.
+     * @returns Promise that resolves to the TAC token master address.
+     */
+    nativeTACAddress(): Promise<string>;
+    /**
+     * List of TAC (EVM-side) executor addresses considered trusted for fee payments/validations.
+     */
+    get getTrustedTACExecutors(): string[];
+    /**
+     * List of TON (TVM-side) executor addresses considered trusted for fee payments/validations.
+     */
+    get getTrustedTONExecutors(): string[];
+    /**
+     * Closes any underlying network connections, clients, or subscriptions established by the SDK.
+     * Implementations should be idempotent and safe to call multiple times.
+     */
+    closeConnections(): unknown;
+    /**
+     * Creates a typed asset wrapper instance based on provided arguments.
+     * Pass FT, NFT collection or NFT item parameters; the returned type will match the input.
+     * @param args Parameters that describe the asset to wrap (FT/NFT collection/NFT item).
+     * @returns Promise resolving to a generic Asset. Use overloads for stronger typing.
+     */
+    getAsset(args: AssetFromFTArg | AssetFromNFTCollectionArg | AssetFromNFTItemArg): Promise<Asset>;
+    getAsset(args: AssetFromFTArg): Promise<FT>;
+    getAsset(args: AssetFromNFTCollectionArg): Promise<NFT>;
+    getAsset(args: AssetFromNFTItemArg): Promise<NFT>;
+    /**
+     * Returns a fungible token (Jetton) asset wrapper by its TVM or EVM address.
+     * @param address TVM or EVM token address.
+     * @returns Promise resolving to an FT wrapper.
+     */
+    getFT(address: TVMAddress | EVMAddress): Promise<FT>;
+    /**
+     * Returns an NFT asset wrapper for either a collection or a specific item.
+     * @param args NFT collection parameters or NFT item parameters.
+     * @returns Promise resolving to an NFT wrapper.
+     */
+    getNFT(args: AssetFromNFTCollectionArg | AssetFromNFTItemArg): Promise<NFT>;
+    /**
+     * Simulates a TAC message execution without broadcasting it on-chain.
+     * Useful for estimating fees and validating transaction inputs.
+     * @param req Simulation request with encoded message and context.
+     * @returns Promise with the detailed simulation result.
+     */
+    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 fee estimation results matching the input order.
+     */
+    simulateTransactions(sender: SenderAbstraction, txs: CrosschainTx[]): Promise<ExecutionFeeEstimationResult[]>;
+    /**
+     * Get tvm fees and simulation info for a tvm transaction using sender abstraction.
+     * @param evmProxyMsg Encoded EVM proxy message.
+     * @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.
+     */
+    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.
+     * @param feeSymbol Symbol (ticker) to express the fee in.
+     * @param tvmValidExecutors Optional whitelist of allowed TVM executors.
+     * @returns Promise with suggested fee details.
+     */
+    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.
+     * @param sender Sender abstraction responsible for signing/sending TVM messages.
+     * @param assets Optional list of assets to attach to the cross-chain message.
+     * @param options Optional cross-chain options (fees, executors, extra data, etc.).
+     * @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?: 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.
+     * @param txs Array of cross-chain transactions to broadcast.
+     * @param options Optional options controlling waiting behavior for operation ids.
+     * @returns Promise with an array of TransactionLinkerWithOperationId for each submitted transaction.
+     */
+    sendCrossChainTransactions(sender: SenderAbstraction, txs: BatchCrossChainTxWithAssetLike[], options?: CrossChainTransactionsOptions): Promise<TransactionLinkerWithOperationId[]>;
+    /**
+     * Bridges tokens/value from EVM to TON chain via the executor.
+     * @param signer Ethers Wallet used to sign the EVM-side transaction.
+     * @param value Amount of native EVM currency to bridge (in wei as bigint).
+     * @param tonTarget Recipient TVM address on TON.
+     * @param assets Optional list of TAC assets to include for the bridge.
+     * @param tvmExecutorFee Optional explicit TON-side executor fee.
+     * @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?: 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.
+     * @param tokenAddress Jetton master address.
+     * @returns Promise resolving to the Jetton wallet address.
+     */
+    getUserJettonWalletAddress(userAddress: string, tokenAddress: string): Promise<string>;
+    /**
+     * Returns Jetton balance for a user and a given Jetton master address.
+     * @param userAddress TVM user address.
+     * @param tokenAddress Jetton master address.
+     * @returns Promise resolving to the balance in raw base units (bigint).
+     */
+    getUserJettonBalance(userAddress: string, tokenAddress: string): Promise<bigint>;
+    /**
+     * Returns extended Jetton wallet information including balance and metadata.
+     * @param userAddress TVM user address.
+     * @param tokenAddress Jetton master address.
+     * @returns Promise resolving to extended wallet data.
+     */
+    getUserJettonBalanceExtended(userAddress: string, tokenAddress: string): Promise<UserWalletBalanceExtended>;
+    /**
+     * Returns Jetton master data (metadata and configuration) for a given Jetton master address.
+     * @param itemAddress Jetton master TVM address.
+     * @returns Promise resolving to JettonMinterData.
+     */
+    getJettonData(itemAddress: TVMAddress): Promise<JettonMinterData>;
+    /**
+     * 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/src/interfaces/ITacSDK.js

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

package/dist/src/interfaces/SenderAbstraction.d.ts

@@ -0,0 +1,35 @@
+import type { SendResult, ShardTransaction } from '../structs/InternalStruct';
+import { Network } from '../structs/Struct';
+import type { Asset, ContractOpener } from './index';
+export interface SenderAbstraction {
+    /**
+     * Sends a single shard transaction on the specified chain.
+     * @param shardTransaction Prepared transaction payload to send.
+     * @param chain Optional network selector; defaults to current SDK network.
+     * @param contractOpener Optional contract opener to use for sending.
+     * @returns Promise with low-level send result.
+     */
+    sendShardTransaction(shardTransaction: ShardTransaction, chain?: Network, contractOpener?: ContractOpener): Promise<SendResult>;
+    /**
+     * Sends multiple shard transactions as a batch.
+     * @param shardTransactions Array of prepared shard transactions to send.
+     * @param chain Optional network selector; defaults to current SDK network.
+     * @param contractOpener Optional contract opener to use for sending.
+     * @returns Promise with an array of low-level send results in the same order.
+     */
+    sendShardTransactions(shardTransactions: ShardTransaction[], chain?: Network, contractOpener?: ContractOpener): Promise<SendResult[]>;
+    /**
+     * Returns the TVM address of the underlying sender wallet.
+     */
+    getSenderAddress(): string;
+    /**
+     * Returns the TON balance of the sender wallet using the provided opener.
+     * @param contractOpener Contract opener used for on-chain queries.
+     */
+    getBalance(contractOpener: ContractOpener): Promise<bigint>;
+    /**
+     * Returns the balance of a given asset for the sender wallet.
+     * @param asset Asset wrapper instance to query balance for.
+     */
+    getBalanceOf(asset: Asset): Promise<bigint>;
+}

package/dist/src/interfaces/SenderAbstraction.js

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

package/dist/src/interfaces/WalletInstanse.d.ts

@@ -0,0 +1,20 @@
+import type { Contract, ContractProvider, MessageRelaxed, SendMode } from '@ton/ton';
+export interface WalletInstanse extends Contract {
+    /**
+     * Returns current wallet seqno, used for nonce/ordering.
+     * @param provider Contract provider to query the wallet.
+     */
+    getSeqno(provider: ContractProvider): Promise<number>;
+    /**
+     * Sends a transfer with specified messages and send mode.
+     * @param provider Contract provider used to send the transfer.
+     * @param args Transfer arguments including seqno, secretKey, messages and sendMode.
+     */
+    sendTransfer(provider: ContractProvider, args: {
+        seqno: number;
+        secretKey: Buffer;
+        messages: MessageRelaxed[];
+        sendMode: SendMode;
+        timeout?: number;
+    }): Promise<void>;
+}

package/dist/src/interfaces/WalletInstanse.js

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

package/dist/src/interfaces/index.d.ts

@@ -0,0 +1,14 @@
+export * from './Asset';
+export * from './ContractOpener';
+export * from './IConfiguration';
+export * from './IHttpClient';
+export * from './ILiteSequencerClient';
+export * from './ILiteSequencerClientFactory';
+export * from './ILogger';
+export * from './IOperationTracker';
+export * from './ISimulator';
+export * from './ITacSDK';
+export * from './ITACTransactionManager';
+export * from './ITONTransactionManager';
+export * from './SenderAbstraction';
+export * from './WalletInstanse';

package/dist/src/interfaces/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Asset"), exports);
+__exportStar(require("./ContractOpener"), exports);
+__exportStar(require("./IConfiguration"), exports);
+__exportStar(require("./IHttpClient"), exports);
+__exportStar(require("./ILiteSequencerClient"), exports);
+__exportStar(require("./ILiteSequencerClientFactory"), exports);
+__exportStar(require("./ILogger"), exports);
+__exportStar(require("./IOperationTracker"), exports);
+__exportStar(require("./ISimulator"), exports);
+__exportStar(require("./ITacSDK"), exports);
+__exportStar(require("./ITACTransactionManager"), exports);
+__exportStar(require("./ITONTransactionManager"), exports);
+__exportStar(require("./SenderAbstraction"), exports);
+__exportStar(require("./WalletInstanse"), exports);

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