@tonappchain/sdk 0.7.2-scaled-ui-support-2 → 0.7.2

package/dist/artifacts/testnet/ton/internal/wrappers/NFTProxy.d.ts

@@ -1,4 +1,5 @@
 import { Address, Cell, Contract, ContractProvider, Sender } from '@ton/core';
+import { StorageStats } from './utils/GasUtils';
 export declare const NFTItemTransferOperation = 2332633442;
 export declare const NFTProxyOpCodes: {
     admin_changeAdmin: number;
@@ -32,6 +33,12 @@ export declare class NFTProxy implements Contract {
         code: Cell;
         data: Cell;
     } | undefined;
+    static estimatedNftItemCells: bigint;
+    static estimatedNftItemBits: bigint;
+    static storageStats: StorageStats;
+    static ownershipAssignedGasConsumption: bigint;
+    static errorNotificationGasConsumption: bigint;
+    static msgToTvmGasConsumption: bigint;
     constructor(address: Address, init?: {
         code: Cell;
         data: Cell;

package/dist/artifacts/testnet/ton/internal/wrappers/NFTProxy.js

@@ -4,10 +4,11 @@ exports.NFTProxy = exports.NFTProxyErrors = exports.NFTProxyOpCodes = exports.NF
 exports.nftProxyConfigToCell = nftProxyConfigToCell;
 const core_1 = require("@ton/core");
 const Constants_1 = require("./Constants");
+const GasUtils_1 = require("./utils/GasUtils");
 exports.NFTItemTransferOperation = 0x8b092962;
 exports.NFTProxyOpCodes = {
     admin_changeAdmin: 0x581879bc,
-    admin_updateCode: 0x20faec53,
+    admin_updateCode: 0x6e7145f9,
     ccl_evmMsgToTVMProxy: 0x7817b330,
     ccl_errorNotification: 0xae7df95b,
     ccl_tvmMsgToEVM: 0x6c582059,
@@ -155,3 +156,9 @@ class NFTProxy {
     }
 }
 exports.NFTProxy = NFTProxy;
+NFTProxy.estimatedNftItemCells = 25n;
+NFTProxy.estimatedNftItemBits = 9877n;
+NFTProxy.storageStats = new GasUtils_1.StorageStats(7512n, 15n);
+NFTProxy.ownershipAssignedGasConsumption = 7688n;
+NFTProxy.errorNotificationGasConsumption = 4737n;
+NFTProxy.msgToTvmGasConsumption = 5348n;

package/dist/artifacts/testnet/ton/internal/wrappers/Settings.d.ts

@@ -52,6 +52,7 @@ export declare class Settings implements Contract {
         data: Cell;
     } | undefined;
     readonly configuration?: SettingsConfig | undefined;
+    static storageStats: StorageStats;
     constructor(address: Address, init?: {
         code: Cell;
         data: Cell;

package/dist/artifacts/testnet/ton/internal/wrappers/Settings.js

@@ -148,5 +148,6 @@ class Settings {
     }
 }
 exports.Settings = Settings;
+Settings.storageStats = new GasUtils_1.StorageStats(38743n, 118n);
 Settings.minStorageDuration = 10 * 365 * 24 * 3600; // 10 years
 Settings.minStorageStats = new GasUtils_1.StorageStats(29557n, 104n);

package/dist/artifacts/testnet/ton/internal/wrappers/utils/CrossChainLayerPayload.d.ts

@@ -0,0 +1,10 @@
+import { Address, Cell } from '@ton/core';
+export type CrossChainLayerPayload = {
+    operationId: bigint;
+    destinationAddress: Address;
+    destinationMsgValue: bigint;
+    payload: Cell;
+    maybeStateInit?: Cell;
+};
+export declare function CrossChainLayerPayloadToCell(payload: CrossChainLayerPayload): Cell;
+export declare function CrossChainLayerPayloadFromCell(cell: Cell): CrossChainLayerPayload;

package/dist/artifacts/testnet/ton/internal/wrappers/utils/CrossChainLayerPayload.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrossChainLayerPayloadToCell = CrossChainLayerPayloadToCell;
+exports.CrossChainLayerPayloadFromCell = CrossChainLayerPayloadFromCell;
+const core_1 = require("@ton/core");
+function CrossChainLayerPayloadToCell(payload) {
+    return (0, core_1.beginCell)()
+        .storeUint(payload.operationId, 256)
+        .storeAddress(payload.destinationAddress)
+        .storeCoins(payload.destinationMsgValue)
+        .storeRef(payload.payload)
+        .storeMaybeRef(payload.maybeStateInit)
+        .endCell();
+}
+function CrossChainLayerPayloadFromCell(cell) {
+    const slice = cell.beginParse();
+    return {
+        operationId: slice.loadUintBig(256),
+        destinationAddress: slice.loadAddress(),
+        destinationMsgValue: slice.loadCoins(),
+        payload: slice.loadRef(),
+        maybeStateInit: slice.loadMaybeRef() ?? undefined,
+    };
+}

package/dist/artifacts/testnet/ton/internal/wrappers/utils/MerkleRoots.d.ts

@@ -4,4 +4,5 @@ export type MerkleRoot = {
     validTimestamp: number;
 };
 export declare function cellToArray(addrDict: Cell | null): Array<MerkleRoot>;
-export declare function arrayToCell(arr: Array<MerkleRoot>): Dictionary<bigint, number>;
+export declare function arrayToDict(arr: Array<MerkleRoot>): Dictionary<bigint, number>;
+export declare function arrayToCell(arr: Array<MerkleRoot>): Cell;

package/dist/artifacts/testnet/ton/internal/wrappers/utils/MerkleRoots.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cellToArray = cellToArray;
+exports.arrayToDict = arrayToDict;
 exports.arrayToCell = arrayToCell;
 const core_1 = require("@ton/core");
 const Constants_1 = require("../Constants");
@@ -18,10 +19,17 @@ function cellToArray(addrDict) {
     }
     return resArr;
 }
-function arrayToCell(arr) {
+function arrayToDict(arr) {
     let dict = core_1.Dictionary.empty(core_1.Dictionary.Keys.BigUint(Constants_1.Params.bitsize.hash), core_1.Dictionary.Values.Uint(Constants_1.Params.bitsize.time));
     for (let i = 0; i < arr.length; i++) {
         dict.set(arr[i].root, arr[i].validTimestamp);
     }
     return dict;
 }
+function arrayToCell(arr) {
+    let dict = core_1.Dictionary.empty(core_1.Dictionary.Keys.BigUint(Constants_1.Params.bitsize.hash), core_1.Dictionary.Values.Uint(Constants_1.Params.bitsize.time));
+    for (let i = 0; i < arr.length; i++) {
+        dict.set(arr[i].root, arr[i].validTimestamp);
+    }
+    return (0, core_1.beginCell)().storeDictDirect(dict).endCell();
+}

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

@@ -0,0 +1,76 @@
+import { SandboxContract } from '@ton/sandbox';
+import { Address, Contract, OpenedContract, Transaction } from '@ton/ton';
+import { ContractOpener, ILogger } from '../interfaces';
+import { AddressInformation, GetTransactionsOptions } from '../structs/Struct';
+import { ContractState, TrackTransactionTreeParams, TrackTransactionTreeResult } from '../structs/Struct';
+/**
+ * Base class for ContractOpener implementations with common functionality
+ */
+export declare abstract class BaseContractOpener implements ContractOpener {
+    protected logger?: ILogger;
+    protected constructor(logger?: ILogger);
+    setLogger(logger: ILogger): void;
+    abstract open<T extends Contract>(contract: T): OpenedContract<T> | SandboxContract<T>;
+    abstract getContractState(address: Address): Promise<ContractState>;
+    abstract getTransactions(address: Address, opts: GetTransactionsOptions): Promise<Transaction[]>;
+    abstract getAddressInformation(address: Address): Promise<AddressInformation>;
+    abstract getConfig(): Promise<string>;
+    closeConnections?(): void;
+    /**
+     * Common pagination logic for scanning transaction history
+     * @param addr Account address
+     * @param opts Search options
+     * @param predicate Function to check if transaction matches search criteria
+     * @returns Found transaction or null
+     */
+    private scanTransactionHistory;
+    /**
+     * Find transaction by hash with pagination through account history
+     * @param addr Account address
+     * @param hash Transaction hash in any format (base64, hex)
+     * @param opts Search options
+     */
+    getTransactionByHash(addr: Address, hash: string, opts?: GetTransactionsOptions): Promise<Transaction | null>;
+    /**
+     * Find transaction by its transaction hash only.
+     * More efficient than getTransactionByHash when you know it's a transaction hash.
+     */
+    getTransactionByTxHash(addr: 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.
+     */
+    getTransactionByInMsgHash(addr: 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.
+     */
+    getTransactionByOutMsgHash(addr: Address, msgHash: string, opts?: GetTransactionsOptions): Promise<Transaction | null>;
+    /**
+     * Get adjacent transactions (children and parent)
+     * @param addr Account address
+     * @param hash Transaction hash in any format (base64, hex)
+     * @param opts Search options
+     */
+    getAdjacentTransactions(addr: Address, hash: string, opts?: GetTransactionsOptions): Promise<Transaction[]>;
+    /**
+     * Validate transaction phases and return error details
+     */
+    private validateTransactionWithResult;
+    /**
+     * Find transaction by hash type
+     */
+    private findTransactionByHashType;
+    /**
+     * Find transaction with retry logic
+     */
+    private findTransactionWithRetry;
+    /**
+     * Track transaction tree and validate all transactions
+     */
+    trackTransactionTree(address: string, hash: string, params?: TrackTransactionTreeParams): Promise<void>;
+    /**
+     * Track transaction tree and validate all transactions (returns result instead of throwing)
+     */
+    trackTransactionTreeWithResult(address: string, hash: string, params?: TrackTransactionTreeParams): Promise<TrackTransactionTreeResult>;
+}

package/dist/src/adapters/BaseContractOpener.js

@@ -0,0 +1,440 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseContractOpener = void 0;
+const ton_1 = require("@ton/ton");
+const errors_1 = require("../errors");
+const Consts_1 = require("../sdk/Consts");
+const Utils_1 = require("../sdk/Utils");
+/**
+ * Base class for ContractOpener implementations with common functionality
+ */
+class BaseContractOpener {
+    constructor(logger) {
+        this.logger = logger;
+    }
+    setLogger(logger) {
+        if (!this.logger) {
+            this.logger = logger;
+        }
+    }
+    /**
+     * Common pagination logic for scanning transaction history
+     * @param addr Account address
+     * @param opts Search options
+     * @param predicate Function to check if transaction matches search criteria
+     * @returns Found transaction or null
+     */
+    async scanTransactionHistory(addr, opts, predicate) {
+        const limit = opts?.limit ?? Consts_1.DEFAULT_FIND_TX_LIMIT;
+        const inclusive = opts?.inclusive ?? true;
+        const toLt = opts?.to_lt ? BigInt(opts.to_lt) : undefined;
+        let currentLt = opts?.lt;
+        let currentHash = opts?.hash ? (0, Utils_1.normalizeHashToBase64)(opts.hash) : undefined;
+        const seenCursors = new Set();
+        let scannedTransactions = 0;
+        const maxScannedTransactions = opts?.maxScannedTransactions ?? Consts_1.DEFAULT_MAX_SCANNED_TRANSACTIONS;
+        while (true) {
+            const list = await this.getTransactions(addr, {
+                limit,
+                lt: currentLt,
+                hash: currentHash,
+                to_lt: opts?.to_lt,
+                inclusive,
+                archival: opts?.archival ?? Consts_1.DEFAULT_FIND_TX_ARCHIVAL,
+                timeoutMs: opts?.timeoutMs,
+                retryDelayMs: opts?.retryDelayMs,
+            });
+            if (list.length === 0) {
+                break;
+            }
+            let startIndex = 0;
+            const firstTx = list[0];
+            const firstTxMatchesCursor = currentLt &&
+                currentHash &&
+                firstTx.lt.toString() === currentLt &&
+                firstTx.hash().toString('base64') === currentHash;
+            if (firstTxMatchesCursor) {
+                startIndex = 1;
+                if (list.length === 1) {
+                    if (firstTx.prevTransactionLt === 0n) {
+                        break;
+                    }
+                    const nextLt = firstTx.prevTransactionLt.toString();
+                    const nextHash = Buffer.from(firstTx.prevTransactionHash.toString(16).padStart(64, '0'), 'hex').toString('base64');
+                    if (currentLt && BigInt(nextLt) >= BigInt(currentLt)) {
+                        break;
+                    }
+                    const cursorKey = `${nextLt}:${nextHash}`;
+                    if (seenCursors.has(cursorKey)) {
+                        break;
+                    }
+                    seenCursors.add(cursorKey);
+                    currentLt = nextLt;
+                    currentHash = nextHash;
+                    continue;
+                }
+            }
+            for (let i = startIndex; i < list.length; i++) {
+                const tx = list[i];
+                scannedTransactions += 1;
+                if (scannedTransactions > maxScannedTransactions) {
+                    this.logger?.debug(`Scan limit reached (${maxScannedTransactions} transactions), stopping history scan`);
+                    return null;
+                }
+                if (predicate(tx)) {
+                    return tx;
+                }
+            }
+            const oldestTx = list[list.length - 1];
+            if (oldestTx.prevTransactionLt === 0n)
+                break;
+            if (toLt !== undefined) {
+                if (inclusive ? oldestTx.lt <= toLt : oldestTx.lt < toLt)
+                    break;
+            }
+            const nextLt = oldestTx.lt.toString();
+            const nextHash = oldestTx.hash().toString('base64');
+            if (currentLt && BigInt(nextLt) >= BigInt(currentLt)) {
+                break;
+            }
+            const cursorKey = `${nextLt}:${nextHash}`;
+            if (seenCursors.has(cursorKey)) {
+                break;
+            }
+            seenCursors.add(cursorKey);
+            currentLt = nextLt;
+            currentHash = nextHash;
+        }
+        return null;
+    }
+    /**
+     * Find transaction by hash with pagination through account history
+     * @param addr Account address
+     * @param hash Transaction hash in any format (base64, hex)
+     * @param opts Search options
+     */
+    async getTransactionByHash(addr, hash, opts) {
+        const targetHashB64 = (0, Utils_1.normalizeHashToBase64)(hash);
+        return this.scanTransactionHistory(addr, opts, (tx) => {
+            // 1. check tx itself
+            if (tx.hash().toString('base64') === targetHashB64) {
+                return true;
+            }
+            // 2. check incoming message(external-in)
+            if (tx.inMessage && tx.inMessage.info.type === 'external-in') {
+                const msgHash = (0, Utils_1.getNormalizedExtMessageHash)(tx.inMessage);
+                if (msgHash === targetHashB64) {
+                    return true;
+                }
+                const rawMsgHash = (0, ton_1.beginCell)().store((0, ton_1.storeMessage)(tx.inMessage)).endCell().hash().toString('base64');
+                if (rawMsgHash === targetHashB64) {
+                    return true;
+                }
+            }
+            // 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 msgHash = messageCell.hash();
+                if (msgHash.toString('base64') === targetHashB64) {
+                    return true;
+                }
+            }
+            // 4. check outcoming message
+            for (const outMsg of tx.outMessages.values()) {
+                const messageCell = (0, ton_1.beginCell)().store((0, ton_1.storeMessage)(outMsg)).endCell();
+                const hash = messageCell.hash();
+                if (hash.toString('base64') === targetHashB64) {
+                    return true;
+                }
+            }
+            return false;
+        });
+    }
+    /**
+     * Find transaction by its transaction hash only.
+     * More efficient than getTransactionByHash when you know it's a transaction hash.
+     */
+    async getTransactionByTxHash(addr, txHash, opts) {
+        const targetHashB64 = (0, Utils_1.normalizeHashToBase64)(txHash);
+        return this.scanTransactionHistory(addr, opts, (tx) => {
+            return tx.hash().toString('base64') === targetHashB64;
+        });
+    }
+    /**
+     * Find transaction by its incoming message hash.
+     * Useful for finding the transaction that processed a specific message.
+     */
+    async getTransactionByInMsgHash(addr, msgHash, opts) {
+        const targetHashB64 = (0, Utils_1.normalizeHashToBase64)(msgHash);
+        return this.scanTransactionHistory(addr, opts, (tx) => {
+            // Check incoming message(external-in) - uses normalized hash
+            if (tx.inMessage && tx.inMessage.info.type === 'external-in') {
+                const hash = (0, Utils_1.getNormalizedExtMessageHash)(tx.inMessage);
+                if (hash === targetHashB64) {
+                    return true;
+                }
+                const rawHash = (0, ton_1.beginCell)().store((0, ton_1.storeMessage)(tx.inMessage)).endCell().hash().toString('base64');
+                if (rawHash === targetHashB64) {
+                    return true;
+                }
+            }
+            // Check incoming message(internal) - uses full message cell hash
+            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 true;
+                }
+            }
+            return false;
+        });
+    }
+    /**
+     * Find transaction by its outgoing message hash.
+     * Useful for finding the parent transaction that sent a specific message.
+     */
+    async getTransactionByOutMsgHash(addr, msgHash, opts) {
+        const targetHashB64 = (0, Utils_1.normalizeHashToBase64)(msgHash);
+        return this.scanTransactionHistory(addr, opts, (tx) => {
+            for (const outMsg of tx.outMessages.values()) {
+                const messageCell = (0, ton_1.beginCell)().store((0, ton_1.storeMessage)(outMsg)).endCell();
+                const hash = messageCell.hash();
+                if (hash.toString('base64') === targetHashB64) {
+                    return true;
+                }
+            }
+            return false;
+        });
+    }
+    /**
+     * Get adjacent transactions (children and parent)
+     * @param addr Account address
+     * @param hash Transaction hash in any format (base64, hex)
+     * @param opts Search options
+     */
+    async getAdjacentTransactions(addr, hash, opts) {
+        // 1. Find the root transaction (hash will be normalized inside getTransactionByHash)
+        const rootTx = await this.getTransactionByHash(addr, hash, opts);
+        if (!rootTx)
+            return [];
+        const adjacent = [];
+        // 2. Follow every outgoing message to find child transactions
+        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');
+            // The outgoing message becomes an incoming message at the destination
+            const tx = await this.getTransactionByInMsgHash(dst, msgHashB64, opts);
+            if (tx)
+                adjacent.push(tx);
+        }
+        // 3. Optional: follow the incoming message to find parent transaction
+        if (rootTx.inMessage?.info.type === 'internal') {
+            const msgHashB64 = (0, ton_1.beginCell)().store((0, ton_1.storeMessage)(rootTx.inMessage)).endCell().hash().toString('base64');
+            // The incoming message was an outgoing message at the source
+            const tx = await this.getTransactionByOutMsgHash(rootTx.inMessage.info.src, msgHashB64, opts);
+            if (tx)
+                adjacent.push(tx);
+        }
+        return adjacent;
+    }
+    /**
+     * Validate transaction phases and return error details
+     */
+    validateTransactionWithResult(tx, ignoreOpcodeList) {
+        if (tx.description.type !== 'generic')
+            return null;
+        const { aborted, computePhase, actionPhase } = tx.description;
+        const txHash = tx.hash().toString('base64');
+        const exitCode = computePhase && computePhase.type !== 'skipped' ? computePhase.exitCode : 'N/A';
+        const resultCode = actionPhase ? actionPhase.resultCode : 'N/A';
+        if (aborted) {
+            return { txHash, exitCode, resultCode, reason: 'aborted' };
+        }
+        if (!computePhase) {
+            return { txHash, exitCode, resultCode, reason: 'compute_phase_missing' };
+        }
+        if (computePhase.type !== 'skipped' && (!computePhase.success || computePhase.exitCode !== 0)) {
+            return { txHash, exitCode, resultCode, reason: 'compute_phase_failed' };
+        }
+        if (actionPhase && (!actionPhase.success || actionPhase.resultCode !== 0)) {
+            return { txHash, exitCode, resultCode, reason: 'action_phase_failed' };
+        }
+        if (!tx.inMessage)
+            return null;
+        // Log optional skip hints (does not bypass phase validation)
+        if (tx.inMessage.info.type === 'internal' && tx.inMessage.info.value.coins === Consts_1.IGNORE_MSG_VALUE_1_NANO) {
+            this.logger?.debug(`Skipping extra checks for tx: ${txHash} (1 nano message)`);
+            return null;
+        }
+        const bodySlice = tx.inMessage.body.beginParse();
+        if (bodySlice.remainingBits >= 32) {
+            const opcode = bodySlice.loadUint(32);
+            if (ignoreOpcodeList.includes(opcode)) {
+                this.logger?.debug(`Skipping extra checks for tx: ${txHash} (opcode in ignore list)`);
+            }
+        }
+        return null;
+    }
+    /**
+     * Find transaction by hash type
+     */
+    async findTransactionByHashType(address, hash, hashType, opts) {
+        const searchOpts = { archival: true, ...opts };
+        if (hashType === 'in') {
+            return this.getTransactionByInMsgHash(address, hash, searchOpts);
+        }
+        else if (hashType === 'out') {
+            return this.getTransactionByOutMsgHash(address, hash, searchOpts);
+        }
+        else {
+            return this.getTransactionByHash(address, hash, searchOpts);
+        }
+    }
+    /**
+     * Find transaction with retry logic
+     */
+    async findTransactionWithRetry(address, hash, hashType, opts, depth) {
+        const retryDelayMs = opts.retryDelayMs ?? Consts_1.DEFAULT_RETRY_ON_NOT_FOUND_DELAY_MS;
+        const maxRetries = opts.retries ?? Consts_1.DEFAULT_RETRY_ON_NOT_FOUND_RETRIES;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            let errorMsg;
+            try {
+                const tx = await this.findTransactionByHashType(address, hash, hashType, opts);
+                if (tx) {
+                    return tx;
+                }
+            }
+            catch (error) {
+                errorMsg = error instanceof Error ? error.message : String(error);
+            }
+            const isLastAttempt = attempt >= maxRetries;
+            const reason = errorMsg ?? 'not found';
+            const retryInfo = isLastAttempt ? '' : `, retrying in ${retryDelayMs}ms`;
+            this.logger?.debug(`Transaction not found at depth ${depth} (attempt ${attempt + 1}/${maxRetries + 1}): ${reason}${retryInfo}`);
+            if (isLastAttempt) {
+                return null;
+            }
+            await (0, Utils_1.sleep)(retryDelayMs);
+        }
+        return null;
+    }
+    /**
+     * Track transaction tree and validate all transactions
+     */
+    async trackTransactionTree(address, hash, params = {
+        maxDepth: Consts_1.DEFAULT_FIND_TX_MAX_DEPTH,
+        ignoreOpcodeList: Consts_1.IGNORE_OPCODE,
+        limit: Consts_1.DEFAULT_FIND_TX_LIMIT,
+        direction: 'both',
+        retryOnNotFound: Consts_1.DEFAULT_RETRY_ON_NOT_FOUND,
+    }) {
+        const result = await this.trackTransactionTreeWithResult(address, hash, params);
+        if (this.logger && typeof result.checkedCount === 'number') {
+            this.logger.debug(`Transaction tree checked: ${result.checkedCount} unique transaction(s)`);
+        }
+        if (!result.success && result.error) {
+            const { txHash, exitCode, resultCode, reason, address: errorAddress, hashType } = result.error;
+            const context = reason === 'not_found' ? ` address=${errorAddress ?? 'unknown'} hashType=${hashType ?? 'unknown'}` : '';
+            const message = `${txHash}: reason=${reason} (exitCode=${exitCode}, resultCode=${resultCode})${context}`;
+            if (reason === 'not_found') {
+                throw new Error(message);
+            }
+            else {
+                throw (0, errors_1.txFinalizationError)(message);
+            }
+        }
+    }
+    /**
+     * Track transaction tree and validate all transactions (returns result instead of throwing)
+     */
+    async trackTransactionTreeWithResult(address, hash, params = {
+        maxDepth: Consts_1.DEFAULT_FIND_TX_MAX_DEPTH,
+        ignoreOpcodeList: Consts_1.IGNORE_OPCODE,
+        limit: Consts_1.DEFAULT_FIND_TX_LIMIT,
+        direction: 'both',
+        retryOnNotFound: Consts_1.DEFAULT_RETRY_ON_NOT_FOUND,
+    }) {
+        const { maxDepth = Consts_1.DEFAULT_FIND_TX_MAX_DEPTH, ignoreOpcodeList = Consts_1.IGNORE_OPCODE, limit = Consts_1.DEFAULT_FIND_TX_LIMIT, maxScannedTransactions = Consts_1.DEFAULT_MAX_SCANNED_TRANSACTIONS, direction = 'both', retryOnNotFound = Consts_1.DEFAULT_RETRY_ON_NOT_FOUND, retryDelayMs, retries, } = params;
+        const parsedAddress = ton_1.Address.parse(address);
+        const normalizedRootHash = (0, Utils_1.normalizeHashToBase64)(hash);
+        const visitedSearchKeys = new Set();
+        const processedTxHashes = new Set();
+        let checkedCount = 0;
+        const searchOpts = {
+            limit,
+            archival: true,
+            maxScannedTransactions,
+            retryDelayMs,
+            retries,
+        };
+        const queue = [
+            { address: parsedAddress, hash: normalizedRootHash, depth: 0, hashType: 'unknown' },
+        ];
+        while (queue.length > 0) {
+            const { hash: currentHash, depth: currentDepth, address: currentAddress, hashType } = queue.shift();
+            const visitedKey = `${currentAddress.toString()}:${currentHash}:${hashType}`;
+            if (visitedSearchKeys.has(visitedKey))
+                continue;
+            visitedSearchKeys.add(visitedKey);
+            const tx = retryOnNotFound
+                ? await this.findTransactionWithRetry(currentAddress, currentHash, hashType, searchOpts, currentDepth)
+                : await this.findTransactionByHashType(currentAddress, currentHash, hashType, searchOpts);
+            if (!tx) {
+                this.logger?.debug(`Transaction not found for hash: ${currentHash} (address=${currentAddress?.toString()}, hashType=${hashType ?? 'unknown'})`);
+                return {
+                    success: false,
+                    checkedCount,
+                    error: {
+                        txHash: currentHash,
+                        exitCode: 'N/A',
+                        resultCode: 'N/A',
+                        reason: 'not_found',
+                        address: currentAddress?.toString(),
+                        hashType: hashType ?? 'unknown',
+                    },
+                };
+            }
+            const txHash = tx.hash().toString('base64');
+            if (processedTxHashes.has(txHash)) {
+                continue;
+            }
+            processedTxHashes.add(txHash);
+            checkedCount += 1;
+            this.logger?.debug(`Checking tx (depth ${currentDepth}): ${txHash}`);
+            // Validate transaction and return error if found
+            const validationError = this.validateTransactionWithResult(tx, ignoreOpcodeList);
+            if (validationError) {
+                return { success: false, checkedCount, error: validationError };
+            }
+            // Add adjacent transactions to queue
+            if (currentDepth < maxDepth) {
+                if ((direction === 'forward' || direction === 'both') && tx.outMessages.size > 0) {
+                    for (const msg of tx.outMessages.values()) {
+                        const dst = msg.info.dest;
+                        if (!dst || dst instanceof ton_1.ExternalAddress)
+                            continue;
+                        queue.push({
+                            hash: (0, ton_1.beginCell)().store((0, ton_1.storeMessage)(msg)).endCell().hash().toString('base64'),
+                            address: dst,
+                            depth: currentDepth + 1,
+                            hashType: 'in',
+                        });
+                    }
+                }
+                // Backward: add parent (incoming message source)
+                if ((direction === 'backward' || direction === 'both') && tx.inMessage?.info.type === 'internal') {
+                    queue.push({
+                        hash: (0, ton_1.beginCell)().store((0, ton_1.storeMessage)(tx.inMessage)).endCell().hash().toString('base64'),
+                        address: tx.inMessage.info.src,
+                        depth: currentDepth + 1,
+                        hashType: 'out',
+                    });
+                }
+            }
+        }
+        return { success: true, checkedCount };
+    }
+}
+exports.BaseContractOpener = BaseContractOpener;