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

package/dist/src/sdk/StartTracking.js

@@ -9,7 +9,7 @@ const Logger_1 = require("./Logger");
 const OperationTracker_1 = require("./OperationTracker");
 const Utils_1 = require("./Utils");
 async function startTracking(transactionLinker, network, options) {
-    const { customLiteSequencerEndpoints, delay = 10, maxIterationCount = Consts_1.MAX_ITERATION_COUNT, returnValue = false, tableView = true, logger = new Logger_1.NoopLogger(), contractOpener, cclAddress, } = options || {};
+    const { customLiteSequencerEndpoints, delay = 10, maxIterationCount = Consts_1.MAX_ITERATION_COUNT, returnValue = false, tableView = true, logger = new Logger_1.NoopLogger(), txFinalizer, contractOpener, cclAddress, } = options || {};
     const tracker = new OperationTracker_1.OperationTracker(network, customLiteSequencerEndpoints, logger);
     logger.debug(`Start tracking operation\n` +
         `caller: ${transactionLinker.caller}\n` +
@@ -66,12 +66,15 @@ async function startTracking(transactionLinker, network, options) {
     // Check if EXECUTED_IN_TON stage exists and use ContractOpener to verify transaction success
     if (profilingData.executedInTON.exists && profilingData.executedInTON.stageData?.transactions) {
         logger.debug('EXECUTED_IN_TON stage found, verifying transaction success in TON...');
-        if (contractOpener && cclAddress) {
+        const finalizer = txFinalizer || contractOpener;
+        if (finalizer && cclAddress) {
             const transactions = profilingData.executedInTON.stageData.transactions;
             for (const tx of transactions) {
                 try {
                     logger.debug(`Verifying transaction: ${tx.hash}`);
-                    await contractOpener.trackTransactionTree(cclAddress, tx.hash, { maxDepth: Consts_1.DEFAULT_FIND_TX_MAX_DEPTH });
+                    await finalizer.trackTransactionTree(cclAddress, tx.hash, {
+                        maxDepth: Consts_1.DEFAULT_FIND_TX_MAX_DEPTH,
+                    });
                     logger.debug(`Transaction ${tx.hash} verified successfully in TON`);
                 }
                 catch (error) {
@@ -83,7 +86,7 @@ async function startTracking(transactionLinker, network, options) {
             }
         }
         else {
-            logger.debug('ContractOpener or CCL address is not provided, skipping TON transaction verification');
+            logger.debug('Finalizer, ContractOpener or CCL address is not provided, skipping TON transaction verification');
         }
     }
     if (returnValue) {
@@ -99,7 +102,7 @@ async function startTracking(transactionLinker, network, options) {
     }
 }
 async function startTrackingMultiple(transactionLinkers, network, options) {
-    const { customLiteSequencerEndpoints, delay = 10, maxIterationCount = Consts_1.MAX_ITERATION_COUNT, returnValue = false, tableView = true, contractOpener, logger = new Logger_1.NoopLogger(), } = options || {};
+    const { customLiteSequencerEndpoints, delay = 10, maxIterationCount = Consts_1.MAX_ITERATION_COUNT, returnValue = false, tableView = true, txFinalizer, contractOpener, cclAddress, logger = new Logger_1.NoopLogger(), } = options || {};
     logger.debug(`Start tracking ${transactionLinkers.length} operations`);
     const results = await Promise.all(transactionLinkers.map((linker, index) => {
         logger.debug(`\nProcessing operation ${index + 1}/${transactionLinkers.length}`);
@@ -109,7 +112,9 @@ async function startTrackingMultiple(transactionLinkers, network, options) {
             maxIterationCount,
             returnValue: true,
             tableView: false,
+            txFinalizer,
             contractOpener,
+            cclAddress,
             logger,
         });
     }));

package/dist/src/sdk/TONTransactionManager.js

@@ -159,12 +159,12 @@ class TONTransactionManager {
     async sendCrossChainTransaction(evmProxyMsg, sender, tx) {
         const { transaction, transactionLinker } = await this.prepareCrossChainTransaction(evmProxyMsg, sender, tx.assets, tx.options);
         await assets_1.TON.checkBalance(sender, this.config, [transaction]);
+        const shouldWaitForOperationId = tx.options?.waitOperationId ?? true;
         this.logger.debug(`Sending transaction: ${(0, Utils_1.formatObjectForLogging)(transactionLinker)}`);
         const sendTransactionResult = await sender.sendShardTransaction(transaction, this.config.network, this.config.TONParams.contractOpener);
         if (!sendTransactionResult.success || sendTransactionResult.error) {
             throw (0, instances_1.sendCrossChainTransactionFailedError)(sendTransactionResult.error?.message ?? 'Transaction failed to send');
         }
-        const shouldWaitForOperationId = tx.options?.waitOperationId ?? true;
         if (!shouldWaitForOperationId) {
             return { sendTransactionResult, ...transactionLinker };
         }

package/dist/src/sdk/TxFinalizer.js

@@ -17,10 +17,11 @@ class TonTxFinalizer {
         for (let i = retries; i >= 0; i--) {
             try {
                 const url = this.apiConfig.urlBuilder(hash);
+                const authHeaders = this.apiConfig.authorization
+                    ? { [this.apiConfig.authorization.header]: this.apiConfig.authorization.value }
+                    : undefined;
                 const response = await this.httpClient.get(url, {
-                    headers: {
-                        [this.apiConfig.authorization.header]: this.apiConfig.authorization.value,
-                    },
+                    ...(authHeaders ? { headers: authHeaders } : {}),
                     transformResponse: [Utils_1.toCamelCaseTransformer],
                 });
                 return response.data.transactions || [];

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

@@ -42,6 +42,11 @@ export declare function muldivr(a: bigint, b: bigint, c: bigint): bigint;
  * Accepts: base64, hex, or raw string
  */
 export declare function normalizeHashToBase64(hash: string): string;
+/**
+ * Normalize hash string to hex format
+ * Accepts: base64, hex
+ */
+export declare function normalizeHashToHex(hash: string): string;
 export declare function getNormalizedExtMessageHash(message: Message): string;
 export declare function retry<T>(fn: () => Promise<T>, options: {
     retries: number;

package/dist/src/sdk/Utils.js

@@ -21,6 +21,7 @@ exports.getNumber = getNumber;
 exports.getString = getString;
 exports.muldivr = muldivr;
 exports.normalizeHashToBase64 = normalizeHashToBase64;
+exports.normalizeHashToHex = normalizeHashToHex;
 exports.getNormalizedExtMessageHash = getNormalizedExtMessageHash;
 exports.retry = retry;
 exports.recurisivelyCollectCellStats = recurisivelyCollectCellStats;
@@ -322,23 +323,51 @@ function muldivr(a, b, c) {
  * Accepts: base64, hex, or raw string
  */
 function normalizeHashToBase64(hash) {
-    // If already base64 (contains +, /, = or matches base64 pattern)
-    if (/^[A-Za-z0-9+/]+={0,2}$/.test(hash)) {
-        try {
-            // Validate it's valid base64
-            Buffer.from(hash, 'base64');
-            return hash;
-        }
-        catch {
-            // Fall through to hex conversion
-        }
+    const input = hash.trim();
+    if (!input)
+        return input;
+    const hex = input.startsWith('0x') ? input.slice(2) : input;
+    if (/^[0-9a-fA-F]{64}$/.test(hex)) {
+        return Buffer.from(hex, 'hex').toString('base64');
+    }
+    const decoded = decodeBase64Like(input);
+    if (decoded) {
+        return decoded.toString('base64');
+    }
+    return input;
+}
+/**
+ * Normalize hash string to hex format
+ * Accepts: base64, hex
+ */
+function normalizeHashToHex(hash) {
+    const input = hash.trim();
+    if (!input)
+        return input;
+    const maybeHex = input.startsWith('0x') ? input.slice(2) : input;
+    if (/^[0-9a-fA-F]+$/.test(maybeHex) && maybeHex.length % 2 === 0) {
+        return maybeHex.toLowerCase();
+    }
+    const decoded = decodeBase64Like(input);
+    if (decoded) {
+        return decoded.toString('hex');
+    }
+    return input;
+}
+function decodeBase64Like(input) {
+    const normalized = input.replace(/-/g, '+').replace(/_/g, '/');
+    const padLength = normalized.length % 4;
+    const padded = padLength === 0 ? normalized : normalized + '='.repeat(4 - padLength);
+    if (!/^[A-Za-z0-9+/]+={0,2}$/.test(padded)) {
+        return null;
+    }
+    try {
+        const buf = Buffer.from(padded, 'base64');
+        return buf.length > 0 ? buf : null;
     }
-    // Try as hex
-    if (/^[0-9a-fA-F]+$/.test(hash)) {
-        return Buffer.from(hash, 'hex').toString('base64');
+    catch {
+        return null;
     }
-    // Assume it's already base64
-    return hash;
 }
 function getNormalizedExtMessageHash(message) {
     if (message.info.type !== 'external-in') {

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

@@ -106,7 +106,7 @@ export type AdjacentTransactionsResponse = {
 };
 export type TxFinalizerConfig = {
     urlBuilder: (hash: string) => string;
-    authorization: {
+    authorization?: {
         header: string;
         value: string;
     };

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

@@ -456,13 +456,19 @@ export type TrackTransactionTreeParams = {
      */
     limit?: number;
     /**
-     * Maximum depth to traverse in the transaction tree (prevents infinite loops)
+     * Maximum depth to traverse in the transaction tree, inclusive (prevents infinite loops)
      * @default 10
      */
     maxDepth?: number;
     /**
-     * List of operation codes (opcodes) to skip during validation.
-     * Transactions with these opcodes in their incoming message will not be validated.
+     * Maximum number of transactions to scan while searching by hash in account history.
+     * Prevents excessive full-history scans on high-activity accounts.
+     * @default 100
+     */
+    maxScannedTransactions?: number;
+    /**
+     * List of operation codes (opcodes) to skip for extra checks.
+     * Core phase validation is still applied.
      * @default [ 0xd53276db ] // Excess
      */
     ignoreOpcodeList?: number[];
@@ -474,13 +480,19 @@ export type TrackTransactionTreeParams = {
      * @default 'both'
      */
     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.
+     * @default true
+     */
+    waitForRootTransaction?: boolean;
 };
 /**
  * Details about a transaction validation error
  */
 export type TransactionValidationError = {
     /**
-     * Base64-encoded hash of the failed transaction
+     * Base64-encoded hash of the failed transaction (or the searched hash if not found)
      */
     txHash: string;
     /**
@@ -494,11 +506,20 @@ export type TransactionValidationError = {
     /**
      * Reason for validation failure:
      * - 'aborted': default: transaction was aborted
-     * - 'compute_phase_missing': compute phase is missing or skipped
+     * - 'compute_phase_missing': compute phase is missing
      * - 'compute_phase_failed': compute phase failed (exitCode !== 0)
      * - 'action_phase_failed': action phase failed (resultCode !== 0)
+     * - 'not_found': transaction or message hash not found during traversal
      */
-    reason: 'aborted' | 'compute_phase_missing' | 'compute_phase_failed' | 'action_phase_failed';
+    reason: 'aborted' | 'compute_phase_missing' | 'compute_phase_failed' | 'action_phase_failed' | 'not_found';
+    /**
+     * Address where the lookup was performed (for reason: 'not_found')
+     */
+    address?: string;
+    /**
+     * Hash type used in lookup (for reason: 'not_found')
+     */
+    hashType?: 'unknown' | 'in' | 'out';
 };
 /**
  * Result of transaction tree tracking and validation
@@ -508,6 +529,10 @@ export type TrackTransactionTreeResult = {
      * Whether all transactions in the tree passed validation
      */
     success: boolean;
+    /**
+     * Count of unique transactions checked during traversal
+     */
+    checkedCount?: number;
     /**
      * Details about the first validation error encountered (if any)
      */
@@ -530,6 +555,8 @@ export type GetTransactionsOptions = {
     timeoutMs?: number;
     /** Delay between retry attempts in milliseconds */
     retryDelayMs?: number;
+    /** Internal scan guard: maximum transactions to inspect while traversing history */
+    maxScannedTransactions?: number;
 };
 export type AddressInformation = {
     /** Information about the last transaction of the address */

package/package.json

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