@tonappchain/sdk 0.7.2-alpha-11 → 0.7.2-alpha-13

package/dist/src/adapters/{retryableContractOpener.js → RetryableContractOpener.js}

@@ -4,15 +4,25 @@ exports.RetryableContractOpener = void 0;
 exports.createDefaultRetryableOpener = createDefaultRetryableOpener;
 const ton_1 = require("@ton/ton");
 const instances_1 = require("../errors/instances");
+const Consts_1 = require("../sdk/Consts");
 const Struct_1 = require("../structs/Struct");
-const contractOpener_1 = require("./contractOpener");
+const TonClient4Opener_1 = require("./TonClient4Opener");
+const TonClientOpener_1 = require("./TonClientOpener");
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 class RetryableContractOpener {
-    constructor(openerConfigs) {
+    constructor(openerConfigs, logger) {
         if (openerConfigs.length === 0) {
             throw new Error('No ContractOpener instances available');
         }
         this.openerConfigs = openerConfigs;
+        this.logger = logger;
+    }
+    async getTransactions(address, opts) {
+        const result = await this.executeWithFallback((config) => config.opener.getTransactions(address, opts));
+        if (result.success && result.data) {
+            return result.data;
+        }
+        throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to get transactions');
     }
     async getTransactionByHash(address, hash, opts) {
         const result = await this.executeWithFallback((config) => config.opener.getTransactionByHash(address, hash, opts));
@@ -21,12 +31,12 @@ class RetryableContractOpener {
         }
         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));
+    async getAdjacentTransactions(address, hash, opts) {
+        const result = await this.executeWithFallback((config) => config.opener.getAdjacentTransactions(address, hash, opts));
         if (result.success && result.data) {
             return result.data;
         }
-        throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to get account transactions');
+        throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to get adjacent transactions');
     }
     open(src) {
         const firstConfig = this.openerConfigs[0];
@@ -54,11 +64,49 @@ class RetryableContractOpener {
         }
         throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to get blockchain config');
     }
+    async getTransactionByTxHash(address, txHash, opts) {
+        const result = await this.executeWithFallback((config) => config.opener.getTransactionByTxHash(address, txHash, opts));
+        if (result.success) {
+            return result.data ?? null;
+        }
+        throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to get transaction by transaction hash');
+    }
+    async getTransactionByInMsgHash(address, msgHash, opts) {
+        const result = await this.executeWithFallback((config) => config.opener.getTransactionByInMsgHash(address, msgHash, opts));
+        if (result.success) {
+            return result.data ?? null;
+        }
+        throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to get transaction by message hash');
+    }
+    async getTransactionByOutMsgHash(address, msgHash, opts) {
+        const result = await this.executeWithFallback((config) => config.opener.getTransactionByOutMsgHash(address, msgHash, opts));
+        if (result.success) {
+            return result.data ?? null;
+        }
+        throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to get transaction by outgoing message hash');
+    }
     closeConnections() {
         for (const config of this.openerConfigs) {
             config.opener.closeConnections?.();
         }
     }
+    async trackTransactionTree(address, hash, params) {
+        const result = await this.executeWithFallback(async (config) => {
+            return config.opener.trackTransactionTree(address, hash, params);
+        });
+        if (!result.success) {
+            throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to track transaction tree');
+        }
+    }
+    async trackTransactionTreeWithResult(address, hash, params) {
+        const result = await this.executeWithFallback(async (config) => {
+            return config.opener.trackTransactionTreeWithResult(address, hash, params);
+        });
+        if (!result.success) {
+            throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to track transaction tree with result');
+        }
+        return result.data;
+    }
     async executeWithFallback(operation) {
         let lastError;
         for (const config of this.openerConfigs) {
@@ -113,26 +161,26 @@ class RetryableContractOpener {
     }
 }
 exports.RetryableContractOpener = RetryableContractOpener;
-async function createDefaultRetryableOpener(tonRpcEndpoint, networkType, maxRetries = 5, retryDelay = 1000) {
+async function createDefaultRetryableOpener(tonRpcEndpoint, networkType, maxRetries = Consts_1.DEFAULT_RETRY_MAX_COUNT, retryDelay = Consts_1.DEFAULT_RETRY_DELAY_MS, logger) {
     const openers = [];
     const tonClient = new ton_1.TonClient({ endpoint: new URL('api/v2/jsonRPC', tonRpcEndpoint).toString() });
-    const opener = (0, contractOpener_1.tonClientOpener)(tonClient);
+    const opener = (0, TonClientOpener_1.tonClientOpener)(tonClient);
     openers.push({ opener, retries: maxRetries, retryDelay });
     if (networkType !== Struct_1.Network.DEV) {
         try {
-            const opener4 = await (0, contractOpener_1.orbsOpener4)(networkType);
-            openers.push({ opener: opener4, retries: maxRetries, retryDelay });
+            const opener = await (0, TonClientOpener_1.orbsOpener)(networkType);
+            openers.push({ opener: opener, 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 });
+            const opener4 = await (0, TonClient4Opener_1.orbsOpener4)(networkType);
+            openers.push({ opener: opener4, retries: maxRetries, retryDelay });
         }
         catch {
             // skip opener in case of failure
         }
     }
-    return new RetryableContractOpener(openers);
+    return new RetryableContractOpener(openers, logger);
 }

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

@@ -0,0 +1,15 @@
+import { Blockchain, SandboxContract } from '@ton/sandbox';
+import { Address, Contract, Transaction } from '@ton/ton';
+import { ContractOpener } from '../interfaces';
+import { AddressInformation, ContractState } from '../structs/Struct';
+import { BaseContractOpener } from './BaseContractOpener';
+export declare class SandboxOpener extends BaseContractOpener {
+    private readonly blockchain;
+    constructor(blockchain: Blockchain);
+    open<T extends Contract>(contract: T): SandboxContract<T>;
+    getContractState(address: Address): Promise<ContractState>;
+    getTransactions(): Promise<Transaction[]>;
+    getAddressInformation(): Promise<AddressInformation>;
+    getConfig(): Promise<string>;
+}
+export declare function sandboxOpener(blockchain: Blockchain): ContractOpener;

package/dist/src/adapters/SandboxOpener.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SandboxOpener = void 0;
+exports.sandboxOpener = sandboxOpener;
+const BaseContractOpener_1 = require("./BaseContractOpener");
+class SandboxOpener extends BaseContractOpener_1.BaseContractOpener {
+    constructor(blockchain) {
+        super();
+        this.blockchain = blockchain;
+    }
+    open(contract) {
+        return this.blockchain.openContract(contract);
+    }
+    async getContractState(address) {
+        const state = await this.blockchain.provider(address).getState();
+        return {
+            balance: state.balance,
+            code: 'code' in state.state ? (state.state.code ?? null) : null,
+            state: state.state.type === 'uninit' ? 'uninitialized' : state.state.type,
+        };
+    }
+    async getTransactions() {
+        throw new Error('getTransactions not implemented for sandboxOpener');
+    }
+    async getAddressInformation() {
+        throw new Error('getAddressInformation not implemented for sandboxOpener');
+    }
+    async getConfig() {
+        return this.blockchain.config.toBoc().toString('base64');
+    }
+}
+exports.SandboxOpener = SandboxOpener;
+function sandboxOpener(blockchain) {
+    return new SandboxOpener(blockchain);
+}

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

@@ -0,0 +1,21 @@
+import { Address, Contract, OpenedContract, TonClient4, Transaction } from '@ton/ton';
+import { AddressInformation, ContractState, GetTransactionsOptions, Network } from '../structs/Struct';
+import { BaseContractOpener } from './BaseContractOpener';
+export declare class TonClient4Opener extends BaseContractOpener {
+    private readonly client4;
+    constructor(client4: TonClient4);
+    static create(endpoint: string, timeout?: number): TonClient4Opener;
+    open<T extends Contract>(contract: T): OpenedContract<T>;
+    getContractState(address: Address): Promise<ContractState>;
+    getTransactions(address: Address, opts: GetTransactionsOptions): Promise<Transaction[]>;
+    getAddressInformation(addr: Address): Promise<AddressInformation>;
+    getConfig(): Promise<string>;
+}
+/**
+ * Creates a TonClient4Opener instance using TonHub public API
+ * @param network Network to connect to (mainnet or testnet)
+ * @param timeout Request timeout in milliseconds
+ */
+export declare function tonHubApi4Opener(network: Network, timeout?: number): TonClient4Opener;
+export declare function tonClient4Opener(client: TonClient4): TonClient4Opener;
+export declare function orbsOpener4(network: Network, timeout?: number): Promise<TonClient4Opener>;

package/dist/src/adapters/TonClient4Opener.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TonClient4Opener = void 0;
+exports.tonHubApi4Opener = tonHubApi4Opener;
+exports.tonClient4Opener = tonClient4Opener;
+exports.orbsOpener4 = orbsOpener4;
+const ton_1 = require("@ton/ton");
+const Consts_1 = require("../sdk/Consts");
+const Struct_1 = require("../structs/Struct");
+const BaseContractOpener_1 = require("./BaseContractOpener");
+const OpenerUtils_1 = require("./OpenerUtils");
+class TonClient4Opener extends BaseContractOpener_1.BaseContractOpener {
+    constructor(client4) {
+        super();
+        this.client4 = client4;
+    }
+    static create(endpoint, timeout = 10000) {
+        const client4 = new ton_1.TonClient4({ endpoint, timeout });
+        return new TonClient4Opener(client4);
+    }
+    open(contract) {
+        return this.client4.open(contract);
+    }
+    async getContractState(address) {
+        const latestBlock = await this.client4.getLastBlock();
+        const latestBlockNumber = latestBlock.last.seqno;
+        const state = await this.client4.getAccount(latestBlockNumber, address);
+        return {
+            balance: BigInt(state.account.balance.coins),
+            code: 'code' in state.account.state && state.account.state.code !== null
+                ? Buffer.from(state.account.state.code, 'base64')
+                : null,
+            state: state.account.state.type === 'uninit' ? 'uninitialized' : state.account.state.type,
+        };
+    }
+    async getTransactions(address, opts) {
+        const allTxs = await this.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));
+        // Apply limit if specified
+        let txs = opts.limit ? allTxs.slice(0, opts.limit) : allTxs;
+        // Apply to_lt filter if specified
+        if (opts.to_lt) {
+            const toLt = BigInt(opts.to_lt);
+            txs = txs.filter((tx) => {
+                const comparison = tx.lt > toLt;
+                return opts.inclusive ? tx.lt >= toLt : comparison;
+            });
+        }
+        return txs;
+    }
+    async getAddressInformation(addr) {
+        const latestBlock = await this.client4.getLastBlock();
+        const latestBlockNumber = latestBlock.last.seqno;
+        const state = await this.client4.getAccount(latestBlockNumber, addr);
+        return {
+            lastTransaction: {
+                lt: state.account.last?.lt ?? '',
+                hash: state.account.last?.hash ?? '',
+            },
+        };
+    }
+    async getConfig() {
+        const block = await this.client4.getLastBlock();
+        const { config } = await this.client4.getConfig(block.last.seqno);
+        return config.cell;
+    }
+}
+exports.TonClient4Opener = TonClient4Opener;
+/**
+ * Creates a TonClient4Opener instance using TonHub public API
+ * @param network Network to connect to (mainnet or testnet)
+ * @param timeout Request timeout in milliseconds
+ */
+function tonHubApi4Opener(network, timeout = Consts_1.DEFAULT_HTTP_CLIENT_TIMEOUT_MS) {
+    const endpoint = network === Struct_1.Network.MAINNET ? 'https://mainnet-v4.tonhubapi.com' : 'https://testnet-v4.tonhubapi.com';
+    return TonClient4Opener.create(endpoint, timeout);
+}
+function tonClient4Opener(client) {
+    return new TonClient4Opener(client);
+}
+async function orbsOpener4(network, timeout = Consts_1.DEFAULT_HTTP_CLIENT_TIMEOUT_MS) {
+    const endpoint = await (0, OpenerUtils_1.getHttpV4EndpointWithRetry)(network);
+    const client = new ton_1.TonClient4({ endpoint, timeout });
+    return new TonClient4Opener(client);
+}

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

@@ -0,0 +1,16 @@
+import { Address, Contract, OpenedContract, TonClient, Transaction } from '@ton/ton';
+import { AddressInformation, ContractState, GetTransactionsOptions, Network } from '../structs/Struct';
+import { BaseContractOpener } from './BaseContractOpener';
+export declare class TonClientOpener extends BaseContractOpener {
+    private readonly client;
+    private readonly httpClient;
+    constructor(client: TonClient);
+    static create(endpoint: string, timeout?: number): TonClientOpener;
+    open<T extends Contract>(contract: T): OpenedContract<T>;
+    getContractState(address: Address): Promise<ContractState>;
+    getTransactions(address: Address, opts: GetTransactionsOptions): Promise<Transaction[]>;
+    getAddressInformation(addr: Address): Promise<AddressInformation>;
+    getConfig(): Promise<string>;
+}
+export declare function tonClientOpener(client: TonClient): TonClientOpener;
+export declare function orbsOpener(network: Network): Promise<TonClientOpener>;

package/dist/src/adapters/TonClientOpener.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TonClientOpener = void 0;
+exports.tonClientOpener = tonClientOpener;
+exports.orbsOpener = orbsOpener;
+const ton_1 = require("@ton/ton");
+const AxiosHttpClient_1 = require("../sdk/AxiosHttpClient");
+const Consts_1 = require("../sdk/Consts");
+const BaseContractOpener_1 = require("./BaseContractOpener");
+const OpenerUtils_1 = require("./OpenerUtils");
+class TonClientOpener extends BaseContractOpener_1.BaseContractOpener {
+    constructor(client) {
+        super();
+        this.client = client;
+        this.httpClient = new AxiosHttpClient_1.AxiosHttpClient({ timeout: Consts_1.DEFAULT_HTTP_CLIENT_TIMEOUT_MS });
+    }
+    static create(endpoint, timeout = Consts_1.DEFAULT_HTTP_CLIENT_TIMEOUT_MS) {
+        const client = new ton_1.TonClient({ endpoint, timeout });
+        return new TonClientOpener(client);
+    }
+    open(contract) {
+        return this.client.open(contract);
+    }
+    async getContractState(address) {
+        return this.client.getContractState(address);
+    }
+    async getTransactions(address, opts) {
+        // TonClient doesn't accept timeoutMs and retryDelayMs, filter them out
+        const clientOpts = {
+            limit: opts.limit ?? Consts_1.DEFAULT_FIND_TX_LIMIT,
+            lt: opts.lt,
+            hash: opts.hash,
+            to_lt: opts.to_lt,
+            inclusive: opts.inclusive,
+            archival: opts.archival,
+        };
+        return this.client.getTransactions(address, clientOpts);
+    }
+    async getAddressInformation(addr) {
+        const state = await this.client.getContractState(addr);
+        return {
+            lastTransaction: {
+                lt: state.lastTransaction?.lt ?? '',
+                hash: state.lastTransaction?.hash ?? '',
+            },
+        };
+    }
+    async getConfig() {
+        const info = await this.client.getMasterchainInfo();
+        const url = new URL('getConfigAll', this.client.parameters.endpoint);
+        url.searchParams.append('seqno', info.latestSeqno.toString());
+        // Use longer timeout for getConfig as the response is very large (~100KB+)
+        // and Brotli decompression can take significant time
+        const response = await this.httpClient.get(url.toString(), { timeout: 60000 });
+        const body = response.data;
+        if (!body?.ok || !body.result?.config?.bytes) {
+            throw new Error(`Failed to fetch config: ${JSON.stringify(body)}`);
+        }
+        return body.result.config.bytes;
+    }
+}
+exports.TonClientOpener = TonClientOpener;
+function tonClientOpener(client) {
+    return new TonClientOpener(client);
+}
+async function orbsOpener(network) {
+    const endpoint = await (0, OpenerUtils_1.getHttpEndpointWithRetry)(network);
+    const client = new ton_1.TonClient({ endpoint });
+    return new TonClientOpener(client);
+}

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

@@ -1,2 +1,7 @@
-export * from './contractOpener';
-export * from './retryableContractOpener';
+export * from './BaseContractOpener';
+export * from './LiteClientOpener';
+export * from './OpenerUtils';
+export * from './RetryableContractOpener';
+export * from './SandboxOpener';
+export * from './TonClient4Opener';
+export * from './TonClientOpener';

package/dist/src/adapters/index.js

@@ -14,5 +14,10 @@ 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("./contractOpener"), exports);
-__exportStar(require("./retryableContractOpener"), exports);
+__exportStar(require("./BaseContractOpener"), exports);
+__exportStar(require("./LiteClientOpener"), exports);
+__exportStar(require("./OpenerUtils"), exports);
+__exportStar(require("./RetryableContractOpener"), exports);
+__exportStar(require("./SandboxOpener"), exports);
+__exportStar(require("./TonClient4Opener"), exports);
+__exportStar(require("./TonClientOpener"), exports);

package/dist/src/index.d.ts

@@ -15,7 +15,7 @@ export { TacExplorerClient } from './sdk/TacExplorerClient';
 export { TacSdk } from './sdk/TacSdk';
 export { TACTransactionManager } from './sdk/TACTransactionManager';
 export { TONTransactionManager } from './sdk/TONTransactionManager';
-export * from './sdk/TxFinalizer';
+export { TonTxFinalizer } from './sdk/TxFinalizer';
 export * from './sender';
 export * from './structs/Struct';
 export * from './wrappers/ContentUtils';

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.TacExplorerClient = exports.Simulator = exports.OperationTracker = exports.NoopLogger = exports.ConsoleLogger = exports.LiteSequencerClient = exports.Configuration = exports.AxiosHttpClient = exports.AgnosticStructs = exports.AgnosticProxySDK = void 0;
+exports.TonTxFinalizer = exports.TONTransactionManager = exports.TACTransactionManager = exports.TacSdk = exports.TacExplorerClient = 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; } });
@@ -66,7 +66,8 @@ var TACTransactionManager_1 = require("./sdk/TACTransactionManager");
 Object.defineProperty(exports, "TACTransactionManager", { enumerable: true, get: function () { return TACTransactionManager_1.TACTransactionManager; } });
 var TONTransactionManager_1 = require("./sdk/TONTransactionManager");
 Object.defineProperty(exports, "TONTransactionManager", { enumerable: true, get: function () { return TONTransactionManager_1.TONTransactionManager; } });
-__exportStar(require("./sdk/TxFinalizer"), exports);
+var TxFinalizer_1 = require("./sdk/TxFinalizer");
+Object.defineProperty(exports, "TonTxFinalizer", { enumerable: true, get: function () { return TxFinalizer_1.TonTxFinalizer; } });
 __exportStar(require("./sender"), exports);
 __exportStar(require("./structs/Struct"), exports);
 __exportStar(require("./wrappers/ContentUtils"), exports);

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

@@ -1,7 +1,6 @@
 import { SandboxContract } from '@ton/sandbox';
 import type { Address, Contract, OpenedContract, Transaction } from '@ton/ton';
-import { AddressInformation, GetTransactionsOptions } from '../structs/InternalStruct';
-import { ContractState } from '../structs/Struct';
+import { AddressInformation, ContractState, GetTransactionsOptions, TrackTransactionTreeParams, TrackTransactionTreeResult } from '../structs/Struct';
 export interface ContractOpener {
     /**
      * Opens a contract for interaction using the underlying client (lite client, sandbox, etc.).
@@ -19,8 +18,76 @@ export interface ContractOpener {
      * Closes any underlying connections if supported by the implementation.
      */
     closeConnections?: () => unknown;
+    /**
+     * Fetches transactions for a given address.
+     * @param address Address to fetch transactions for.
+     * @param opts Options for fetching transactions (limit, archival, etc.).
+     * @returns Promise with array of transactions.
+     */
+    getTransactions(address: Address, opts: GetTransactionsOptions): Promise<Transaction[]>;
+    /**
+     * Find transaction by its hash.
+     * Searches by transaction hash, and also by incoming message hash (both external-in and internal).
+     * This is a universal method that checks all possible hash types.
+     * @param address Account address where to search
+     * @param hash Transaction or message hash in any format (base64, hex)
+     * @param opts Search options (limit, pagination, etc.)
+     * @returns Transaction if found, null otherwise
+     */
     getTransactionByHash(address: Address, hash: string, opts?: GetTransactionsOptions): Promise<Transaction | null>;
+    /**
+     * Find transaction by its transaction hash only.
+     * More efficient than getTransactionByHash if you know it's a transaction hash.
+     * @param address Account address where to search
+     * @param txHash Transaction hash in any format (base64, hex)
+     * @param opts Search options
+     * @returns Transaction if found, null otherwise
+     */
+    getTransactionByTxHash(address: Address, txHash: string, opts?: GetTransactionsOptions): Promise<Transaction | null>;
+    /**
+     * Find transaction by its incoming message hash.
+     * Useful for finding the transaction that processed a specific message.
+     * @param address Account address where to search
+     * @param msgHash Message hash in any format (base64, hex)
+     * @param opts Search options
+     * @returns Transaction if found, null otherwise
+     */
+    getTransactionByInMsgHash(address: Address, msgHash: string, opts?: GetTransactionsOptions): Promise<Transaction | null>;
+    /**
+     * Find transaction by its outgoing message hash.
+     * Useful for finding the parent transaction that sent a specific message.
+     * @param address Account address where to search
+     * @param msgHash Outgoing message hash in any format (base64, hex)
+     * @param opts Search options
+     * @returns Transaction if found, null otherwise
+     */
+    getTransactionByOutMsgHash(address: Address, msgHash: string, opts?: GetTransactionsOptions): Promise<Transaction | null>;
+    /**
+     * Get adjacent transactions (children via outgoing messages and parent via incoming message).
+     * @param address Account address
+     * @param hash Transaction or message hash in any format (base64, hex)
+     * @param opts Search options
+     * @returns Array of adjacent transactions
+     */
     getAdjacentTransactions(address: Address, hash: string, opts?: GetTransactionsOptions): Promise<Transaction[]>;
     getAddressInformation(address: Address): Promise<AddressInformation>;
     getConfig(): Promise<string>;
+    /**
+     * Track and validate entire transaction tree starting from a root transaction.
+     * Recursively follows outgoing messages and validates all child transactions.
+     * @param address Root account address
+     * @param hash Root transaction or message hash
+     * @param params Tracking parameters (maxDepth, ignoreOpcodeList, etc.)
+     * @throws Error if any transaction in the tree failed
+     */
+    trackTransactionTree(address: string, hash: string, params?: TrackTransactionTreeParams): Promise<void>;
+    /**
+     * Track and validate entire transaction tree starting from a root transaction (returns result instead of throwing).
+     * Recursively follows outgoing messages and validates all child transactions.
+     * @param address Root account address
+     * @param hash Root transaction or message hash
+     * @param params Tracking parameters (maxDepth, ignoreOpcodeList, etc.)
+     * @returns Result object with success flag and error details if validation failed
+     */
+    trackTransactionTreeWithResult(address: string, hash: string, params?: TrackTransactionTreeParams): Promise<TrackTransactionTreeResult>;
 }

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

@@ -4,6 +4,7 @@ import { FT, NFT } from '../assets';
 import type { SenderAbstraction } from '../sender';
 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 { ContractOpener } from './ContractOpener';
 import { IConfiguration } from './IConfiguration';
 import { IOperationTracker } from './IOperationTracker';
 import { ITacExplorerClient } from './ITacExplorerClient';
@@ -187,6 +188,10 @@ export interface ITacSDK {
      * Returns the TAC explorer client instance used for querying blockchain explorer data.
      */
     getTacExplorerClient(): ITacExplorerClient;
+    /**
+     * Returns the TON contract opener client instance used for querying TON blockchain data.
+     */
+    getTonContractOpener(): ContractOpener;
     /**
      * Prepares the transaction payloads required for a cross-chain operation without sending them.
      * @param evmProxyMsg Encoded EVM proxy message.

package/dist/src/sdk/Configuration.js

@@ -52,7 +52,7 @@ class Configuration {
         else {
             contractOpener =
                 TONParams?.contractOpener ??
-                    (await (0, adapters_1.createDefaultRetryableOpener)(artifacts.TON_RPC_ENDPOINT_BY_TAC, network, 5, delay));
+                    (await (0, adapters_1.createDefaultRetryableOpener)(artifacts.TON_RPC_ENDPOINT_BY_TAC, network, 5, delay, logger));
             settingsAddress = TONParams?.settingsAddress ?? artifacts.TON_SETTINGS_ADDRESS;
         }
         const settings = contractOpener.open(artifacts.ton.wrappers.Settings.createFromAddress(ton_1.Address.parse(settingsAddress)));

package/dist/src/sdk/Consts.d.ts

@@ -15,9 +15,12 @@ export declare const TON_DECIMALS = 9;
 export declare const TAC_DECIMALS = 18;
 export declare const FIVE_MINUTES: number;
 export declare const TON_BURN_ADDRESS = "EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c";
-export declare const DEFAULT_FIND_TX_TIMEOUT_MS = 60000;
-export declare const DEFAULT_FIND_TX_RETRY_DELAY_MS = 2000;
+export declare const DEFAULT_HTTP_CLIENT_TIMEOUT_MS = 30000;
+export declare const DEFAULT_FIND_TX_TIMEOUT_MS = 180000;
+export declare const DEFAULT_RETRY_MAX_COUNT = 5;
+export declare const DEFAULT_RETRY_DELAY_MS = 1000;
 export declare const DEFAULT_FIND_TX_LIMIT = 10;
 export declare const DEFAULT_FIND_TX_ARCHIVAL = true;
 export declare const DEFAULT_FIND_TX_MAX_DEPTH = 10;
 export declare const IGNORE_MSG_VALUE_1_NANO = 1n;
+export declare const IGNORE_OPCODE: number[];

package/dist/src/sdk/Consts.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IGNORE_MSG_VALUE_1_NANO = exports.DEFAULT_FIND_TX_MAX_DEPTH = exports.DEFAULT_FIND_TX_ARCHIVAL = exports.DEFAULT_FIND_TX_LIMIT = exports.DEFAULT_FIND_TX_RETRY_DELAY_MS = exports.DEFAULT_FIND_TX_TIMEOUT_MS = exports.TON_BURN_ADDRESS = exports.FIVE_MINUTES = exports.TAC_DECIMALS = exports.TON_DECIMALS = exports.ONE_YEAR_SECONDS = exports.FIFTEEN_MINUTES = exports.TAC_SYMBOL = exports.TON_SYMBOL = exports.MAX_MSG_DEPTH = exports.MAX_HIGHLOAD_GROUP_MSG_NUM = exports.MAX_EXT_MSG_SIZE = exports.SOLIDITY_METHOD_NAME_REGEX = exports.SOLIDITY_SIGNATURE_REGEX = exports.DEFAULT_DELAY = exports.MAX_ITERATION_COUNT = exports.NFT_TRANSFER_FORWARD_TON_AMOUNT = exports.JETTON_TRANSFER_FORWARD_TON_AMOUNT = void 0;
+exports.IGNORE_OPCODE = exports.IGNORE_MSG_VALUE_1_NANO = exports.DEFAULT_FIND_TX_MAX_DEPTH = exports.DEFAULT_FIND_TX_ARCHIVAL = exports.DEFAULT_FIND_TX_LIMIT = exports.DEFAULT_RETRY_DELAY_MS = exports.DEFAULT_RETRY_MAX_COUNT = exports.DEFAULT_FIND_TX_TIMEOUT_MS = exports.DEFAULT_HTTP_CLIENT_TIMEOUT_MS = exports.TON_BURN_ADDRESS = exports.FIVE_MINUTES = exports.TAC_DECIMALS = exports.TON_DECIMALS = exports.ONE_YEAR_SECONDS = exports.FIFTEEN_MINUTES = exports.TAC_SYMBOL = exports.TON_SYMBOL = exports.MAX_MSG_DEPTH = exports.MAX_HIGHLOAD_GROUP_MSG_NUM = exports.MAX_EXT_MSG_SIZE = exports.SOLIDITY_METHOD_NAME_REGEX = exports.SOLIDITY_SIGNATURE_REGEX = exports.DEFAULT_DELAY = exports.MAX_ITERATION_COUNT = exports.NFT_TRANSFER_FORWARD_TON_AMOUNT = exports.JETTON_TRANSFER_FORWARD_TON_AMOUNT = void 0;
 const ton_1 = require("@ton/ton");
 exports.JETTON_TRANSFER_FORWARD_TON_AMOUNT = (0, ton_1.toNano)(0.2);
 exports.NFT_TRANSFER_FORWARD_TON_AMOUNT = (0, ton_1.toNano)(0.3);
@@ -19,10 +19,14 @@ exports.TON_DECIMALS = 9;
 exports.TAC_DECIMALS = 18;
 exports.FIVE_MINUTES = 5 * 60 * 1000;
 exports.TON_BURN_ADDRESS = 'EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c';
-// TX TRACKING
-exports.DEFAULT_FIND_TX_TIMEOUT_MS = 60000;
-exports.DEFAULT_FIND_TX_RETRY_DELAY_MS = 2000;
+exports.DEFAULT_HTTP_CLIENT_TIMEOUT_MS = 30000;
+exports.DEFAULT_FIND_TX_TIMEOUT_MS = 180000;
+exports.DEFAULT_RETRY_MAX_COUNT = 5;
+exports.DEFAULT_RETRY_DELAY_MS = 1000;
 exports.DEFAULT_FIND_TX_LIMIT = 10;
 exports.DEFAULT_FIND_TX_ARCHIVAL = true;
 exports.DEFAULT_FIND_TX_MAX_DEPTH = 10;
 exports.IGNORE_MSG_VALUE_1_NANO = 1n;
+exports.IGNORE_OPCODE = [
+    0xd53276db, // Excess
+];

package/dist/src/sdk/StartTracking.d.ts

@@ -1,5 +1,4 @@
-import { ILogger } from '../interfaces';
-import { ITxFinalizer } from '../interfaces/ITxFinalizer';
+import { ContractOpener, ILogger } from '../interfaces';
 import { ExecutionStages, Network, TransactionLinker } from '../structs/Struct';
 export declare function startTracking(transactionLinker: TransactionLinker, network: Network, options?: {
     customLiteSequencerEndpoints?: string[];
@@ -8,7 +7,7 @@ export declare function startTracking(transactionLinker: TransactionLinker, netw
     returnValue?: boolean;
     tableView?: boolean;
     logger?: ILogger;
-    txFinalizer?: ITxFinalizer;
+    contractOpener?: ContractOpener;
     cclAddress?: string;
 }): Promise<void | ExecutionStages>;
 export declare function startTrackingMultiple(transactionLinkers: TransactionLinker[], network: Network, options?: {
@@ -18,6 +17,6 @@ export declare function startTrackingMultiple(transactionLinkers: TransactionLin
     returnValue?: boolean;
     tableView?: boolean;
     logger?: ILogger;
-    txFinalizer?: ITxFinalizer;
+    contractOpener?: ContractOpener;
 }): Promise<void | ExecutionStages[]>;
 export declare function printExecutionStagesTable(stages: ExecutionStages, logger: ILogger): void;