@tonappchain/sdk 0.6.6-mainnet-alpha → 0.7.0-rc11

package/dist/interfaces/IOperationTracker.js

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

package/dist/interfaces/ISimulator.d.ts

@@ -0,0 +1,47 @@
+import type { SenderAbstraction } from '../sender';
+import { CrosschainTx, EvmProxyMsg, ExecutionFeeEstimationResult, SuggestedTONExecutorFee, TACSimulationRequest, TACSimulationResult, TransactionLinker } from '../structs/Struct';
+import { Asset } from './Asset';
+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.
+     */
+    getTVMExecutorFeeInfo(assets: Asset[], feeSymbol: string, tvmValidExecutors?: string[]): Promise<SuggestedTONExecutorFee>;
+    /**
+     * 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.
+     * @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>;
+}

package/dist/interfaces/ISimulator.js

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

package/dist/interfaces/ITacSDK.d.ts

@@ -0,0 +1,147 @@
+import { Wallet } from 'ethers';
+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 { IConfiguration } from './IConfiguration';
+import { Asset } from './Asset';
+import { FT, NFT } from '../assets';
+import { JettonMasterData } from '../wrappers/JettonMaster';
+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 IAsset. 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: TACSimulationRequest): 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.
+     */
+    simulateTransactions(sender: SenderAbstraction, txs: CrosschainTx[]): Promise<TACSimulationResult[]>;
+    /**
+     * Computes fee and execution information for a prospective transaction.
+     * @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.
+     */
+    getTransactionSimulationInfo(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: Asset[]): 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: Asset[], feeSymbol: string, tvmValidExecutors?: string[]): Promise<SuggestedTONExecutorFee>;
+    /**
+     * 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?: Asset[], 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 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[]>;
+    /**
+     * 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?: Asset[], 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 JettonMasterData.
+     */
+    getJettonData(itemAddress: TVMAddress): Promise<JettonMasterData>;
+    getNFTItemData(itemAddress: TVMAddress): Promise<NFTItemData>;
+    getEVMTokenAddress(tvmTokenAddress: string): Promise<string>;
+    getTVMTokenAddress(evmTokenAddress: string): Promise<string>;
+    getTVMNFTAddress(evmNFTAddress: string, tokenId?: number | bigint): Promise<string>;
+    getEVMNFTAddress(tvmNFTAddress: string, addressType: NFTAddressType): Promise<string>;
+    isContractDeployedOnTVM(address: string): Promise<boolean>;
+}

package/dist/interfaces/ITacSDK.js

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

package/dist/interfaces/ITransactionManager.d.ts

@@ -0,0 +1,35 @@
+import { Wallet } from 'ethers';
+import type { SenderAbstraction } from '../sender';
+import { CrossChainTransactionOptions, CrosschainTx, EvmProxyMsg, OperationIdsByShardsKey, TransactionLinkerWithOperationId, WaitOptions } from '../structs/Struct';
+import { Asset } from './Asset';
+export interface ITransactionManager {
+    /**
+     * Sends a single cross-chain transaction.
+     * @param evmProxyMsg Encoded EVM proxy message to bridge.
+     * @param sender Sender abstraction for TVM message sending.
+     * @param assets Optional assets to attach to the cross-chain message.
+     * @param options Optional cross-chain execution options (fees, executors, extra data).
+     * @param waitOptions Optional policy to wait for operation id resolution.
+     * @returns Transaction linker with operation id for tracking.
+     */
+    sendCrossChainTransaction(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: Asset[], options?: CrossChainTransactionOptions, 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 broadcast.
+     * @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[]>;
+    /**
+     * 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/ITransactionManager.js

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

package/dist/interfaces/SenderAbstraction.d.ts

@@ -0,0 +1,35 @@
+import type { SendResult, ShardTransaction } from '../structs/InternalStruct';
+import type { Asset, ContractOpener } from './index';
+import { Network } from '../structs/Struct';
+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/interfaces/SenderAbstraction.js

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

package/dist/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/interfaces/WalletInstanse.js

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

package/dist/interfaces/index.d.ts

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

package/dist/interfaces/index.js

@@ -0,0 +1,29 @@
+"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("./IConfiguration"), exports);
+__exportStar(require("./ContractOpener"), exports);
+__exportStar(require("./IHttpClient"), exports);
+__exportStar(require("./ILiteSequencerClient"), exports);
+__exportStar(require("./ILiteSequencerClientFactory"), exports);
+__exportStar(require("./ILogger"), exports);
+__exportStar(require("./IOperationTracker"), exports);
+__exportStar(require("./SenderAbstraction"), exports);
+__exportStar(require("./ISimulator"), exports);
+__exportStar(require("./ITacSDK"), exports);
+__exportStar(require("./ITransactionManager"), exports);
+__exportStar(require("./WalletInstanse"), exports);

package/dist/sdk/AxiosHttpClient.d.ts

@@ -0,0 +1,12 @@
+import { IHttpClient } from '../interfaces';
+import { AxiosRequestConfig, AxiosResponse } from '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.
+ */
+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/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/Configuration.d.ts

@@ -0,0 +1,21 @@
+import { mainnet, testnet } from '@tonappchain/artifacts';
+import { InternalTACParams, InternalTONParams } from '../structs/InternalStruct';
+import { IConfiguration } from '../interfaces';
+import { Network, TACParams, TONParams } from '../structs/Struct';
+export declare class Configuration implements IConfiguration {
+    readonly network: Network;
+    readonly artifacts: typeof testnet | typeof mainnet;
+    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>;
+    private static prepareTONParams;
+    private static prepareTACParams;
+    get nativeTONAddress(): string;
+    nativeTACAddress(): Promise<string>;
+    get getTrustedTACExecutors(): string[];
+    get getTrustedTONExecutors(): string[];
+    closeConnections(): unknown;
+    isContractDeployedOnTVM(address: string): Promise<boolean>;
+}

package/dist/sdk/Configuration.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Configuration = void 0;
+const ton_1 = require("@ton/ton");
+const artifacts_1 = require("@tonappchain/artifacts");
+const ethers_1 = require("ethers");
+const retryableContractOpener_1 = require("../adapters/retryableContractOpener");
+const Struct_1 = require("../structs/Struct");
+const Settings_1 = require("../wrappers/Settings");
+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 = await this.prepareTONParams(artifacts, TONParams, delay);
+        const internalTACParams = await this.prepareTACParams(artifacts, TACParams);
+        const liteSequencerEndpoints = customLiteSequencerEndpoints ??
+            (network === Struct_1.Network.TESTNET
+                ? artifacts_1.testnet.PUBLIC_LITE_SEQUENCER_ENDPOINTS
+                : artifacts_1.mainnet.PUBLIC_LITE_SEQUENCER_ENDPOINTS);
+        return new Configuration(network, artifacts, internalTONParams, internalTACParams, liteSequencerEndpoints);
+    }
+    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');
+        return {
+            contractOpener,
+            jettonProxyAddress,
+            crossChainLayerAddress,
+            jettonMinterCode,
+            jettonWalletCode,
+            nftProxyAddress,
+            nftItemCode,
+            nftCollectionCode,
+        };
+    }
+    static async prepareTACParams(artifacts, TACParams) {
+        const provider = TACParams?.provider ?? ethers_1.ethers.getDefaultProvider(artifacts.TAC_RPC_ENDPOINT);
+        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 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();
+        return {
+            provider,
+            settings,
+            tokenUtils,
+            crossChainLayer,
+            trustedTACExecutors,
+            trustedTONExecutors,
+            abiCoder: new ethers_1.ethers.AbiCoder(),
+        };
+    }
+    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/LiteSequencerClient.d.ts

@@ -1,12 +1,16 @@
-import { ExecutionStagesByOperationId, OperationIdsByShardsKey, OperationType, StatusInfosByOperationId, TransactionLinker } from '../structs/Struct';
+import { ConvertCurrencyParams, ConvertedCurrencyResult, ExecutionStagesByOperationId, OperationIdsByShardsKey, OperationType, StatusInfosByOperationId, TransactionLinker } from '../structs/Struct';
+import { IHttpClient } from '../interfaces';
 export declare class LiteSequencerClient {
     private readonly endpoint;
     private readonly maxChunkSize;
-    constructor(endpoint: string, maxChunkSize?: number);
+    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>;
     private processChunkedRequest;
 }