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

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

@@ -9,6 +9,7 @@ import { ContractState, TrackTransactionTreeParams, TrackTransactionTreeResult }
 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[]>;
@@ -60,6 +61,10 @@ export declare abstract class BaseContractOpener implements ContractOpener {
      * Find transaction by hash type
      */
     private findTransactionByHashType;
+    /**
+     * Retry lookup for root transaction because it may appear in indexers with a delay.
+     */
+    private findRootTransactionWithRetry;
     /**
      * Track transaction tree and validate all transactions
      */

package/dist/src/adapters/BaseContractOpener.js

@@ -12,6 +12,11 @@ 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
@@ -21,28 +26,84 @@ class BaseContractOpener {
      */
     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;
+        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 batch = await this.getTransactions(addr, {
+            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 (batch.length === 0)
+            if (list.length === 0) {
                 break;
-            for (const tx of batch) {
+            }
+            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 = batch[batch.length - 1];
+            const oldestTx = list[list.length - 1];
             if (oldestTx.prevTransactionLt === 0n)
                 break;
-            currentLt = oldestTx.prevTransactionLt.toString();
-            const hashHex = oldestTx.prevTransactionHash.toString(16).padStart(64, '0');
-            currentHash = Buffer.from(hashHex, 'hex').toString('base64');
+            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;
     }
@@ -65,6 +126,10 @@ class BaseContractOpener {
                 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') {
@@ -74,6 +139,14 @@ class BaseContractOpener {
                     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;
         });
     }
@@ -100,6 +173,10 @@ class BaseContractOpener {
                 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') {
@@ -166,53 +243,98 @@ class BaseContractOpener {
      * Validate transaction phases and return error details
      */
     validateTransactionWithResult(tx, ignoreOpcodeList) {
-        if (tx.description.type !== 'generic' || !tx.inMessage)
-            return null;
-        // Skip validation for 1 nano messages
-        if (tx.inMessage.info.type === 'internal' && tx.inMessage.info.value.coins === Consts_1.IGNORE_MSG_VALUE_1_NANO) {
-            return null;
-        }
-        const bodySlice = tx.inMessage.body.beginParse();
-        if (bodySlice.remainingBits < 32)
+        if (tx.description.type !== 'generic')
             return null;
-        const opcode = bodySlice.loadUint(32);
-        if (ignoreOpcodeList.includes(opcode)) {
-            this.logger?.debug(`Skipping validation for tx: ${tx.hash().toString('base64')} (opcode in ignore list)`);
-            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) {
-            if (!computePhase || computePhase.type === 'skipped') {
-                return { txHash, exitCode, resultCode, reason: 'compute_phase_missing' };
-            }
-            if (!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' };
-            }
             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, limit) {
-        const opts = { limit, archival: true };
+    async findTransactionByHashType(address, hash, hashType, opts) {
+        const searchOpts = { archival: true, ...opts };
         if (hashType === 'in') {
-            return this.getTransactionByInMsgHash(address, hash, opts);
+            return this.getTransactionByInMsgHash(address, hash, searchOpts);
         }
         else if (hashType === 'out') {
-            return this.getTransactionByOutMsgHash(address, hash, opts);
+            return this.getTransactionByOutMsgHash(address, hash, searchOpts);
         }
         else {
-            return this.getTransactionByHash(address, hash, opts);
+            return this.getTransactionByHash(address, hash, searchOpts);
         }
     }
+    /**
+     * Retry lookup for root transaction because it may appear in indexers with a delay.
+     */
+    async findRootTransactionWithRetry(address, hash, hashType, limit, maxScannedTransactions, waitForRootTransaction) {
+        if (!waitForRootTransaction) {
+            return this.findTransactionByHashType(address, hash, hashType, {
+                limit,
+                archival: true,
+                maxScannedTransactions,
+            });
+        }
+        const attempts = Math.ceil(Consts_1.DEFAULT_WAIT_FOR_ROOT_TRANSACTION_TIMEOUT_MS / Consts_1.DEFAULT_WAIT_FOR_ROOT_TRANSACTION_RETRY_DELAY_MS);
+        const broadSearchOpts = { limit, archival: true, maxScannedTransactions };
+        const baselineInfo = await this.getAddressInformation(address);
+        let seenLt = baselineInfo.lastTransaction.lt || undefined;
+        // Capture baseline before first search.
+        const firstTx = await this.findTransactionByHashType(address, hash, hashType, broadSearchOpts);
+        if (firstTx) {
+            this.logger?.debug(`Root transaction found on attempt 1/${attempts}`);
+            return firstTx;
+        }
+        this.logger?.debug(`Root transaction not found yet (attempt 1/${attempts}), retrying in ${Consts_1.DEFAULT_WAIT_FOR_ROOT_TRANSACTION_RETRY_DELAY_MS}ms`);
+        await (0, Utils_1.sleep)(Consts_1.DEFAULT_WAIT_FOR_ROOT_TRANSACTION_RETRY_DELAY_MS);
+        for (let attempt = 2; attempt <= attempts; attempt++) {
+            const info = await this.getAddressInformation(address);
+            const currentLt = info.lastTransaction.lt || undefined;
+            if (!currentLt || currentLt === seenLt) {
+                this.logger?.debug(`Root transaction not found yet (attempt ${attempt}/${attempts}), lastTx unchanged, retrying in ${Consts_1.DEFAULT_WAIT_FOR_ROOT_TRANSACTION_RETRY_DELAY_MS}ms`);
+                await (0, Utils_1.sleep)(Consts_1.DEFAULT_WAIT_FOR_ROOT_TRANSACTION_RETRY_DELAY_MS);
+                continue;
+            }
+            seenLt = currentLt;
+            const tx = await this.findTransactionByHashType(address, hash, hashType, broadSearchOpts);
+            if (tx) {
+                this.logger?.debug(`Root transaction found on attempt ${attempt}/${attempts}`);
+                return tx;
+            }
+            this.logger?.debug(`Root transaction not found yet (attempt ${attempt}/${attempts}), retrying in ${Consts_1.DEFAULT_WAIT_FOR_ROOT_TRANSACTION_RETRY_DELAY_MS}ms`);
+            await (0, Utils_1.sleep)(Consts_1.DEFAULT_WAIT_FOR_ROOT_TRANSACTION_RETRY_DELAY_MS);
+        }
+        this.logger?.debug(`Root transaction not found after ${attempts} attempts`);
+        return null;
+    }
     /**
      * Track transaction tree and validate all transactions
      */
@@ -221,11 +343,18 @@ class BaseContractOpener {
         ignoreOpcodeList: Consts_1.IGNORE_OPCODE,
         limit: Consts_1.DEFAULT_FIND_TX_LIMIT,
         direction: 'both',
+        waitForRootTransaction: Consts_1.DEFAULT_WAIT_FOR_ROOT_TRANSACTION,
     }) {
         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 } = result.error;
-            throw (0, errors_1.txFinalizationError)(`${txHash}: reason= ${reason} (exitCode=${exitCode}, resultCode=${resultCode})`);
+            const { txHash, exitCode, resultCode, reason, address: errorAddress, hashType } = result.error;
+            const context = reason === 'not_found'
+                ? ` address=${errorAddress ?? 'unknown'} hashType=${hashType ?? 'unknown'}`
+                : '';
+            throw (0, errors_1.txFinalizationError)(`${txHash}: reason=${reason} (exitCode=${exitCode}, resultCode=${resultCode})${context}`);
         }
     }
     /**
@@ -236,29 +365,56 @@ class BaseContractOpener {
         ignoreOpcodeList: Consts_1.IGNORE_OPCODE,
         limit: Consts_1.DEFAULT_FIND_TX_LIMIT,
         direction: 'both',
+        waitForRootTransaction: Consts_1.DEFAULT_WAIT_FOR_ROOT_TRANSACTION,
     }) {
-        const { maxDepth = Consts_1.DEFAULT_FIND_TX_MAX_DEPTH, ignoreOpcodeList = Consts_1.IGNORE_OPCODE, limit = Consts_1.DEFAULT_FIND_TX_LIMIT, direction = 'both', } = params;
+        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', waitForRootTransaction = Consts_1.DEFAULT_WAIT_FOR_ROOT_TRANSACTION, } = params;
         const parsedAddress = ton_1.Address.parse(address);
-        const visitedHashes = new Set();
-        const queue = [{ address: parsedAddress, hash, depth: 0, hashType: 'unknown' }];
+        const normalizedRootHash = (0, Utils_1.normalizeHashToBase64)(hash);
+        const visitedSearchKeys = new Set();
+        const processedTxHashes = new Set();
+        let checkedCount = 0;
+        const searchOpts = { limit, archival: true, maxScannedTransactions };
+        const queue = [
+            { address: parsedAddress, hash: normalizedRootHash, depth: 0, hashType: 'unknown' },
+        ];
         while (queue.length > 0) {
             const { hash: currentHash, depth: currentDepth, address: currentAddress, hashType } = queue.shift();
-            if (visitedHashes.has(currentHash))
+            const visitedKey = `${currentAddress.toString()}:${currentHash}:${hashType}`;
+            if (visitedSearchKeys.has(visitedKey))
                 continue;
-            visitedHashes.add(currentHash);
-            this.logger?.debug(`Checking hash (depth ${currentDepth}): ${currentHash}`);
-            const tx = await this.findTransactionByHashType(currentAddress, currentHash, hashType, limit);
+            visitedSearchKeys.add(visitedKey);
+            const tx = currentDepth === 0
+                ? await this.findRootTransactionWithRetry(currentAddress, currentHash, hashType, limit, maxScannedTransactions, waitForRootTransaction)
+                : await this.findTransactionByHashType(currentAddress, currentHash, hashType, searchOpts);
             if (!tx) {
-                this.logger?.debug(`Transaction not found for hash: ${currentHash}`);
+                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, error: validationError };
+                return { success: false, checkedCount, error: validationError };
             }
             // Add adjacent transactions to queue
-            if (currentDepth + 1 < maxDepth) {
+            if (currentDepth < maxDepth) {
                 if ((direction === 'forward' || direction === 'both') && tx.outMessages.size > 0) {
                     for (const msg of tx.outMessages.values()) {
                         const dst = msg.info.dest;
@@ -282,9 +438,8 @@ class BaseContractOpener {
                     });
                 }
             }
-            this.logger?.debug(`Finished checking hash (depth ${currentDepth}): ${currentHash}`);
         }
-        return { success: true };
+        return { success: true, checkedCount };
     }
 }
 exports.BaseContractOpener = BaseContractOpener;

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

@@ -1,4 +1,5 @@
 import { Address, Contract, OpenedContract, Transaction } from '@ton/ton';
+import { ILogger } from '../interfaces';
 import { AddressInformation, ContractState, GetTransactionsOptions, Network } from '../structs/Struct';
 import { BaseContractOpener } from './BaseContractOpener';
 type LiteServer = {
@@ -12,13 +13,17 @@ type LiteServer = {
 export declare class LiteClientOpener extends BaseContractOpener {
     private readonly client;
     private readonly engine;
+    private readonly singleEngines;
+    private isClosing;
+    private isClosed;
     private constructor();
     static create(options: {
         liteservers: LiteServer[];
     } | {
         network: Network;
-    }): Promise<LiteClientOpener>;
+    }, logger?: ILogger): Promise<LiteClientOpener>;
     open<T extends Contract>(contract: T): OpenedContract<T>;
+    private disableReconnect;
     closeConnections(): void;
     getContractState(addr: Address): Promise<ContractState>;
     getTransactions(address: Address, opts: GetTransactionsOptions): Promise<Transaction[]>;
@@ -29,5 +34,5 @@ export declare function liteClientOpener(options: {
     liteservers: LiteServer[];
 } | {
     network: Network;
-}): Promise<LiteClientOpener>;
+}, logger?: ILogger): Promise<LiteClientOpener>;
 export {};

package/dist/src/adapters/LiteClientOpener.js

@@ -24,12 +24,15 @@ async function getDefaultLiteServers(network) {
     return liteClients.liteservers;
 }
 class LiteClientOpener extends BaseContractOpener_1.BaseContractOpener {
-    constructor(client, engine) {
-        super();
+    constructor(client, engine, logger, singleEngines = []) {
+        super(logger);
         this.client = client;
         this.engine = engine;
+        this.isClosing = false;
+        this.isClosed = false;
+        this.singleEngines = singleEngines;
     }
-    static async create(options) {
+    static async create(options, logger) {
         const liteservers = 'liteservers' in options ? options.liteservers : await getDefaultLiteServers(options.network);
         const engines = [];
         for (const server of liteservers) {
@@ -41,13 +44,32 @@ class LiteClientOpener extends BaseContractOpener_1.BaseContractOpener {
         }
         const engine = new ton_lite_client_1.LiteRoundRobinEngine(engines);
         const client = new ton_lite_client_1.LiteClient({ engine });
-        return new LiteClientOpener(client, engine);
+        return new LiteClientOpener(client, engine, logger, engines);
     }
     open(contract) {
         return this.client.open(contract);
     }
+    disableReconnect(singleEngine) {
+        const engine = singleEngine;
+        engine.connect = async () => undefined;
+        engine.onClosed = () => undefined;
+    }
     closeConnections() {
-        this.engine.close();
+        if (this.isClosing || this.isClosed) {
+            return;
+        }
+        this.isClosing = true;
+        try {
+            for (const singleEngine of this.singleEngines) {
+                this.disableReconnect(singleEngine);
+                singleEngine.close();
+            }
+            this.engine.close();
+            this.isClosed = true;
+        }
+        finally {
+            this.isClosing = false;
+        }
     }
     async getContractState(addr) {
         const block = await this.client.getMasterchainInfo();
@@ -98,10 +120,12 @@ class LiteClientOpener extends BaseContractOpener_1.BaseContractOpener {
     async getAddressInformation(addr) {
         const block = await this.client.getMasterchainInfo();
         const state = await this.client.getAccountState(addr, block.last);
+        const lastHashHex = state.lastTx ? state.lastTx.hash.toString(16).padStart(64, '0') : '';
+        const lastHashB64 = lastHashHex ? Buffer.from(lastHashHex, 'hex').toString('base64') : '';
         return {
             lastTransaction: {
                 lt: state.lastTx?.lt.toString() ?? '',
-                hash: Buffer.from(state.lastTx?.hash.toString(16) ?? '', 'hex').toString('base64'),
+                hash: lastHashB64,
             },
         };
     }
@@ -112,6 +136,6 @@ class LiteClientOpener extends BaseContractOpener_1.BaseContractOpener {
     }
 }
 exports.LiteClientOpener = LiteClientOpener;
-async function liteClientOpener(options) {
-    return LiteClientOpener.create(options);
+async function liteClientOpener(options, logger) {
+    return LiteClientOpener.create(options, logger);
 }

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

@@ -14,6 +14,8 @@ export declare class RetryableContractOpener implements ContractOpener {
     private readonly openerConfigs;
     private logger?;
     constructor(openerConfigs: OpenerConfig[], logger?: ILogger);
+    setLogger(logger: ILogger): void;
+    private applyLoggerToOpeners;
     getTransactions(address: Address, opts: GetTransactionsOptions): Promise<Transaction[]>;
     getTransactionByHash(address: Address, hash: string, opts?: GetTransactionsOptions): Promise<Transaction | null>;
     getAdjacentTransactions(address: Address, hash: string, opts?: GetTransactionsOptions): Promise<Transaction[]>;
@@ -28,7 +30,10 @@ export declare class RetryableContractOpener implements ContractOpener {
     trackTransactionTree(address: string, hash: string, params?: TrackTransactionTreeParams): Promise<void>;
     trackTransactionTreeWithResult(address: string, hash: string, params?: TrackTransactionTreeParams): Promise<TrackTransactionTreeResult>;
     private executeWithFallback;
+    private trySingleAttempt;
     private tryWithRetries;
+    private isContractExecutionError;
+    private isTransportError;
     private createRetryableContract;
     private callMethodAcrossOpeners;
 }