@tonappchain/sdk 0.7.0-rc8 → 0.7.0

package/dist/src/interfaces/Asset.js

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

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

@@ -0,0 +1,21 @@
+import { SandboxContract } from '@ton/sandbox';
+import type { Address, Contract, OpenedContract } from '@ton/ton';
+import { ContractState } from '../structs/Struct';
+export interface ContractOpener {
+    /**
+     * Opens a contract for interaction using the underlying client (lite client, sandbox, etc.).
+     * @param src Contract source instance to open.
+     * @returns Opened contract ready for method calls and sending messages.
+     */
+    open<T extends Contract>(src: T): OpenedContract<T> | SandboxContract<T>;
+    /**
+     * Fetches on-chain contract state for a given address.
+     * @param address TVM address of the contract.
+     * @returns Promise with the contract state (code/data/existence).
+     */
+    getContractState(address: Address): Promise<ContractState>;
+    /**
+     * Closes any underlying connections if supported by the implementation.
+     */
+    closeConnections?: () => unknown;
+}

package/dist/src/interfaces/ContractOpener.js

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

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

@@ -0,0 +1,35 @@
+import { dev, mainnet, testnet } from '../../artifacts';
+import { InternalTACParams, InternalTONParams } from '../structs/InternalStruct';
+import { Network } from '../structs/Struct';
+export interface IConfiguration {
+    /** Current network the SDK is configured for (e.g., MAINNET/TESTNET). */
+    readonly network: Network;
+    /** Resolved artifacts bundle for the selected network (contract ABIs/addresses). */
+    readonly artifacts: typeof testnet | typeof mainnet | typeof dev;
+    /** Low-level TON client parameters and dependencies. */
+    readonly TONParams: InternalTONParams;
+    /** Low-level TAC (EVM-side) client parameters and dependencies. */
+    readonly TACParams: InternalTACParams;
+    /** List of Lite Sequencer API endpoints used for tracking and utilities. */
+    readonly liteSequencerEndpoints: string[];
+    /** Native TON coin master address for the configured network. */
+    readonly nativeTONAddress: string;
+    /**
+     * Returns the native TAC token (Jetton master) address for the configured network.
+     */
+    nativeTACAddress(): Promise<string>;
+    /** Whitelisted EVM (TAC) executor addresses considered trusted. */
+    readonly getTrustedTACExecutors: string[];
+    /** Whitelisted TVM (TON) executor addresses considered trusted. */
+    readonly getTrustedTONExecutors: string[];
+    /**
+     * Closes any underlying connections/resources held by configuration-level clients.
+     * Implementations should be idempotent.
+     */
+    closeConnections(): unknown;
+    /**
+     * Checks if a given TVM address is a deployed contract on the current network.
+     * @param address TVM address to verify.
+     */
+    isContractDeployedOnTVM(address: string): Promise<boolean>;
+}

package/dist/src/interfaces/IConfiguration.js

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

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

@@ -0,0 +1,16 @@
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+export interface IHttpClient {
+    /**
+     * Sends an HTTP GET request and returns a typed Axios response.
+     * @param url Target URL.
+     * @param config Optional Axios request configuration.
+     */
+    get<T>(url: string, config?: AxiosRequestConfig): Promise<AxiosResponse<T>>;
+    /**
+     * Sends an HTTP POST request and returns a typed Axios response.
+     * @param url Target URL.
+     * @param data Request body payload.
+     * @param config Optional Axios request configuration.
+     */
+    post<T>(url: string, data: unknown, config?: AxiosRequestConfig): Promise<AxiosResponse<T>>;
+}

package/dist/src/interfaces/IHttpClient.js

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

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

@@ -0,0 +1,43 @@
+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>;
+    /** Resolves operation id by a transaction linker. */
+    getOperationId(transactionLinker: TransactionLinker): Promise<string>;
+    /** Resolves operation id by the originating transaction hash. */
+    getOperationIdByTransactionHash(transactionHash: string): Promise<string>;
+    /**
+     * Resolves operation ids for multiple shard keys.
+     * @param shardsKeys Shard keys to query.
+     * @param caller Human-readable identifier of the caller (for rate limiting/observability).
+     * @param chunkSize Optional chunk size for batching requests.
+     */
+    getOperationIdsByShardsKeys(shardsKeys: string[], caller: string, chunkSize?: number): Promise<OperationIdsByShardsKey>;
+    /**
+     * Fetches stage profiling data for a set of operation ids.
+     * @param operationIds Operation ids to get profiling for.
+     * @param chunkSize Optional batching size.
+     */
+    getStageProfilings(operationIds: string[], chunkSize?: number): Promise<ExecutionStagesByOperationId>;
+    /**
+     * Fetches statuses for a set of operation ids.
+     * @param operationIds Operation ids to get statuses for.
+     * @param chunkSize Optional batching size.
+     */
+    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/src/interfaces/ILiteSequencerClient.js

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

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

@@ -0,0 +1,9 @@
+import { ILiteSequencerClient } from './ILiteSequencerClient';
+export interface ILiteSequencerClientFactory {
+    /**
+     * Creates Lite Sequencer clients for the provided HTTP endpoints.
+     * @param endpoints List of base URLs.
+     * @returns Array of ILiteSequencerClient instances, one per endpoint.
+     */
+    createClients(endpoints: string[]): ILiteSequencerClient[];
+}

package/dist/src/interfaces/ILiteSequencerClientFactory.js

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

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

@@ -0,0 +1,10 @@
+export interface ILogger {
+    /** Logs verbose diagnostic information useful during development. */
+    debug(...arg: unknown[]): void;
+    /** Logs general informational messages about normal operation. */
+    info(...arg: unknown[]): void;
+    /** Logs warnings about unexpected but non-fatal conditions. */
+    warn(...arg: unknown[]): void;
+    /** Logs errors for failures and exceptional conditions. */
+    error(...arg: unknown[]): void;
+}

package/dist/src/interfaces/ILogger.js

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

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

@@ -0,0 +1,81 @@
+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.
+     * @param operationId Operation identifier.
+     * @param waitOptions Optional waiting and polling settings.
+     */
+    getOperationType(operationId: string, waitOptions?: WaitOptions<OperationType>): Promise<OperationType>;
+    /**
+     * Resolves an operation id for the given transaction linker, optionally waiting until available.
+     * @param transactionLinker Reference to originating transaction across chains.
+     * @param waitOptions Optional waiting settings.
+     */
+    getOperationId(transactionLinker: TransactionLinker, waitOptions?: WaitOptions<string>): Promise<string>;
+    /**
+     * Resolves an operation id by a transaction hash, optionally waiting until available.
+     * @param transactionHash Hash of the originating transaction.
+     * @param waitOptions Optional waiting settings.
+     */
+    getOperationIdByTransactionHash(transactionHash: string, waitOptions?: WaitOptions<string>): Promise<string>;
+    /**
+     * Resolves operation ids by shard keys for a particular caller, with optional batching and waiting.
+     * @param shardsKeys List of shard keys.
+     * @param caller Human-readable identifier of the caller (for tracing/limits).
+     * @param waitOptions Optional waiting settings.
+     * @param chunkSize Optional batching size for network requests.
+     */
+    getOperationIdsByShardsKeys(shardsKeys: string[], caller: string, waitOptions?: WaitOptions<OperationIdsByShardsKey>, chunkSize?: number): Promise<OperationIdsByShardsKey>;
+    /**
+     * Gets detailed stage profiling for a single operation, optionally waiting until available.
+     * @param operationId Operation identifier.
+     * @param waitOptions Optional waiting settings.
+     */
+    getStageProfiling(operationId: string, waitOptions?: WaitOptions<ExecutionStages>): Promise<ExecutionStages>;
+    /**
+     * Gets stage profiling for multiple operations in bulk.
+     * @param operationIds Operation identifiers.
+     * @param waitOptions Optional waiting settings.
+     * @param chunkSize Optional batching size for requests.
+     */
+    getStageProfilings(operationIds: string[], waitOptions?: WaitOptions<ExecutionStagesByOperationId>, chunkSize?: number): Promise<ExecutionStagesByOperationId>;
+    /**
+     * Gets statuses for multiple operations.
+     * @param operationIds Operation identifiers.
+     * @param waitOptions Optional waiting settings.
+     * @param chunkSize Optional batching size for requests.
+     */
+    getOperationStatuses(operationIds: string[], waitOptions?: WaitOptions<StatusInfosByOperationId>, chunkSize?: number): Promise<StatusInfosByOperationId>;
+    /**
+     * Gets a single operation status, optionally waiting according to policy.
+     * @param operationId Operation identifier.
+     * @param waitOptions Optional waiting settings.
+     */
+    getOperationStatus(operationId: string, waitOptions?: WaitOptions<StatusInfo>): Promise<StatusInfo>;
+    /**
+     * Returns a simplified status for the provided transaction linker.
+     * @param transactionLinker Reference to originating transaction across chains.
+     */
+    getSimplifiedOperationStatus(transactionLinker: TransactionLinker): Promise<SimplifiedStatuses>;
+    /**
+     * Converts currency using the tracker service, optionally waiting for completion.
+     * @param params Conversion parameters.
+     * @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/src/interfaces/IOperationTracker.js

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

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

@@ -0,0 +1,18 @@
+import type { SenderAbstraction } from '../sender';
+import { CrosschainTx, ExecutionFeeEstimationResult } from '../structs/Struct';
+export interface ISimulator {
+    /**
+     * 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 fee estimation results, one for each input transaction.
+     */
+    getSimulationsInfo(sender: SenderAbstraction, txs: CrosschainTx[]): Promise<ExecutionFeeEstimationResult[]>;
+    /**
+     * 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.
+     */
+    getSimulationInfo(sender: SenderAbstraction, tx: CrosschainTx): Promise<ExecutionFeeEstimationResult>;
+}

package/dist/src/interfaces/ISimulator.js

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

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

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

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

@@ -0,0 +1,20 @@
+import type { SenderAbstraction } from '../sender';
+import { BatchCrossChainTx, CrossChainTransactionsOptions, CrosschainTx, EvmProxyMsg, TransactionLinkerWithOperationId } 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.
+     * @returns Transaction linker with operation id for tracking.
+     */
+    sendCrossChainTransaction(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, tx: CrosschainTx): 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 options Optional options controlling waiting behavior for operation ids.
+     * @returns Array of transaction linkers, one per submitted transaction.
+     */
+    sendCrossChainTransactions(sender: SenderAbstraction, txs: BatchCrossChainTx[], options?: CrossChainTransactionsOptions): Promise<TransactionLinkerWithOperationId[]>;
+}

package/dist/src/interfaces/ITONTransactionManager.js

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

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