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

package/dist/src/adapters/RetryableContractOpener.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RetryableContractOpener = void 0;
 exports.createDefaultRetryableOpener = createDefaultRetryableOpener;
 const ton_1 = require("@ton/ton");
+const errors_1 = require("../errors");
 const instances_1 = require("../errors/instances");
 const Consts_1 = require("../sdk/Consts");
 const Struct_1 = require("../structs/Struct");
@@ -16,24 +17,40 @@ class RetryableContractOpener {
         }
         this.openerConfigs = openerConfigs;
         this.logger = logger;
+        if (logger) {
+            this.applyLoggerToOpeners(logger);
+        }
+    }
+    setLogger(logger) {
+        if (!this.logger) {
+            this.logger = logger;
+        }
+        this.applyLoggerToOpeners(logger);
+    }
+    applyLoggerToOpeners(logger) {
+        for (const config of this.openerConfigs) {
+            config.opener.setLogger(logger);
+        }
     }
     async getTransactions(address, opts) {
-        const result = await this.executeWithFallback((config) => config.opener.getTransactions(address, opts));
-        if (result.success && result.data) {
+        const result = await this.executeWithFallback((config) => config.opener.getTransactions(address, opts), {
+            operationName: 'getTransactions',
+        });
+        if (result.success && result.data !== undefined) {
             return result.data;
         }
         throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to get transactions');
     }
     async getTransactionByHash(address, hash, opts) {
-        const result = await this.executeWithFallback((config) => config.opener.getTransactionByHash(address, hash, opts));
-        if (result.success && result.data) {
-            return result.data;
+        const result = await this.executeWithFallback((config) => config.opener.getTransactionByHash(address, hash, opts), { operationName: 'getTransactionByHash' });
+        if (result.success) {
+            return result.data ?? null;
         }
         throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to get transaction by hash');
     }
     async getAdjacentTransactions(address, hash, opts) {
-        const result = await this.executeWithFallback((config) => config.opener.getAdjacentTransactions(address, hash, opts));
-        if (result.success && result.data) {
+        const result = await this.executeWithFallback((config) => config.opener.getAdjacentTransactions(address, hash, opts), { operationName: 'getAdjacentTransactions' });
+        if (result.success && result.data !== undefined) {
             return result.data;
         }
         throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to get adjacent transactions');
@@ -44,42 +61,48 @@ class RetryableContractOpener {
         return this.createRetryableContract(contract, src);
     }
     async getContractState(address) {
-        const result = await this.executeWithFallback((config) => config.opener.getContractState(address));
-        if (result.success && result.data) {
+        const result = await this.executeWithFallback((config) => config.opener.getContractState(address), {
+            operationName: 'getContractState',
+        });
+        if (result.success && result.data !== undefined) {
             return result.data;
         }
         throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to get contract state');
     }
     async getAddressInformation(address) {
-        const result = await this.executeWithFallback((config) => config.opener.getAddressInformation(address));
-        if (result.success && result.data) {
+        const result = await this.executeWithFallback((config) => config.opener.getAddressInformation(address), {
+            operationName: 'getAddressInformation',
+        });
+        if (result.success && result.data !== undefined) {
             return result.data;
         }
         throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to get address information');
     }
     async getConfig() {
-        const result = await this.executeWithFallback((config) => config.opener.getConfig());
-        if (result.success && result.data) {
+        const result = await this.executeWithFallback((config) => config.opener.getConfig(), {
+            operationName: 'getConfig',
+        });
+        if (result.success && result.data !== undefined) {
             return result.data;
         }
         throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to get blockchain config');
     }
     async getTransactionByTxHash(address, txHash, opts) {
-        const result = await this.executeWithFallback((config) => config.opener.getTransactionByTxHash(address, txHash, opts));
+        const result = await this.executeWithFallback((config) => config.opener.getTransactionByTxHash(address, txHash, opts), { operationName: 'getTransactionByTxHash' });
         if (result.success) {
             return result.data ?? null;
         }
         throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to get transaction by transaction hash');
     }
     async getTransactionByInMsgHash(address, msgHash, opts) {
-        const result = await this.executeWithFallback((config) => config.opener.getTransactionByInMsgHash(address, msgHash, opts));
+        const result = await this.executeWithFallback((config) => config.opener.getTransactionByInMsgHash(address, msgHash, opts), { operationName: 'getTransactionByInMsgHash' });
         if (result.success) {
             return result.data ?? null;
         }
         throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to get transaction by message hash');
     }
     async getTransactionByOutMsgHash(address, msgHash, opts) {
-        const result = await this.executeWithFallback((config) => config.opener.getTransactionByOutMsgHash(address, msgHash, opts));
+        const result = await this.executeWithFallback((config) => config.opener.getTransactionByOutMsgHash(address, msgHash, opts), { operationName: 'getTransactionByOutMsgHash' });
         if (result.success) {
             return result.data ?? null;
         }
@@ -91,34 +114,76 @@ class RetryableContractOpener {
         }
     }
     async trackTransactionTree(address, hash, params) {
-        const result = await this.executeWithFallback(async (config) => {
-            return config.opener.trackTransactionTree(address, hash, params);
+        const result = await this.executeWithFallback(async (config) => config.opener.trackTransactionTree(address, hash, params), {
+            shouldFallbackOnError: (error) => this.isTransportError(error),
+            operationName: 'trackTransactionTree',
         });
         if (!result.success) {
+            if (result.lastError instanceof errors_1.TransactionError) {
+                throw result.lastError;
+            }
             throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to track transaction tree');
         }
     }
     async trackTransactionTreeWithResult(address, hash, params) {
-        const result = await this.executeWithFallback(async (config) => {
-            return config.opener.trackTransactionTreeWithResult(address, hash, params);
+        const result = await this.executeWithFallback(async (config) => config.opener.trackTransactionTreeWithResult(address, hash, params), {
+            shouldFallbackOnError: (error) => this.isTransportError(error),
+            operationName: 'trackTransactionTreeWithResult',
         });
         if (!result.success) {
+            if (result.lastError instanceof errors_1.TransactionError) {
+                throw result.lastError;
+            }
             throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to track transaction tree with result');
         }
         return result.data;
     }
-    async executeWithFallback(operation) {
+    async executeWithFallback(operation, options = {}) {
+        const { useRetries = true, shouldFallbackOnError, operationName = 'operation' } = options;
         let lastError;
-        for (const config of this.openerConfigs) {
-            const result = await this.tryWithRetries(() => operation(config), config);
+        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)'}`);
+            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;
+            if (lastError) {
+                this.logger?.debug(`[RetryableContractOpener] ${operationName}: ${openerLabel} failed: ${lastError.message}`);
+            }
+            if (lastError instanceof errors_1.TransactionError) {
+                this.logger?.debug(`[RetryableContractOpener] ${operationName}: stopping fallback because of TransactionError`);
+                return { success: false, lastError };
+            }
+            if (lastError && this.isContractExecutionError(lastError)) {
+                this.logger?.debug(`[RetryableContractOpener] ${operationName}: stopping fallback because of contract execution error`);
+                return { success: false, lastError };
+            }
+            if (lastError && shouldFallbackOnError) {
+                const shouldFallback = shouldFallbackOnError(lastError);
+                if (!shouldFallback) {
+                    this.logger?.debug(`[RetryableContractOpener] ${operationName}: stopping fallback due to non-transport error`);
+                    return { success: false, lastError };
+                }
+            }
         }
         return { success: false, lastError };
     }
-    async tryWithRetries(operation, config) {
+    async trySingleAttempt(operation) {
+        try {
+            const data = await operation();
+            return { success: true, data };
+        }
+        catch (error) {
+            return { success: false, lastError: error };
+        }
+    }
+    async tryWithRetries(operation, config, operationContext = 'operation') {
         let lastError;
         for (let attempt = 0; attempt <= config.retries; attempt++) {
             try {
@@ -127,13 +192,45 @@ class RetryableContractOpener {
             }
             catch (error) {
                 lastError = error;
+                if (lastError instanceof errors_1.TransactionError || this.isContractExecutionError(lastError)) {
+                    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`);
                     await sleep(config.retryDelay);
                 }
             }
         }
         return { success: false, lastError };
     }
+    isContractExecutionError(error) {
+        const errorWithExit = error;
+        if (typeof errorWithExit.exitCode === 'number' ||
+            typeof errorWithExit.vmExitCode === 'number' ||
+            typeof errorWithExit.exit_code === 'number') {
+            return true;
+        }
+        const message = String(error.message ?? error);
+        return (/unable to execute get method/i.test(message) ||
+            /exit[_\s-]*code\s*:\s*\d+/i.test(message) ||
+            /vm exit code\s*:\s*\d+/i.test(message));
+    }
+    isTransportError(error) {
+        if (error instanceof errors_1.TransactionError) {
+            return false;
+        }
+        const errorWithResponse = error;
+        const status = errorWithResponse.response?.status ?? errorWithResponse.response?.statusCode;
+        if (typeof status === 'number') {
+            return status === 429 || status >= 500;
+        }
+        const code = errorWithResponse.code ?? '';
+        if (['ETIMEDOUT', 'ECONNRESET', 'ENOTFOUND', 'EAI_AGAIN'].includes(code)) {
+            return true;
+        }
+        const message = String(error.message ?? error);
+        return /too many requests|timeout|timed out|network|connection/i.test(message);
+    }
     createRetryableContract(contract, src) {
         return new Proxy(contract, {
             get: (target, prop) => {
@@ -147,6 +244,7 @@ class RetryableContractOpener {
         });
     }
     async callMethodAcrossOpeners(methodName, args, src) {
+        const addressLabel = src.address ? src.address.toString() : 'unknown';
         const result = await this.executeWithFallback((config) => {
             const contract = config.opener.open(src);
             const method = Reflect.get(contract, methodName);
@@ -154,7 +252,7 @@ class RetryableContractOpener {
                 throw new Error(`Method ${String(methodName)} is not a function`);
             }
             return method.call(contract, ...args);
-        });
+        }, { operationName: `${String(methodName)} (address=${addressLabel})` });
         if (result.success)
             return result.data;
         throw result.lastError || (0, instances_1.allContractOpenerFailedError)('failed to call method in contract');
@@ -163,19 +261,22 @@ class RetryableContractOpener {
 exports.RetryableContractOpener = RetryableContractOpener;
 async function createDefaultRetryableOpener(tonRpcEndpoint, networkType, maxRetries = Consts_1.DEFAULT_RETRY_MAX_COUNT, retryDelay = Consts_1.DEFAULT_RETRY_DELAY_MS, logger) {
     const openers = [];
-    const tonClient = new ton_1.TonClient({ endpoint: new URL('api/v2/jsonRPC', tonRpcEndpoint).toString() });
-    const opener = (0, TonClientOpener_1.tonClientOpener)(tonClient);
+    const tonClient = new ton_1.TonClient({
+        endpoint: new URL('api/v2/jsonRPC', tonRpcEndpoint).toString(),
+        timeout: Consts_1.DEFAULT_HTTP_CLIENT_TIMEOUT_MS,
+    });
+    const opener = (0, TonClientOpener_1.tonClientOpener)(tonClient, logger);
     openers.push({ opener, retries: maxRetries, retryDelay });
     if (networkType !== Struct_1.Network.DEV) {
         try {
-            const opener = await (0, TonClientOpener_1.orbsOpener)(networkType);
+            const opener = await (0, TonClientOpener_1.orbsOpener)(networkType, logger);
             openers.push({ opener: opener, retries: maxRetries, retryDelay });
         }
         catch {
             // skip opener in case of failure
         }
         try {
-            const opener4 = await (0, TonClient4Opener_1.orbsOpener4)(networkType);
+            const opener4 = await (0, TonClient4Opener_1.orbsOpener4)(networkType, Consts_1.DEFAULT_HTTP_CLIENT_TIMEOUT_MS, logger);
             openers.push({ opener: opener4, retries: maxRetries, retryDelay });
         }
         catch {

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

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

package/dist/src/adapters/TonClient4Opener.js

@@ -10,13 +10,13 @@ const Struct_1 = require("../structs/Struct");
 const BaseContractOpener_1 = require("./BaseContractOpener");
 const OpenerUtils_1 = require("./OpenerUtils");
 class TonClient4Opener extends BaseContractOpener_1.BaseContractOpener {
-    constructor(client4) {
-        super();
+    constructor(client4, logger) {
+        super(logger);
         this.client4 = client4;
     }
-    static create(endpoint, timeout = 10000) {
+    static create(endpoint, timeout = 10000, logger) {
         const client4 = new ton_1.TonClient4({ endpoint, timeout });
-        return new TonClient4Opener(client4);
+        return new TonClient4Opener(client4, logger);
     }
     open(contract) {
         return this.client4.open(contract);
@@ -71,16 +71,17 @@ exports.TonClient4Opener = TonClient4Opener;
  * Creates a TonClient4Opener instance using TonHub public API
  * @param network Network to connect to (mainnet or testnet)
  * @param timeout Request timeout in milliseconds
+ * @param logger
  */
-function tonHubApi4Opener(network, timeout = Consts_1.DEFAULT_HTTP_CLIENT_TIMEOUT_MS) {
+function tonHubApi4Opener(network, timeout = Consts_1.DEFAULT_HTTP_CLIENT_TIMEOUT_MS, logger) {
     const endpoint = network === Struct_1.Network.MAINNET ? 'https://mainnet-v4.tonhubapi.com' : 'https://testnet-v4.tonhubapi.com';
-    return TonClient4Opener.create(endpoint, timeout);
+    return TonClient4Opener.create(endpoint, timeout, logger);
 }
-function tonClient4Opener(client) {
-    return new TonClient4Opener(client);
+function tonClient4Opener(client, logger) {
+    return new TonClient4Opener(client, logger);
 }
-async function orbsOpener4(network, timeout = Consts_1.DEFAULT_HTTP_CLIENT_TIMEOUT_MS) {
+async function orbsOpener4(network, timeout = Consts_1.DEFAULT_HTTP_CLIENT_TIMEOUT_MS, logger) {
     const endpoint = await (0, OpenerUtils_1.getHttpV4EndpointWithRetry)(network);
     const client = new ton_1.TonClient4({ endpoint, timeout });
-    return new TonClient4Opener(client);
+    return new TonClient4Opener(client, logger);
 }

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

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

package/dist/src/adapters/TonClientOpener.js

@@ -6,17 +6,18 @@ exports.orbsOpener = orbsOpener;
 const ton_1 = require("@ton/ton");
 const AxiosHttpClient_1 = require("../sdk/AxiosHttpClient");
 const Consts_1 = require("../sdk/Consts");
+const Utils_1 = require("../sdk/Utils");
 const BaseContractOpener_1 = require("./BaseContractOpener");
 const OpenerUtils_1 = require("./OpenerUtils");
 class TonClientOpener extends BaseContractOpener_1.BaseContractOpener {
-    constructor(client) {
-        super();
+    constructor(client, logger) {
+        super(logger);
         this.client = client;
         this.httpClient = new AxiosHttpClient_1.AxiosHttpClient({ timeout: Consts_1.DEFAULT_HTTP_CLIENT_TIMEOUT_MS });
     }
-    static create(endpoint, timeout = Consts_1.DEFAULT_HTTP_CLIENT_TIMEOUT_MS) {
+    static create(endpoint, timeout = Consts_1.DEFAULT_HTTP_CLIENT_TIMEOUT_MS, logger) {
         const client = new ton_1.TonClient({ endpoint, timeout });
-        return new TonClientOpener(client);
+        return new TonClientOpener(client, logger);
     }
     open(contract) {
         return this.client.open(contract);
@@ -29,7 +30,8 @@ class TonClientOpener extends BaseContractOpener_1.BaseContractOpener {
         const clientOpts = {
             limit: opts.limit ?? Consts_1.DEFAULT_FIND_TX_LIMIT,
             lt: opts.lt,
-            hash: opts.hash,
+            // TonClient API expects base64 transaction hash and converts it to hex internally.
+            hash: opts.hash ? (0, Utils_1.normalizeHashToBase64)(opts.hash) : undefined,
             to_lt: opts.to_lt,
             inclusive: opts.inclusive,
             archival: opts.archival,
@@ -60,11 +62,11 @@ class TonClientOpener extends BaseContractOpener_1.BaseContractOpener {
     }
 }
 exports.TonClientOpener = TonClientOpener;
-function tonClientOpener(client) {
-    return new TonClientOpener(client);
+function tonClientOpener(client, logger) {
+    return new TonClientOpener(client, logger);
 }
-async function orbsOpener(network) {
+async function orbsOpener(network, logger) {
     const endpoint = await (0, OpenerUtils_1.getHttpEndpointWithRetry)(network);
-    const client = new ton_1.TonClient({ endpoint });
-    return new TonClientOpener(client);
+    const client = new ton_1.TonClient({ endpoint, timeout: Consts_1.DEFAULT_HTTP_CLIENT_TIMEOUT_MS });
+    return new TonClientOpener(client, logger);
 }

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

@@ -1,6 +1,7 @@
 import { SandboxContract } from '@ton/sandbox';
 import type { Address, Contract, OpenedContract, Transaction } from '@ton/ton';
 import { AddressInformation, ContractState, GetTransactionsOptions, TrackTransactionTreeParams, TrackTransactionTreeResult } from '../structs/Struct';
+import { ILogger } from './ILogger';
 export interface ContractOpener {
     /**
      * Opens a contract for interaction using the underlying client (lite client, sandbox, etc.).
@@ -78,7 +79,7 @@ export interface ContractOpener {
      * @param address Root account address
      * @param hash Root transaction or message hash
      * @param params Tracking parameters (maxDepth, ignoreOpcodeList, etc.)
-     * @throws Error if any transaction in the tree failed
+     * @throws Error if any transaction in the tree failed or if a hash is not found
      */
     trackTransactionTree(address: string, hash: string, params?: TrackTransactionTreeParams): Promise<void>;
     /**
@@ -87,7 +88,8 @@ export interface ContractOpener {
      * @param address Root account address
      * @param hash Root transaction or message hash
      * @param params Tracking parameters (maxDepth, ignoreOpcodeList, etc.)
-     * @returns Result object with success flag and error details if validation failed
+     * @returns Result object with success flag and error details if validation failed or a hash was not found
      */
     trackTransactionTreeWithResult(address: string, hash: string, params?: TrackTransactionTreeParams): Promise<TrackTransactionTreeResult>;
+    setLogger(logger: ILogger): void;
 }

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

@@ -2,7 +2,7 @@ import { Wallet } from 'ethers';
 import { JettonMinterData, NFTItemData } from '../../artifacts/tonTypes';
 import { FT, NFT } from '../assets';
 import type { SenderAbstraction } from '../sender';
-import { AssetFromFTArg, AssetFromNFTCollectionArg, AssetFromNFTItemArg, AssetLike, BatchCrossChainTxWithAssetLike, CrossChainPayloadResult, CrossChainTransactionOptions, CrossChainTransactionsOptions, CrosschainTx, EVMAddress, EvmProxyMsg, ExecutionFeeEstimationResult, NFTAddressType, SuggestedTVMExecutorFee, TACSimulationParams, TACSimulationResult, TransactionLinkerWithOperationId, TVMAddress, UserWalletBalanceExtended, WaitOptions } from '../structs/Struct';
+import { AssetFromFTArg, AssetFromNFTCollectionArg, AssetFromNFTItemArg, AssetLike, BatchCrossChainTxWithAssetLike, CrossChainPayloadResult, CrossChainTransactionOptions, CrossChainTransactionsOptions, CrosschainTx, EVMAddress, EvmProxyMsg, ExecutionFeeEstimationResult, NFTAddressType, SuggestedTVMExecutorFee, TacGasPrice, TACSimulationParams, TACSimulationResult, TransactionLinkerWithOperationId, TVMAddress, UserWalletBalanceExtended, WaitOptions } from '../structs/Struct';
 import { Asset } from './Asset';
 import { ContractOpener } from './ContractOpener';
 import { IConfiguration } from './IConfiguration';
@@ -201,4 +201,9 @@ export interface ITacSDK {
      * @returns Promise with the prepared transaction payloads.
      */
     prepareCrossChainTransactionPayload(evmProxyMsg: EvmProxyMsg, senderAddress: string, assets?: AssetLike[], options?: CrossChainTransactionOptions): Promise<CrossChainPayloadResult[]>;
+    /**
+     * Returns TAC gas price for the current network.
+     * @returns Promise resolving to the gas price in wei (bigint).
+     */
+    getTACGasPrice(): Promise<TacGasPrice>;
 }

package/dist/src/sdk/Configuration.js

@@ -55,6 +55,7 @@ class Configuration {
                     (await (0, adapters_1.createDefaultRetryableOpener)(artifacts.TON_RPC_ENDPOINT_BY_TAC, network, 5, delay, logger));
             settingsAddress = TONParams?.settingsAddress ?? artifacts.TON_SETTINGS_ADDRESS;
         }
+        contractOpener.setLogger(logger);
         const settings = contractOpener.open(artifacts.ton.wrappers.Settings.createFromAddress(ton_1.Address.parse(settingsAddress)));
         const allSettingsSlice = (await settings.getAll()).beginParse();
         const allSettings = allSettingsSlice.loadDictDirect(ton_1.Dictionary.Keys.BigUint(256), ton_1.Dictionary.Values.Cell());

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

@@ -14,13 +14,17 @@ export declare const ONE_YEAR_SECONDS: number;
 export declare const TON_DECIMALS = 9;
 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_HTTP_CLIENT_TIMEOUT_MS = 30000;
-export declare const DEFAULT_FIND_TX_TIMEOUT_MS = 180000;
 export declare const DEFAULT_RETRY_MAX_COUNT = 5;
 export declare const DEFAULT_RETRY_DELAY_MS = 1000;
-export declare const DEFAULT_FIND_TX_LIMIT = 10;
+export declare const DEFAULT_FIND_TX_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 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_FIND_TX_MAX_DEPTH = exports.DEFAULT_FIND_TX_ARCHIVAL = exports.DEFAULT_FIND_TX_LIMIT = exports.DEFAULT_RETRY_DELAY_MS = exports.DEFAULT_RETRY_MAX_COUNT = exports.DEFAULT_FIND_TX_TIMEOUT_MS = exports.DEFAULT_HTTP_CLIENT_TIMEOUT_MS = exports.TON_BURN_ADDRESS = exports.FIVE_MINUTES = exports.TAC_DECIMALS = exports.TON_DECIMALS = exports.ONE_YEAR_SECONDS = exports.FIFTEEN_MINUTES = exports.TAC_SYMBOL = exports.TON_SYMBOL = exports.MAX_MSG_DEPTH = exports.MAX_HIGHLOAD_GROUP_MSG_NUM = exports.MAX_EXT_MSG_SIZE = exports.SOLIDITY_METHOD_NAME_REGEX = exports.SOLIDITY_SIGNATURE_REGEX = exports.DEFAULT_DELAY = exports.MAX_ITERATION_COUNT = exports.NFT_TRANSFER_FORWARD_TON_AMOUNT = exports.JETTON_TRANSFER_FORWARD_TON_AMOUNT = void 0;
+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.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);
@@ -18,14 +18,18 @@ exports.ONE_YEAR_SECONDS = 365 * 24 * 3600;
 exports.TON_DECIMALS = 9;
 exports.TAC_DECIMALS = 18;
 exports.FIVE_MINUTES = 5 * 60 * 1000;
+exports.MINUTE = 60 * 1000;
 exports.TON_BURN_ADDRESS = 'EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c';
 exports.DEFAULT_HTTP_CLIENT_TIMEOUT_MS = 30000;
-exports.DEFAULT_FIND_TX_TIMEOUT_MS = 180000;
 exports.DEFAULT_RETRY_MAX_COUNT = 5;
 exports.DEFAULT_RETRY_DELAY_MS = 1000;
-exports.DEFAULT_FIND_TX_LIMIT = 10;
+exports.DEFAULT_FIND_TX_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.IGNORE_MSG_VALUE_1_NANO = 1n;
 exports.IGNORE_OPCODE = [
     0xd53276db, // Excess

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

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

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 };
         }