@tonappchain/sdk 0.7.2-alpha-21 → 0.7.2-alpha-22

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

@@ -62,9 +62,9 @@ export declare abstract class BaseContractOpener implements ContractOpener {
      */
     private findTransactionByHashType;
     /**
-     * Retry lookup for root transaction because it may appear in indexers with a delay.
+     * Find transaction with retry logic
      */
-    private findRootTransactionWithRetry;
+    private findTransactionWithRetry;
     /**
      * Track transaction tree and validate all transactions
      */

package/dist/src/adapters/BaseContractOpener.js

@@ -293,46 +293,31 @@ class BaseContractOpener {
         }
     }
     /**
-     * Retry lookup for root transaction because it may appear in indexers with a delay.
+     * Find transaction with retry logic
      */
-    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;
+    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);
             }
-            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;
+            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;
             }
-            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);
+            await (0, Utils_1.sleep)(retryDelayMs);
         }
-        this.logger?.debug(`Root transaction not found after ${attempts} attempts`);
         return null;
     }
     /**
@@ -343,7 +328,7 @@ class BaseContractOpener {
         ignoreOpcodeList: Consts_1.IGNORE_OPCODE,
         limit: Consts_1.DEFAULT_FIND_TX_LIMIT,
         direction: 'both',
-        waitForRootTransaction: Consts_1.DEFAULT_WAIT_FOR_ROOT_TRANSACTION,
+        retryOnNotFound: Consts_1.DEFAULT_RETRY_ON_NOT_FOUND,
     }) {
         const result = await this.trackTransactionTreeWithResult(address, hash, params);
         if (this.logger && typeof result.checkedCount === 'number') {
@@ -354,7 +339,13 @@ class BaseContractOpener {
             const context = reason === 'not_found'
                 ? ` address=${errorAddress ?? 'unknown'} hashType=${hashType ?? 'unknown'}`
                 : '';
-            throw (0, errors_1.txFinalizationError)(`${txHash}: reason=${reason} (exitCode=${exitCode}, resultCode=${resultCode})${context}`);
+            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);
+            }
         }
     }
     /**
@@ -365,15 +356,21 @@ class BaseContractOpener {
         ignoreOpcodeList: Consts_1.IGNORE_OPCODE,
         limit: Consts_1.DEFAULT_FIND_TX_LIMIT,
         direction: 'both',
-        waitForRootTransaction: Consts_1.DEFAULT_WAIT_FOR_ROOT_TRANSACTION,
+        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', waitForRootTransaction = Consts_1.DEFAULT_WAIT_FOR_ROOT_TRANSACTION, } = 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', 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 };
+        const searchOpts = {
+            limit,
+            archival: true,
+            maxScannedTransactions,
+            retryDelayMs,
+            retries,
+        };
         const queue = [
             { address: parsedAddress, hash: normalizedRootHash, depth: 0, hashType: 'unknown' },
         ];
@@ -383,8 +380,8 @@ class BaseContractOpener {
             if (visitedSearchKeys.has(visitedKey))
                 continue;
             visitedSearchKeys.add(visitedKey);
-            const tx = currentDepth === 0
-                ? await this.findRootTransactionWithRetry(currentAddress, currentHash, hashType, limit, maxScannedTransactions, waitForRootTransaction)
+            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'})`);

package/dist/src/adapters/RetryableContractOpener.js

@@ -144,12 +144,11 @@ class RetryableContractOpener {
         for (let index = 0; index < this.openerConfigs.length; index++) {
             const config = this.openerConfigs[index];
             const openerLabel = `opener ${index + 1}/${this.openerConfigs.length}`;
-            this.logger?.debug(`[RetryableContractOpener] ${operationName}: trying ${openerLabel}${useRetries ? ` (max retries ${config.retries})` : ' (single attempt)'}`);
+            this.logger?.debug(`[RetryableContractOpener] ${operationName}: trying ${openerLabel}`);
             const result = useRetries
                 ? await this.tryWithRetries(() => operation(config), config, `${operationName} ${openerLabel}`)
                 : await this.trySingleAttempt(() => operation(config));
             if (result.success) {
-                this.logger?.debug(`[RetryableContractOpener] ${operationName}: ${openerLabel} succeeded`);
                 return { success: true, data: result.data };
             }
             lastError = result.lastError;
@@ -200,7 +199,7 @@ class RetryableContractOpener {
                     return { success: false, lastError };
                 }
                 if (attempt < config.retries) {
-                    this.logger?.debug(`[RetryableContractOpener] ${operationContext}: attempt ${attempt + 1}/${config.retries + 1} failed, retrying in ${config.retryDelay}ms`);
+                    this.logger?.debug(`[RetryableContractOpener] ${operationContext}: attempt ${attempt + 1}/${config.retries + 1} failed (${lastError.message}), retrying in ${config.retryDelay}ms`);
                     await sleep(config.retryDelay);
                 }
             }

package/dist/src/errors/instances.js

@@ -37,8 +37,12 @@ function extractEndpoint(message) {
     }
     return match[0].replace(/[),.;]+$/, '');
 }
-function extractResponseMessage(data) {
+function extractResponseMessage(data, includeFullTrace) {
     if (typeof data === 'string' && data.length > 0) {
+        const isHtml = data.includes('<!doctype html>') || data.includes('<html');
+        if (isHtml && !includeFullTrace) {
+            return '[HTML response]';
+        }
         return data;
     }
     if (!data || typeof data !== 'object') {
@@ -53,11 +57,11 @@ function extractResponseMessage(data) {
     }
     return undefined;
 }
-function buildInnerErrorSummary(inner) {
+function buildInnerErrorSummary(inner, includeFullTrace) {
     if (inner && typeof inner === 'object') {
         const err = inner;
         const parts = [];
-        const responseMessage = extractResponseMessage(err.response?.data);
+        const responseMessage = extractResponseMessage(err.response?.data, includeFullTrace);
         const httpStatus = [err.httpStatus, err.status, err.response?.status].find((value) => typeof value === 'number');
         const httpMessage = typeof err.innerMessage === 'string' && err.innerMessage.length > 0 ? err.innerMessage : responseMessage;
         if (typeof httpStatus === 'number') {
@@ -81,7 +85,7 @@ function buildInnerErrorSummary(inner) {
     }
     return 'message=unknown error';
 }
-const allEndpointsFailedError = (inner, includeInnerStack = false) => new errors_1.FetchError(`All endpoints failed, last err: ${buildInnerErrorSummary(inner)}`, 117, inner, {
+const allEndpointsFailedError = (inner, includeInnerStack = false) => new errors_1.FetchError(`All endpoints failed, last err: ${buildInnerErrorSummary(inner, includeInnerStack)}`, 117, inner, {
     includeInnerStack,
 });
 exports.allEndpointsFailedError = allEndpointsFailedError;

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

@@ -16,16 +16,18 @@ export declare const TAC_DECIMALS = 18;
 export declare const FIVE_MINUTES: number;
 export declare const MINUTE: number;
 export declare const TON_BURN_ADDRESS = "EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c";
-export declare const DEFAULT_TIMEOUT_MS = 300000;
 export declare const DEFAULT_HTTP_CLIENT_TIMEOUT_MS = 30000;
 export declare const DEFAULT_RETRY_MAX_COUNT = 5;
 export declare const DEFAULT_RETRY_DELAY_MS = 1000;
+export declare const DEFAULT_WAIT_TIMEOUT_MS = 300000;
+export declare const DEFAULT_WAIT_MAX_ATTEMPTS = 30;
+export declare const DEFAULT_WAIT_DELAY_MS = 10000;
 export declare const DEFAULT_FIND_TX_LIMIT = 100;
 export declare const DEFAULT_MAX_SCANNED_TRANSACTIONS = 100;
 export declare const DEFAULT_FIND_TX_ARCHIVAL = true;
 export declare const DEFAULT_FIND_TX_MAX_DEPTH = 10;
-export declare const DEFAULT_WAIT_FOR_ROOT_TRANSACTION = true;
-export declare const DEFAULT_WAIT_FOR_ROOT_TRANSACTION_TIMEOUT_MS: number;
-export declare const DEFAULT_WAIT_FOR_ROOT_TRANSACTION_RETRY_DELAY_MS = 1000;
+export declare const DEFAULT_RETRY_ON_NOT_FOUND = true;
+export declare const DEFAULT_RETRY_ON_NOT_FOUND_RETRIES = 10;
+export declare const DEFAULT_RETRY_ON_NOT_FOUND_DELAY_MS = 5000;
 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_OPCODE = exports.IGNORE_MSG_VALUE_1_NANO = exports.DEFAULT_WAIT_FOR_ROOT_TRANSACTION_RETRY_DELAY_MS = exports.DEFAULT_WAIT_FOR_ROOT_TRANSACTION_TIMEOUT_MS = exports.DEFAULT_WAIT_FOR_ROOT_TRANSACTION = exports.DEFAULT_FIND_TX_MAX_DEPTH = exports.DEFAULT_FIND_TX_ARCHIVAL = exports.DEFAULT_MAX_SCANNED_TRANSACTIONS = exports.DEFAULT_FIND_TX_LIMIT = exports.DEFAULT_RETRY_DELAY_MS = exports.DEFAULT_RETRY_MAX_COUNT = exports.DEFAULT_HTTP_CLIENT_TIMEOUT_MS = exports.DEFAULT_TIMEOUT_MS = exports.TON_BURN_ADDRESS = exports.MINUTE = 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_RETRY_ON_NOT_FOUND_DELAY_MS = exports.DEFAULT_RETRY_ON_NOT_FOUND_RETRIES = exports.DEFAULT_RETRY_ON_NOT_FOUND = exports.DEFAULT_FIND_TX_MAX_DEPTH = exports.DEFAULT_FIND_TX_ARCHIVAL = exports.DEFAULT_MAX_SCANNED_TRANSACTIONS = exports.DEFAULT_FIND_TX_LIMIT = exports.DEFAULT_WAIT_DELAY_MS = exports.DEFAULT_WAIT_MAX_ATTEMPTS = exports.DEFAULT_WAIT_TIMEOUT_MS = exports.DEFAULT_RETRY_DELAY_MS = exports.DEFAULT_RETRY_MAX_COUNT = exports.DEFAULT_HTTP_CLIENT_TIMEOUT_MS = exports.TON_BURN_ADDRESS = exports.MINUTE = 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);
@@ -20,17 +20,19 @@ exports.TAC_DECIMALS = 18;
 exports.FIVE_MINUTES = 5 * 60 * 1000;
 exports.MINUTE = 60 * 1000;
 exports.TON_BURN_ADDRESS = 'EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c';
-exports.DEFAULT_TIMEOUT_MS = 300000; // 5 minute
 exports.DEFAULT_HTTP_CLIENT_TIMEOUT_MS = 30000;
 exports.DEFAULT_RETRY_MAX_COUNT = 5;
 exports.DEFAULT_RETRY_DELAY_MS = 1000;
+exports.DEFAULT_WAIT_TIMEOUT_MS = 300000; // 5 minutes
+exports.DEFAULT_WAIT_MAX_ATTEMPTS = 30;
+exports.DEFAULT_WAIT_DELAY_MS = 10000; // 10 seconds
 exports.DEFAULT_FIND_TX_LIMIT = 100;
 exports.DEFAULT_MAX_SCANNED_TRANSACTIONS = 100;
 exports.DEFAULT_FIND_TX_ARCHIVAL = true;
 exports.DEFAULT_FIND_TX_MAX_DEPTH = 10;
-exports.DEFAULT_WAIT_FOR_ROOT_TRANSACTION = true;
-exports.DEFAULT_WAIT_FOR_ROOT_TRANSACTION_TIMEOUT_MS = exports.MINUTE;
-exports.DEFAULT_WAIT_FOR_ROOT_TRANSACTION_RETRY_DELAY_MS = 1000;
+exports.DEFAULT_RETRY_ON_NOT_FOUND = true;
+exports.DEFAULT_RETRY_ON_NOT_FOUND_RETRIES = 10;
+exports.DEFAULT_RETRY_ON_NOT_FOUND_DELAY_MS = 5000;
 exports.IGNORE_MSG_VALUE_1_NANO = 1n;
 exports.IGNORE_OPCODE = [
     0xd53276db, // Excess

package/dist/src/sdk/OperationTracker.js

@@ -35,96 +35,78 @@ class OperationTracker {
         this.logger = logger;
     }
     async getOperationIdByTransactionHash(transactionHash, waitOptions) {
-        this.logger.debug(`Getting operation ID for transactionHash: ${(0, Utils_1.formatObjectForLogging)(transactionHash)}`);
         const requestFn = async () => {
             let lastError;
             for (const client of this.clients) {
                 try {
                     const id = await client.getOperationIdByTransactionHash(transactionHash);
-                    this.logger.debug(`Operation ID ${id == '' ? 'does not exist' : 'retrieved successfully'}`);
                     return id;
                 }
                 catch (error) {
-                    this.logger.warn(`Failed to get OperationId by transactionHash using one of the endpoints`);
                     lastError = error;
                 }
             }
-            this.logger.error('All endpoints failed to get operation id by transactionHash');
             throw (0, errors_1.allEndpointsFailedError)(lastError, waitOptions?.includeErrorTrace ?? false);
         };
         return waitOptions === null
             ? await requestFn()
-            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, 'OperationTracker: Getting operation ID by transaction hash');
+            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, `OperationTracker: Getting operation ID by transaction hash ${(0, Utils_1.formatObjectForLogging)(transactionHash)}`);
     }
     async getOperationType(operationId, waitOptions) {
-        this.logger.debug(`Getting operation type for ${(0, Utils_1.formatObjectForLogging)(operationId)}`);
         const requestFn = async () => {
             let lastError;
             for (const client of this.clients) {
                 try {
                     const type = await client.getOperationType(operationId);
-                    this.logger.debug(`Operation retrieved successfully`);
                     return type;
                 }
                 catch (error) {
-                    this.logger.warn(`Failed to get operationType using one of the endpoints`);
                     lastError = error;
                 }
             }
-            this.logger.error('All endpoints failed to get operation type');
             throw (0, errors_1.allEndpointsFailedError)(lastError, waitOptions?.includeErrorTrace ?? false);
         };
         return waitOptions === null
             ? await requestFn()
-            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, 'OperationTracker: Getting operation type');
+            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, `OperationTracker: Getting operation type for ${(0, Utils_1.formatObjectForLogging)(operationId)}`);
     }
     async getOperationId(transactionLinker, waitOptions) {
-        this.logger.debug(`Getting operation ID for transaction linker: ${(0, Utils_1.formatObjectForLogging)(transactionLinker)}`);
         const requestFn = async () => {
             let lastError;
             for (const client of this.clients) {
                 try {
                     const id = await client.getOperationId(transactionLinker);
-                    this.logger.debug(`Operation ID ${id == '' ? 'does not exist' : 'retrieved successfully'}`);
                     return id;
                 }
                 catch (error) {
-                    this.logger.warn(`Failed to get OperationId using one of the endpoints`);
                     lastError = error;
                 }
             }
-            this.logger.error('All endpoints failed to get operation id');
             throw (0, errors_1.allEndpointsFailedError)(lastError, waitOptions?.includeErrorTrace ?? false);
         };
         return waitOptions === null
             ? await requestFn()
-            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, 'OperationTracker: Getting operation ID by transaction linker');
+            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, `OperationTracker: Getting operation ID by transaction linker ${(0, Utils_1.formatObjectForLogging)(transactionLinker)}`);
     }
     async getOperationIdsByShardsKeys(shardsKeys, caller, waitOptions, chunkSize = 100) {
-        this.logger.debug(`Getting operation IDs for shards keys: ${(0, Utils_1.formatObjectForLogging)(shardsKeys)}`);
-        this.logger.debug(`Caller: ${caller}, Chunk size: ${chunkSize}`);
         const requestFn = async () => {
             let lastError;
             for (const client of this.clients) {
                 try {
                     const result = await client.getOperationIdsByShardsKeys(shardsKeys, caller, chunkSize);
-                    this.logger.debug(`Operation IDs by shards keys retrieved successfully`);
                     return result;
                 }
                 catch (error) {
-                    this.logger.warn(`Failed to get OperationIds using one of the endpoints`);
                     lastError = error;
                 }
             }
-            this.logger.error('All endpoints failed to get operation ids by shards keys');
             throw (0, errors_1.allEndpointsFailedError)(lastError, waitOptions?.includeErrorTrace ?? false);
         };
         return waitOptions === null
             ? await requestFn()
-            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, 'OperationTracker: Getting operation IDs by shards keys');
+            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, `OperationTracker: Getting operation IDs by shards keys ${(0, Utils_1.formatObjectForLogging)(shardsKeys)} caller=${caller} chunkSize=${chunkSize}`);
     }
     async getStageProfiling(operationId, waitOptions) {
-        this.logger.debug(`Getting stage profiling for operation ${operationId}`);
         const requestFn = async () => {
             let lastError;
             for (const client of this.clients) {
@@ -132,72 +114,57 @@ class OperationTracker {
                     const map = await client.getStageProfilings([operationId]);
                     const result = map[operationId];
                     if (!result) {
-                        this.logger.warn(`No stageProfiling data for operationId=${operationId}`);
                         throw new Error(`No stageProfiling data for operationId=${operationId}`);
                     }
-                    this.logger.debug(`Stage profiling retrieved successfully`);
                     return result;
                 }
                 catch (error) {
-                    this.logger.warn(`Failed to get stage profiling using one of the endpoints`);
                     lastError = error;
                 }
             }
-            this.logger.error('All endpoints failed to get stage profiling');
             throw (0, errors_1.allEndpointsFailedError)(lastError, waitOptions?.includeErrorTrace ?? false);
         };
         return waitOptions === null
             ? await requestFn()
-            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, 'OperationTracker: Getting stage profiling');
+            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, `OperationTracker: Getting stage profiling for operation ${operationId}`);
     }
     async getStageProfilings(operationIds, waitOptions, chunkSize = 100) {
-        this.logger.debug(`Getting stage profilings for operations: ${operationIds.join(', ')}`);
-        this.logger.debug(`Chunk size: ${chunkSize}`);
         const requestFn = async () => {
             let lastError;
             for (const client of this.clients) {
                 try {
                     const result = await client.getStageProfilings(operationIds, chunkSize);
-                    this.logger.debug(`Stage profilings retrieved successfully`);
                     return result;
                 }
                 catch (error) {
-                    this.logger.warn(`Failed to get stage profilings using one of the endpoints`);
                     lastError = error;
                 }
             }
-            this.logger.error('All endpoints failed to get stage profilings');
             throw (0, errors_1.allEndpointsFailedError)(lastError, waitOptions?.includeErrorTrace ?? false);
         };
         return waitOptions === null
             ? await requestFn()
-            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, 'OperationTracker: Getting stage profilings');
+            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, `OperationTracker: Getting stage profilings for operations: ${operationIds.join(', ')} chunkSize=${chunkSize}`);
     }
     async getOperationStatuses(operationIds, waitOptions, chunkSize = 100) {
-        this.logger.debug(`Getting operation statuses for operations: ${(0, Utils_1.formatObjectForLogging)(operationIds)}`);
-        this.logger.debug(`Chunk size: ${chunkSize}`);
         const requestFn = async () => {
             let lastError;
             for (const client of this.clients) {
                 try {
                     const result = await client.getOperationStatuses(operationIds, chunkSize);
-                    this.logger.debug(`Operation statuses retrieved successfully`);
                     return result;
                 }
                 catch (error) {
-                    this.logger.warn(`Failed to get operation statuses using one of the endpoints`);
                     lastError = error;
                 }
             }
-            this.logger.error('All endpoints failed to get operation statuses');
             throw (0, errors_1.allEndpointsFailedError)(lastError, waitOptions?.includeErrorTrace ?? false);
         };
         return waitOptions === null
             ? await requestFn()
-            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, 'OperationTracker: Getting operation statuses');
+            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, `OperationTracker: Getting operation statuses for operations: ${(0, Utils_1.formatObjectForLogging)(operationIds)} chunkSize=${chunkSize}`);
     }
     async getOperationStatus(operationId, waitOptions) {
-        this.logger.debug(`Getting operation status for ${(0, Utils_1.formatObjectForLogging)(operationId)}`);
         const requestFn = async () => {
             let lastError;
             for (const client of this.clients) {
@@ -205,27 +172,23 @@ class OperationTracker {
                     const map = await client.getOperationStatuses([operationId]);
                     const result = map[operationId];
                     if (!result) {
-                        this.logger.warn(`No operation status for operationId=${operationId}`);
                         throw new Error(`No operation status for operationId=${operationId}`);
                     }
                     return result;
                 }
                 catch (error) {
-                    this.logger.warn(`Failed to get operation status using one of the endpoints`);
                     lastError = error;
                 }
             }
-            this.logger.error('All endpoints failed to get operation status');
             throw (0, errors_1.allEndpointsFailedError)(lastError, waitOptions?.includeErrorTrace ?? false);
         };
         const status = waitOptions === null
             ? await requestFn()
-            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, 'OperationTracker: Getting operation status');
+            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, `OperationTracker: Getting operation status for ${(0, Utils_1.formatObjectForLogging)(operationId)}`);
         this.logger.debug(`operation status resolved stage=${status.stage ?? 'unknown'} success=${(String(status.success))}`);
         return status;
     }
     async getSimplifiedOperationStatus(transactionLinker) {
-        this.logger.debug(`Getting simplified operation status for transaction linker: ${(0, Utils_1.formatObjectForLogging)(transactionLinker)}`);
         const operationId = await this.getOperationId(transactionLinker);
         if (operationId == '') {
             this.logger.warn('Operation ID not found');
@@ -244,71 +207,59 @@ class OperationTracker {
         if (params.value <= 0n) {
             throw instances_1.convertCurrencyNegativeOrZeroValueError;
         }
-        this.logger.debug(`Converting currency: ${(0, Utils_1.formatObjectForLogging)(params)}`);
         const requestFn = async () => {
             let lastError;
             for (const client of this.clients) {
                 try {
                     const result = await client.convertCurrency(params);
-                    this.logger.debug(`Conversion result retrieved successfully`);
                     return result;
                 }
                 catch (error) {
-                    this.logger.warn(`Failed to convert currency using one of the endpoints`);
                     lastError = error;
                 }
             }
-            this.logger.error('All endpoints failed to convert currency');
             throw (0, errors_1.allEndpointsFailedError)(lastError, waitOptions?.includeErrorTrace ?? false);
         };
         return waitOptions === null
             ? await requestFn()
-            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, 'OperationTracker: Converting currency');
+            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, `OperationTracker: Converting currency ${(0, Utils_1.formatObjectForLogging)(params)}`);
     }
     async simulateTACMessage(params, waitOptions) {
         Validator_1.Validator.validateTACSimulationParams(params);
-        this.logger.debug(`Simulating TAC message: ${(0, Utils_1.formatObjectForLogging)(params)}`);
         const requestFn = async () => {
             let lastError;
             for (const client of this.clients) {
                 try {
                     const result = await client.simulateTACMessage(params);
-                    this.logger.debug(`Simulation result retrieved successfully`);
                     return result;
                 }
                 catch (error) {
-                    this.logger.warn(`Failed to simulate TAC message using one of the endpoints`);
                     lastError = error;
                 }
             }
-            this.logger.error('All endpoints failed to simulate TAC message');
             throw (0, errors_1.allEndpointsFailedError)(lastError, waitOptions?.includeErrorTrace ?? false);
         };
         return waitOptions === null
             ? await requestFn()
-            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, 'OperationTracker: Simulating TAC message');
+            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, `OperationTracker: Simulating TAC message ${(0, Utils_1.formatObjectForLogging)(params)}`);
     }
     async getTVMExecutorFee(params, waitOptions) {
-        this.logger.debug(`get TVM executor fee: ${(0, Utils_1.formatObjectForLogging)(params)}`);
         const requestFn = async () => {
             let lastError;
             for (const client of this.clients) {
                 try {
                     const result = await client.getTVMExecutorFee(params);
-                    this.logger.debug(`Suggested TVM executor fee retrieved successfully`);
                     return result;
                 }
                 catch (error) {
-                    this.logger.warn(`Failed to get TVM executor fee using one of the endpoints`);
                     lastError = error;
                 }
             }
-            this.logger.error('All endpoints failed to get TVM executor fee');
             throw (0, errors_1.allEndpointsFailedError)(lastError, waitOptions?.includeErrorTrace ?? false);
         };
         return waitOptions === null
             ? await requestFn()
-            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, 'OperationTracker: Getting TVM executor fee');
+            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, `OperationTracker: Getting TVM executor fee ${(0, Utils_1.formatObjectForLogging)(params)}`);
     }
 }
 exports.OperationTracker = OperationTracker;

package/dist/src/sdk/TacSdk.js

@@ -42,7 +42,7 @@ class TacSdk {
                 throw new Error(`Unsupported network: ${network}`);
         }
         const config = await Configuration_1.Configuration.create(network, artifacts, sdkParams.TONParams, sdkParams.TACParams, sdkParams.customLiteSequencerEndpoints, delay, logger, passLoggerToOpeners);
-        const operationTracker = new OperationTracker_1.OperationTracker(network, config.liteSequencerEndpoints);
+        const operationTracker = new OperationTracker_1.OperationTracker(network, config.liteSequencerEndpoints, logger);
         const explorerClient = new TacExplorerClient_1.TacExplorerClient(artifacts.TAC_EXPLORER_API_ENDPOINT);
         const simulator = new Simulator_1.Simulator(config, operationTracker, logger);
         const tonTransactionManager = new TONTransactionManager_1.TONTransactionManager(config, simulator, operationTracker, logger);

package/dist/src/sdk/Utils.js

@@ -157,7 +157,6 @@ async function waitUntilSuccess(options = {}, operation, operationDescription, .
     const successCheck = options.successCheck;
     const context = options.context;
     const contextPrefix = operationDescription ? `[${operationDescription}] ` : '';
-    options.logger?.debug(`${contextPrefix}Starting wait for success with timeout=${timeout}ms, maxAttempts=${maxAttempts}, delay=${delay}ms`);
     const startTime = Date.now();
     let attempt = 1;
     while (true) {
@@ -171,8 +170,7 @@ async function waitUntilSuccess(options = {}, operation, operationDescription, .
             if (successCheck && !successCheck(result, context)) {
                 throw new Error(`Result is not successful: ${formatObjectForLogging(result)}`);
             }
-            options.logger?.debug(`${contextPrefix}Attempt ${attempt} successful`);
-            // Execute custom onSuccess callback if provided
+            options.logger?.debug(`${contextPrefix}Success (attempt ${attempt}/${maxAttempts})`);
             if (options.onSuccess) {
                 try {
                     await options.onSuccess(result, context);
@@ -197,7 +195,11 @@ async function waitUntilSuccess(options = {}, operation, operationDescription, .
                 options.logger?.debug(`${contextPrefix}${pendingMessage}`);
             }
             else {
-                options.logger?.debug(`${contextPrefix}attempt=${attempt}/${maxAttempts} failed; retry_in=${delay}ms; error=${String(error)}`);
+                let errorMessage = error instanceof Error ? error.message : String(error);
+                if (errorMessage.includes('<!doctype html>') || errorMessage.includes('<html')) {
+                    errorMessage = errorMessage.replace(/<!doctype html>[\s\S]*?<\/html>/gi, '[HTML response]');
+                }
+                options.logger?.debug(`${contextPrefix}attempt=${attempt}/${maxAttempts} failed; retry_in=${delay}ms; error=${errorMessage}`);
             }
             await (0, exports.sleep)(delay);
             attempt++;

package/dist/src/structs/Struct.d.ts

@@ -496,11 +496,21 @@ export type TrackTransactionTreeParams = {
      */
     direction?: 'forward' | 'backward' | 'both';
     /**
-     * Internal option: wait for the root transaction to appear before failing with `not_found`.
-     * Useful right after sending a message when transaction indexing is eventually consistent.
+     * Retry transaction lookup when `not_found` error occurs.
+     * Useful when transaction indexing has delays or when transactions appear gradually.
      * @default true
      */
-    waitForRootTransaction?: boolean;
+    retryOnNotFound?: boolean;
+    /**
+     * Delay in milliseconds between retry attempts for transaction lookup
+     * @default 5000
+     */
+    retryDelayMs?: number;
+    /**
+     * Number of retry attempts for transaction lookup
+     * @default 10
+     */
+    retries?: number;
 };
 /**
  * Details about a transaction validation error
@@ -570,6 +580,8 @@ export type GetTransactionsOptions = {
     timeoutMs?: number;
     /** Delay between retry attempts in milliseconds */
     retryDelayMs?: number;
+    /** Number of retry attempts */
+    retries?: number;
     /** Internal scan guard: maximum transactions to inspect while traversing history */
     maxScannedTransactions?: number;
 };

package/dist/src/structs/Struct.js

@@ -59,9 +59,9 @@ var TokenSymbol;
     TokenSymbol["TON_SYMBOL"] = "TON";
 })(TokenSymbol || (exports.TokenSymbol = TokenSymbol = {}));
 exports.defaultWaitOptions = {
-    timeout: Consts_1.DEFAULT_TIMEOUT_MS,
-    maxAttempts: Consts_1.DEFAULT_RETRY_MAX_COUNT,
-    delay: Consts_1.DEFAULT_RETRY_DELAY_MS,
+    timeout: Consts_1.DEFAULT_WAIT_TIMEOUT_MS,
+    maxAttempts: Consts_1.DEFAULT_WAIT_MAX_ATTEMPTS,
+    delay: Consts_1.DEFAULT_WAIT_DELAY_MS,
 };
 var Origin;
 (function (Origin) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@tonappchain/sdk",
-    "version": "0.7.2-alpha-21",
+    "version": "0.7.2-alpha-22",
     "repository": "https://github.com/TacBuild/tac-sdk.git",
     "author": "TAC. <developers@tac>",
     "license": "MIT",