@tonappchain/sdk 0.7.1 → 0.7.2-alpha-2

package/dist/src/adapters/contractOpener.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAdjacentTransactionsHelper = getAdjacentTransactionsHelper;
 exports.liteClientOpener = liteClientOpener;
 exports.sandboxOpener = sandboxOpener;
 exports.orbsOpener = orbsOpener;
 exports.orbsOpener4 = orbsOpener4;
+exports.tonClientOpener = tonClientOpener;
 const ton_access_1 = require("@orbs-network/ton-access");
 const ton_1 = require("@ton/ton");
 const ton_lite_client_1 = require("@tonappchain/ton-lite-client");
@@ -42,6 +44,74 @@ async function getHttpV4EndpointWithRetry(network, maxRetries = 5, delay = 1000)
     }
     throw lastError || new Error('Failed to get HTTP V4 endpoint after retries');
 }
+async function findTransactionByHash(addr, targetHashB64, getTransactions, opts) {
+    const timeoutMs = opts?.timeoutMs ?? 60000; // 60 seconds default
+    const retryDelayMs = opts?.retryDelayMs ?? 2000; // 2 seconds between retries
+    const deadline = Date.now() + timeoutMs;
+    const limit = opts?.limit ?? 10;
+    while (Date.now() < deadline) {
+        const batch = await getTransactions(addr, {
+            limit,
+            archival: opts?.archival ?? true,
+        });
+        // Check each transaction in the current batch
+        for (const tx of batch) {
+            // 1. check tx itself
+            if (tx.hash().toString('base64') === targetHashB64) {
+                return tx;
+            }
+            // 2. check incoming message(external-in)
+            if (tx.inMessage && tx.inMessage.info.type === 'external-in') {
+                const hash = (0, Utils_1.getNormalizedExtMessageHash)(tx.inMessage);
+                if (hash === targetHashB64) {
+                    return tx;
+                }
+            }
+            // 3. check incoming message(internal)
+            if (tx.inMessage && tx.inMessage.info.type === 'internal') {
+                const messageCell = (0, ton_1.beginCell)().store((0, ton_1.storeMessage)(tx.inMessage)).endCell();
+                const hash = messageCell.hash();
+                if (hash.toString('base64') === targetHashB64) {
+                    return tx;
+                }
+            }
+        }
+        if (Date.now() < deadline) {
+            await (0, Utils_1.sleep)(retryDelayMs);
+        }
+    }
+    return null;
+}
+async function getAdjacentTransactionsHelper(addr, hashB64, getTransactions, opts) {
+    // 1. Find the root transaction
+    const rootTx = await findTransactionByHash(addr, hashB64, getTransactions, opts);
+    if (!rootTx)
+        return [];
+    const adjacent = [];
+    // 2. Follow every outgoing message
+    for (const msg of rootTx.outMessages.values()) {
+        const dst = msg.info.dest;
+        if (!dst || dst instanceof ton_1.ExternalAddress)
+            continue;
+        const msgHashB64 = (0, ton_1.beginCell)().store((0, ton_1.storeMessage)(msg)).endCell().hash().toString('base64');
+        const tx = await findTransactionByHash(dst, msgHashB64, getTransactions, opts);
+        if (tx)
+            adjacent.push(tx);
+    }
+    // 3. Optional: follow the incoming message (if it exists and is internal)
+    if (rootTx.inMessage?.info.type === 'internal') {
+        const src = rootTx.inMessage.info.src;
+        if (src instanceof ton_1.Address) {
+            // The incoming message belongs to the sender's out-message list,
+            // so we look for the same message hash on the sender side.
+            const msgHashB64 = (0, ton_1.beginCell)().store((0, ton_1.storeMessage)(rootTx.inMessage)).endCell().hash().toString('base64');
+            const tx = await findTransactionByHash(src, msgHashB64, getTransactions, opts);
+            if (tx)
+                adjacent.push(tx);
+        }
+    }
+    return adjacent;
+}
 function intToIP(int) {
     const part1 = int & 255;
     const part2 = (int >> 8) & 255;
@@ -72,6 +142,14 @@ async function liteClientOpener(options) {
     const closeConnections = () => {
         engine.close();
     };
+    const getTransactions = async (address, opts) => {
+        const txsBuffered = await client
+            .getAccountTransactions(address, opts.lt ?? '', opts.hash ? Buffer.from(opts.hash, 'base64') : Buffer.alloc(0), opts.limit)
+            .then((r) => r.transactions);
+        const cell = ton_1.Cell.fromBoc(txsBuffered);
+        const transactions = cell.map((c) => (0, ton_1.loadTransaction)(c.beginParse()));
+        return transactions;
+    };
     return {
         getContractState: async (addr) => {
             const block = await client.getMasterchainInfo();
@@ -86,6 +164,21 @@ async function liteClientOpener(options) {
         },
         open: (contract) => client.open(contract),
         closeConnections,
+        getTransactionByHash: async (addr, hash, opts) => {
+            const tx = await findTransactionByHash(addr, hash, getTransactions, opts);
+            return tx;
+        },
+        getAdjacentTransactions: async (addr, hash, opts) => getAdjacentTransactionsHelper(addr, hash, getTransactions, opts),
+        getAddressInformation: async (addr) => {
+            const block = await client.getMasterchainInfo();
+            const state = await client.getAccountState(addr, block.last);
+            return {
+                lastTransaction: {
+                    lt: state.lastTx?.lt.toString() ?? '',
+                    hash: Buffer.from(state.lastTx?.hash.toString(16) ?? '', 'hex').toString('base64'),
+                },
+            };
+        },
     };
 }
 function sandboxOpener(blockchain) {
@@ -99,15 +192,47 @@ function sandboxOpener(blockchain) {
                 state: state.state.type === 'uninit' ? 'uninitialized' : state.state.type,
             };
         },
+        getTransactionByHash: () => {
+            throw new Error('Not implemented.');
+        },
+        getAdjacentTransactions() {
+            throw new Error('Not implemented.');
+        },
+        getAddressInformation: async () => {
+            throw new Error('Not implemented.');
+        },
     };
 }
 async function orbsOpener(network) {
     const endpoint = await getHttpEndpointWithRetry(network);
-    return new ton_1.TonClient({ endpoint });
+    const client = new ton_1.TonClient({ endpoint });
+    return {
+        open: client.open,
+        getContractState: client.getContractState,
+        getTransactionByHash: async (addr, hash, opts) => {
+            const tx = await findTransactionByHash(addr, hash, client.getTransactions, opts);
+            return tx;
+        },
+        getAdjacentTransactions: async (addr, hash, opts) => getAdjacentTransactionsHelper(addr, hash, client.getTransactions, opts),
+        getAddressInformation: async (addr) => {
+            const state = await client.getContractState(addr);
+            return {
+                lastTransaction: {
+                    lt: state.lastTransaction?.lt ?? '',
+                    hash: state.lastTransaction?.hash ?? '',
+                },
+            };
+        },
+    };
 }
 async function orbsOpener4(network, timeout = 10000) {
     const endpoint = await getHttpV4EndpointWithRetry(network);
     const client4 = new ton_1.TonClient4({ endpoint, timeout });
+    const getTransactions = async (address, opts) => {
+        return client4
+            .getAccountTransactions(address, opts.lt ? BigInt(opts.lt) : 0n, opts.hash ? Buffer.from(opts.hash, 'base64') : Buffer.alloc(0))
+            .then((res) => res.map((t) => t.tx));
+    };
     return {
         open: (contract) => client4.open(contract),
         getContractState: async (address) => {
@@ -122,5 +247,41 @@ async function orbsOpener4(network, timeout = 10000) {
                 state: state.account.state.type === 'uninit' ? 'uninitialized' : state.account.state.type,
             };
         },
+        getTransactionByHash: async (addr, hash, opts) => {
+            const tx = await findTransactionByHash(addr, hash, getTransactions, opts);
+            return tx;
+        },
+        getAdjacentTransactions: async (addr, hash, opts) => getAdjacentTransactionsHelper(addr, hash, getTransactions, opts),
+        getAddressInformation: async (addr) => {
+            const latestBlock = await client4.getLastBlock();
+            const latestBlockNumber = latestBlock.last.seqno;
+            const state = await client4.getAccount(latestBlockNumber, addr);
+            return {
+                lastTransaction: {
+                    lt: state.account.last?.lt ?? '',
+                    hash: state.account.last?.hash ?? '',
+                },
+            };
+        },
+    };
+}
+function tonClientOpener(client) {
+    return {
+        open: client.open.bind(client),
+        getContractState: client.getContractState.bind(client),
+        getTransactionByHash: async (addr, hash, opts) => {
+            const tx = await findTransactionByHash(addr, hash, client.getTransactions.bind(client), opts);
+            return tx;
+        },
+        getAdjacentTransactions: async (addr, hash, opts) => getAdjacentTransactionsHelper(addr, hash, client.getTransactions.bind(client), opts),
+        getAddressInformation: async (addr) => {
+            const state = await client.getContractState(addr);
+            return {
+                lastTransaction: {
+                    lt: state.lastTransaction?.lt ?? '',
+                    hash: state.lastTransaction?.hash ?? '',
+                },
+            };
+        },
     };
 }

package/dist/src/adapters/retryableContractOpener.d.ts

@@ -1,6 +1,7 @@
 import { SandboxContract } from '@ton/sandbox';
-import { Address, Contract, OpenedContract } from '@ton/ton';
+import { Address, Contract, OpenedContract, Transaction } from '@ton/ton';
 import { ContractOpener } from '../interfaces';
+import { AddressInformation, GetTransactionsOptions } from '../structs/InternalStruct';
 import { ContractState, Network } from '../structs/Struct';
 export interface OpenerConfig {
     /** Underlying opener implementation to use for this slot. */
@@ -13,8 +14,11 @@ export interface OpenerConfig {
 export declare class RetryableContractOpener implements ContractOpener {
     private readonly openerConfigs;
     constructor(openerConfigs: OpenerConfig[]);
+    getTransactionByHash(address: Address, hash: string, opts: GetTransactionsOptions): Promise<Transaction | null>;
+    getAdjacentTransactions(address: Address, hash: string): Promise<Transaction[]>;
     open<T extends Contract>(src: T): OpenedContract<T> | SandboxContract<T>;
     getContractState(address: Address): Promise<ContractState>;
+    getAddressInformation(address: Address): Promise<AddressInformation>;
     closeConnections(): void;
     private executeWithFallback;
     private tryWithRetries;

package/dist/src/adapters/retryableContractOpener.js

@@ -14,6 +14,20 @@ class RetryableContractOpener {
         }
         this.openerConfigs = openerConfigs;
     }
+    async getTransactionByHash(address, hash, opts) {
+        const result = await this.executeWithFallback((config) => config.opener.getTransactionByHash(address, hash, opts));
+        if (result.success && result.data) {
+            return result.data;
+        }
+        throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to get transaction by hash');
+    }
+    async getAdjacentTransactions(address, hash) {
+        const result = await this.executeWithFallback((config) => config.opener.getAdjacentTransactions(address, hash));
+        if (result.success && result.data) {
+            return result.data;
+        }
+        throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to get account transactions');
+    }
     open(src) {
         const firstConfig = this.openerConfigs[0];
         const contract = firstConfig.opener.open(src);
@@ -26,6 +40,13 @@ class RetryableContractOpener {
         }
         throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to get contract state');
     }
+    async getAddressInformation(address) {
+        const result = await this.executeWithFallback((config) => config.opener.getAddressInformation(address));
+        if (result.success && result.data) {
+            return result.data;
+        }
+        throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to get address information');
+    }
     closeConnections() {
         for (const config of this.openerConfigs) {
             config.opener.closeConnections?.();
@@ -87,14 +108,24 @@ class RetryableContractOpener {
 exports.RetryableContractOpener = RetryableContractOpener;
 async function createDefaultRetryableOpener(tonRpcEndpoint, networkType, maxRetries = 5, retryDelay = 1000) {
     const openers = [];
-    const tonClient = new ton_1.TonClient({
-        endpoint: new URL('api/v2/jsonRPC', tonRpcEndpoint).toString(),
-    });
-    openers.push({ opener: tonClient, retries: maxRetries, retryDelay });
+    const tonClient = new ton_1.TonClient({ endpoint: new URL('api/v2/jsonRPC', tonRpcEndpoint).toString() });
+    const opener = (0, contractOpener_1.tonClientOpener)(tonClient);
+    openers.push({ opener, retries: maxRetries, retryDelay });
     if (networkType !== Struct_1.Network.DEV) {
-        const opener4 = await (0, contractOpener_1.orbsOpener4)(networkType);
-        const opener = await (0, contractOpener_1.orbsOpener)(networkType);
-        openers.push({ opener: opener4, retries: maxRetries, retryDelay }, { opener: opener, retries: maxRetries, retryDelay });
+        try {
+            const opener4 = await (0, contractOpener_1.orbsOpener4)(networkType);
+            openers.push({ opener: opener4, retries: maxRetries, retryDelay });
+        }
+        catch {
+            // skip opener in case of failure
+        }
+        try {
+            const opener = await (0, contractOpener_1.orbsOpener)(networkType);
+            openers.push({ opener: opener, retries: maxRetries, retryDelay });
+        }
+        catch {
+            // skip opener in case of failure
+        }
     }
     return new RetryableContractOpener(openers);
 }

package/dist/src/assets/AssetFactory.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AssetFactory = void 0;
 const errors_1 = require("../errors");
+const Consts_1 = require("../sdk/Consts");
 const Struct_1 = require("../structs/Struct");
 const AssetCache_1 = require("./AssetCache");
 const FT_1 = require("./FT");
@@ -9,7 +10,9 @@ const NFT_1 = require("./NFT");
 const TON_1 = require("./TON");
 class AssetFactory {
     static async from(configuration, token) {
-        if (token.address === '' || token.address === configuration.nativeTONAddress) {
+        if (token.address === '' ||
+            token.address === configuration.nativeTONAddress ||
+            token.address === Consts_1.TON_BURN_ADDRESS) {
             if (token.tokenType !== Struct_1.AssetType.FT)
                 throw (0, errors_1.unknownTokenTypeError)(token.address, 'detected TON, but token type is not FT');
             return TON_1.TON.create(configuration);
@@ -26,7 +29,10 @@ class AssetFactory {
     }
     static async createFTAsset(configuration, address) {
         const ton = TON_1.TON.create(configuration);
-        if (address === configuration.nativeTONAddress || address === '' || address === (await ton.getEVMAddress())) {
+        if (address === configuration.nativeTONAddress ||
+            address === '' ||
+            address === (await ton.getEVMAddress()) ||
+            address === Consts_1.TON_BURN_ADDRESS) {
             return ton;
         }
         return FT_1.FT.fromAddress(configuration, address);

package/dist/src/assets/FT.d.ts

@@ -39,7 +39,7 @@ export declare class FT implements Asset {
         crossChainTonAmount?: bigint;
         forwardFeeTonAmount?: bigint;
         feeParams?: FeeParams;
-    }): Promise<Cell>;
+    }): Cell;
     get opType(): AssetOpType.JETTON_BURN | AssetOpType.JETTON_TRANSFER;
     getWallet(userAddress: string): Promise<OpenedContract<JettonWallet> | SandboxContract<JettonWallet>>;
     getUserWalletAddress(userAddress: string): Promise<string>;

package/dist/src/assets/FT.js

@@ -197,7 +197,7 @@ class FT {
     async getTVMAddress() {
         return this._tvmAddress.toString({ bounceable: true });
     }
-    async generatePayload(params) {
+    generatePayload(params) {
         const { excessReceiver, evmData, crossChainTonAmount = 0n, forwardFeeTonAmount = 0n, feeParams } = params;
         const feeData = (0, Utils_1.generateFeeData)(feeParams);
         let payload;

package/dist/src/assets/NFT.d.ts

@@ -59,7 +59,7 @@ export declare class NFT implements Asset {
         crossChainTonAmount?: bigint;
         forwardFeeTonAmount?: bigint;
         feeParams?: FeeParams;
-    }): Promise<Cell>;
+    }): Cell;
     isOwnedBy(userAddress: string): Promise<boolean>;
     checkCanBeTransferredBy(userAddress: string): Promise<void>;
     getBalanceOf(userAddress: string): Promise<bigint>;

package/dist/src/assets/NFT.js

@@ -188,7 +188,7 @@ class NFT {
     async getTVMAddress() {
         return this.address.toString();
     }
-    async generatePayload(params) {
+    generatePayload(params) {
         const { excessReceiver, evmData, crossChainTonAmount = 0n, forwardFeeTonAmount = 0n, feeParams } = params;
         const opType = this.origin === Struct_1.Origin.TAC ? InternalStruct_1.AssetOpType.NFT_BURN : InternalStruct_1.AssetOpType.NFT_TRANSFER;
         const feeData = (0, Utils_1.generateFeeData)(feeParams);

package/dist/src/assets/TON.d.ts

@@ -2,13 +2,14 @@ import { Cell } from '@ton/ton';
 import { Asset, IConfiguration } from '../interfaces';
 import type { SenderAbstraction } from '../sender';
 import type { ShardTransaction } from '../structs/InternalStruct';
-import { AssetType, FeeParams } from '../structs/Struct';
+import { AssetType, FeeParams, Origin } from '../structs/Struct';
 export declare class TON implements Asset {
     readonly address: string;
     readonly type: AssetType;
     private evmAddress;
     private _rawAmount;
     private _config;
+    readonly origin: Origin;
     constructor(config: IConfiguration);
     static create(config: IConfiguration): TON;
     get rawAmount(): bigint;
@@ -25,7 +26,7 @@ export declare class TON implements Asset {
         crossChainTonAmount?: bigint;
         forwardFeeTonAmount?: bigint;
         feeParams?: FeeParams;
-    }): Promise<Cell>;
+    }): Cell;
     getUserBalance(userAddress: string): Promise<bigint>;
     static checkBalance(sender: SenderAbstraction, config: IConfiguration, transactions: ShardTransaction[]): Promise<void>;
     checkCanBeTransferredBy(userAddress: string): Promise<void>;

package/dist/src/assets/TON.js

@@ -9,6 +9,7 @@ const Struct_1 = require("../structs/Struct");
 class TON {
     constructor(config) {
         this.type = Struct_1.AssetType.FT;
+        this.origin = Struct_1.Origin.TON;
         this.address = '';
         this._config = config;
         this._rawAmount = 0n;
@@ -60,7 +61,7 @@ class TON {
     async getTVMAddress() {
         return '';
     }
-    async generatePayload(params) {
+    generatePayload(params) {
         const { excessReceiver, evmData, feeParams } = params;
         const queryId = (0, Utils_1.generateRandomNumberByTimestamp)().randomNumber;
         const feeData = (0, Utils_1.generateFeeData)(feeParams);

package/dist/src/errors/instances.d.ts

@@ -1,3 +1,4 @@
+import { Origin } from '../structs/Struct';
 import { AddressError, BitError, ContractError, EVMCallError, FetchError, FormatError, InsufficientBalanceError, KeyError, MetadataError, NoValidGroupFoundError, PrepareMessageGroupError, SettingError, TokenError, WalletError } from './errors';
 export declare const emptyContractError: ContractError;
 export declare const operationFetchError: (msg: string, inner?: unknown) => FetchError;
@@ -32,3 +33,4 @@ export declare const missingJettonDataError: MetadataError;
 export declare const zeroRawAmountError: (assetAddress: string) => TokenError;
 export declare const sendCrossChainTransactionFailedError: (msg: string) => WalletError;
 export declare const convertCurrencyNegativeOrZeroValueError: FormatError;
+export declare const unknownAssetOriginError: (origin: Origin) => TokenError;

package/dist/src/errors/instances.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertCurrencyNegativeOrZeroValueError = exports.sendCrossChainTransactionFailedError = exports.zeroRawAmountError = exports.missingJettonDataError = exports.missingDecimals = exports.missingGasLimitError = exports.missingTvmExecutorFeeError = exports.missingFeeParamsError = exports.getTONFeeInfoFetchError = exports.simulationFetchError = exports.convertCurrencyFetchError = exports.indexRequiredError = exports.unknownTokenTypeError = exports.insufficientBalanceError = exports.allContractOpenerFailedError = exports.allEndpointsFailedError = exports.noValidGroupFoundError = exports.prepareMessageGroupError = exports.invalidAssetType = exports.emptyArrayError = exports.profilingFetchError = exports.invalidMethodNameError = exports.emptySettingError = exports.prefixError = exports.notMultiplyOf8Error = exports.unsupportedFormatError = exports.unsupportedKeyError = exports.unknownWalletError = exports.evmAddressError = exports.tvmAddressError = exports.statusFetchError = exports.operationFetchError = exports.emptyContractError = void 0;
+exports.unknownAssetOriginError = exports.convertCurrencyNegativeOrZeroValueError = exports.sendCrossChainTransactionFailedError = exports.zeroRawAmountError = exports.missingJettonDataError = exports.missingDecimals = exports.missingGasLimitError = exports.missingTvmExecutorFeeError = exports.missingFeeParamsError = exports.getTONFeeInfoFetchError = exports.simulationFetchError = exports.convertCurrencyFetchError = exports.indexRequiredError = exports.unknownTokenTypeError = exports.insufficientBalanceError = exports.allContractOpenerFailedError = exports.allEndpointsFailedError = exports.noValidGroupFoundError = exports.prepareMessageGroupError = exports.invalidAssetType = exports.emptyArrayError = exports.profilingFetchError = exports.invalidMethodNameError = exports.emptySettingError = exports.prefixError = exports.notMultiplyOf8Error = exports.unsupportedFormatError = exports.unsupportedKeyError = exports.unknownWalletError = exports.evmAddressError = exports.tvmAddressError = exports.statusFetchError = exports.operationFetchError = exports.emptyContractError = void 0;
 const errors_1 = require("./errors");
 exports.emptyContractError = new errors_1.ContractError('unexpected empty contract code of given jetton.', 100);
 const operationFetchError = (msg, inner) => new errors_1.FetchError(`failed to fetch OperationId: ${msg}`, 101, inner);
@@ -56,3 +56,5 @@ exports.zeroRawAmountError = zeroRawAmountError;
 const sendCrossChainTransactionFailedError = (msg) => new errors_1.WalletError(`failed to send cross chain transaction: ${msg}`, 131);
 exports.sendCrossChainTransactionFailedError = sendCrossChainTransactionFailedError;
 exports.convertCurrencyNegativeOrZeroValueError = new errors_1.FormatError('Value cannot be negative or zero for currency conversion', 132);
+const unknownAssetOriginError = (origin) => new errors_1.TokenError(`Unknown asset origin: ${origin}`, 133);
+exports.unknownAssetOriginError = unknownAssetOriginError;

package/dist/src/index.d.ts

@@ -10,7 +10,7 @@ export { LiteSequencerClient } from './sdk/LiteSequencerClient';
 export { ConsoleLogger, NoopLogger } from './sdk/Logger';
 export { OperationTracker } from './sdk/OperationTracker';
 export { Simulator } from './sdk/Simulator';
-export { startTracking, startTrackingMultiple } from './sdk/StartTracking';
+export * from './sdk/StartTracking';
 export { TacSdk } from './sdk/TacSdk';
 export { TACTransactionManager } from './sdk/TACTransactionManager';
 export { TONTransactionManager } from './sdk/TONTransactionManager';

package/dist/src/index.js

@@ -36,7 +36,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TONTransactionManager = exports.TACTransactionManager = exports.TacSdk = exports.startTrackingMultiple = exports.startTracking = exports.Simulator = exports.OperationTracker = exports.NoopLogger = exports.ConsoleLogger = exports.LiteSequencerClient = exports.Configuration = exports.AxiosHttpClient = exports.AgnosticStructs = exports.AgnosticProxySDK = void 0;
+exports.TONTransactionManager = exports.TACTransactionManager = exports.TacSdk = exports.Simulator = exports.OperationTracker = exports.NoopLogger = exports.ConsoleLogger = exports.LiteSequencerClient = exports.Configuration = exports.AxiosHttpClient = exports.AgnosticStructs = exports.AgnosticProxySDK = void 0;
 __exportStar(require("./adapters"), exports);
 var AgnosticSdk_1 = require("./agnosticSdk/AgnosticSdk");
 Object.defineProperty(exports, "AgnosticProxySDK", { enumerable: true, get: function () { return AgnosticSdk_1.AgnosticProxySDK; } });
@@ -57,9 +57,7 @@ var OperationTracker_1 = require("./sdk/OperationTracker");
 Object.defineProperty(exports, "OperationTracker", { enumerable: true, get: function () { return OperationTracker_1.OperationTracker; } });
 var Simulator_1 = require("./sdk/Simulator");
 Object.defineProperty(exports, "Simulator", { enumerable: true, get: function () { return Simulator_1.Simulator; } });
-var StartTracking_1 = require("./sdk/StartTracking");
-Object.defineProperty(exports, "startTracking", { enumerable: true, get: function () { return StartTracking_1.startTracking; } });
-Object.defineProperty(exports, "startTrackingMultiple", { enumerable: true, get: function () { return StartTracking_1.startTrackingMultiple; } });
+__exportStar(require("./sdk/StartTracking"), exports);
 var TacSdk_1 = require("./sdk/TacSdk");
 Object.defineProperty(exports, "TacSdk", { enumerable: true, get: function () { return TacSdk_1.TacSdk; } });
 var TACTransactionManager_1 = require("./sdk/TACTransactionManager");

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

@@ -1,10 +1,11 @@
 import type { Cell } from '@ton/ton';
-import { AssetType, FeeParams } from '../structs/Struct';
+import { AssetType, GeneratePayloadParams, Origin } from '../structs/Struct';
 export interface Asset {
     address: string;
     type: AssetType;
     rawAmount: bigint;
     clone: Asset;
+    origin: Origin;
     /**
      * Returns a new asset instance with the specified transfer amount in human-readable units.
      * Does not mutate the current asset instance.
@@ -53,15 +54,9 @@ export interface Asset {
      * @param params.crossChainTonAmount Optional TON amount to transfer cross-chain with the message.
      * @param params.forwardFeeTonAmount Optional TON amount used to cover forwarding fees on TON.
      * @param params.feeParams Optional fee parameters to fine-tune execution costs.
-     * @returns Promise that resolves to a Cell containing the encoded payload.
+     * @returns Cell containing the encoded payload.
      */
-    generatePayload(params: {
-        excessReceiver: string;
-        evmData: Cell;
-        crossChainTonAmount?: bigint;
-        forwardFeeTonAmount?: bigint;
-        feeParams?: FeeParams;
-    }): Promise<Cell>;
+    generatePayload(params: GeneratePayloadParams): Cell;
     /**
      * Validates whether the specified user is allowed to transfer this asset.
      * Implementations should throw if the transfer is not permitted (e.g., frozen asset, missing wallet, insufficient permissions).

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

@@ -1,5 +1,6 @@
 import { SandboxContract } from '@ton/sandbox';
-import type { Address, Contract, OpenedContract } from '@ton/ton';
+import type { Address, Contract, OpenedContract, Transaction } from '@ton/ton';
+import { AddressInformation, GetTransactionsOptions } from '../structs/InternalStruct';
 import { ContractState } from '../structs/Struct';
 export interface ContractOpener {
     /**
@@ -18,4 +19,7 @@ export interface ContractOpener {
      * Closes any underlying connections if supported by the implementation.
      */
     closeConnections?: () => unknown;
+    getTransactionByHash(address: Address, hash: string, opts?: GetTransactionsOptions): Promise<Transaction | null>;
+    getAdjacentTransactions(address: Address, hash: string, opts?: GetTransactionsOptions): Promise<Transaction[]>;
+    getAddressInformation(address: Address): Promise<AddressInformation>;
 }

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

@@ -1,5 +1,6 @@
 import type { SenderAbstraction } from '../sender';
-import { CrosschainTx, ExecutionFeeEstimationResult } from '../structs/Struct';
+import { CrosschainTx, ExecutionFeeEstimationResult, GeneratePayloadParams } from '../structs/Struct';
+import { Asset } from './Asset';
 export interface ISimulator {
     /**
      * Simulates a list of cross-chain transactions for a given sender.
@@ -15,4 +16,17 @@ export interface ISimulator {
      * @returns Promise with fee estimation and execution info.
      */
     getSimulationInfo(sender: SenderAbstraction, tx: CrosschainTx): Promise<ExecutionFeeEstimationResult>;
+    /**
+     * Estimates the total TON network fees required for a cross-chain transaction.
+     * @param assets Assets to be included in the transaction.
+     * @returns The total estimated fee in nanotons (1 TON = 10^9 nanotons) for processing all provided assets.
+     */
+    estimateTONFees(assets: Asset[], params: GeneratePayloadParams): bigint;
+    /**
+     * Estimates the TON network fee required for a single asset.
+     * @param asset Asset to be included in the transaction.
+     * @param params Payload parameters.
+     * @returns The total estimated fee in nanotons (1 TON = 10^9 nanotons) for processing the provided asset.
+     */
+    estimateTONFee(asset: Asset, params: GeneratePayloadParams): bigint;
 }

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

@@ -1,5 +1,6 @@
 import type { SenderAbstraction } from '../sender';
-import { BatchCrossChainTx, CrossChainTransactionsOptions, CrosschainTx, EvmProxyMsg, TransactionLinkerWithOperationId } from '../structs/Struct';
+import { BatchCrossChainTx, CrossChainPayloadResult, CrossChainTransactionOptions, CrossChainTransactionsOptions, CrosschainTx, EvmProxyMsg, FeeParams, TransactionLinkerWithOperationId } from '../structs/Struct';
+import { Asset } from './Asset';
 export interface ITONTransactionManager {
     /**
      * Sends a single cross-chain transaction.
@@ -17,4 +18,22 @@ export interface ITONTransactionManager {
      * @returns Array of transaction linkers, one per submitted transaction.
      */
     sendCrossChainTransactions(sender: SenderAbstraction, txs: BatchCrossChainTx[], options?: CrossChainTransactionsOptions): Promise<TransactionLinkerWithOperationId[]>;
+    /**
+     * Builds the fee parameters for a cross-chain transaction.
+     * @param options Transaction configuration options.
+     * @param evmProxyMsg Encoded EVM proxy message.
+     * @param sender Sender abstraction for TVM message sending.
+     * @param tx Cross-chain transaction to bridge.
+     * @returns Promise with the fee parameters.
+     */
+    buildFeeParams(options: CrossChainTransactionOptions, evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, tx: CrosschainTx): Promise<FeeParams>;
+    /**
+     * Prepares the transaction payloads required for a cross-chain operation without sending them.
+     * @param evmProxyMsg Encoded EVM proxy message.
+     * @param senderAddress TVM address of the transaction sender (wallet address).
+     * @param assets Assets to be included in the transaction.
+     * @param options Optional transaction configuration including error handling and executor settings.
+     * @returns Promise with the prepared transaction payloads.
+     */
+    prepareCrossChainTransactionPayload(evmProxyMsg: EvmProxyMsg, senderAddress: string, assets: Asset[], options?: CrossChainTransactionOptions): Promise<CrossChainPayloadResult[]>;
 }

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

@@ -2,7 +2,7 @@ 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 { AssetFromFTArg, AssetFromNFTCollectionArg, AssetFromNFTItemArg, AssetLike, BatchCrossChainTxWithAssetLike, CrossChainPayloadResult, 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';
@@ -182,4 +182,13 @@ export interface ITacSDK {
      * Returns the operation tracker instance used for querying operation statuses and utilities.
      */
     getOperationTracker(): IOperationTracker;
+    /**
+     * Prepares the transaction payloads required for a cross-chain operation without sending them.
+     * @param evmProxyMsg Encoded EVM proxy message.
+     * @param senderAddress TVM address of the transaction sender (wallet address).
+     * @param assets Assets to be included in the transaction.
+     * @param options Optional transaction configuration including error handling and executor settings.
+     * @returns Promise with the prepared transaction payloads.
+     */
+    prepareCrossChainTransactionPayload(evmProxyMsg: EvmProxyMsg, senderAddress: string, assets?: AssetLike[], options?: CrossChainTransactionOptions): Promise<CrossChainPayloadResult[]>;
 }

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

@@ -0,0 +1,5 @@
+export interface ITxFinalizer {
+    trackTransactionTree(address: string, hash: string, params: {
+        maxDepth?: number;
+    }): Promise<void>;
+}

package/dist/src/interfaces/ITxFinalizer.js

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

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

@@ -1,20 +1,16 @@
-import type { Contract, ContractProvider, MessageRelaxed, SendMode } from '@ton/ton';
+import type { Cell, 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: {
+    send(provider: ContractProvider, msg: Cell): Promise<string | void>;
+    createTransfer(args: {
         seqno: number;
         secretKey: Buffer;
         messages: MessageRelaxed[];
         sendMode: SendMode;
         timeout?: number;
-    }): Promise<void>;
+    }): Cell;
 }