@tonappchain/sdk 0.6.5-mainnet-alpha → 0.6.6-mainnet-alpha

package/dist/adapters/contractOpener.js

@@ -70,8 +70,7 @@ async function orbsOpener(network) {
     const endpoint = await (0, ton_access_1.getHttpEndpoint)({
         network,
     });
-    const client = new ton_1.TonClient({ endpoint });
-    return client;
+    return new ton_1.TonClient({ endpoint });
 }
 async function orbsOpener4(network, timeout = 10000) {
     const endpoint = await (0, ton_access_1.getHttpV4Endpoint)({ network });

package/dist/adapters/retryableContractOpener.d.ts

@@ -0,0 +1,21 @@
+import { ContractOpener, ContractState } from '../structs/Struct';
+import { Address, Contract, OpenedContract } from '@ton/ton';
+import { SandboxContract } from '@ton/sandbox';
+import { mainnet, testnet } from '@tonappchain/artifacts';
+export interface OpenerConfig {
+    opener: ContractOpener;
+    retries: number;
+    retryDelay: number;
+}
+export declare class RetryableContractOpener implements ContractOpener {
+    private readonly openerConfigs;
+    constructor(openerConfigs: OpenerConfig[]);
+    open<T extends Contract>(src: T): OpenedContract<T> | SandboxContract<T>;
+    getContractState(address: Address): Promise<ContractState>;
+    closeConnections(): void;
+    private executeWithFallback;
+    private tryWithRetries;
+    private createRetryableContract;
+    private callMethodAcrossOpeners;
+}
+export declare function createDefaultRetryableOpener(artifacts: typeof testnet | typeof mainnet, maxRetries?: number, retryDelay?: number): Promise<ContractOpener>;

package/dist/adapters/retryableContractOpener.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryableContractOpener = void 0;
+exports.createDefaultRetryableOpener = createDefaultRetryableOpener;
+const Struct_1 = require("../structs/Struct");
+const ton_1 = require("@ton/ton");
+const artifacts_1 = require("@tonappchain/artifacts");
+const contractOpener_1 = require("./contractOpener");
+const instances_1 = require("../errors/instances");
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+class RetryableContractOpener {
+    constructor(openerConfigs) {
+        if (openerConfigs.length === 0) {
+            throw new Error('No ContractOpener instances available');
+        }
+        this.openerConfigs = openerConfigs;
+    }
+    open(src) {
+        const firstConfig = this.openerConfigs[0];
+        const contract = firstConfig.opener.open(src);
+        return this.createRetryableContract(contract, src);
+    }
+    async getContractState(address) {
+        const result = await this.executeWithFallback((config) => config.opener.getContractState(address));
+        if (result.success && result.data) {
+            return result.data;
+        }
+        throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to get contract state');
+    }
+    closeConnections() {
+        for (const config of this.openerConfigs) {
+            config.opener.closeConnections?.();
+        }
+    }
+    async executeWithFallback(operation) {
+        let lastError;
+        for (const config of this.openerConfigs) {
+            const result = await this.tryWithRetries(() => operation(config), config);
+            if (result.success) {
+                return { success: true, data: result.data };
+            }
+            lastError = result.lastError;
+        }
+        return { success: false, lastError };
+    }
+    async tryWithRetries(operation, config) {
+        let lastError;
+        for (let attempt = 0; attempt <= config.retries; attempt++) {
+            try {
+                const data = await operation();
+                return { success: true, data };
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt < config.retries) {
+                    await sleep(config.retryDelay);
+                }
+            }
+        }
+        return { success: false, lastError };
+    }
+    createRetryableContract(contract, src) {
+        return new Proxy(contract, {
+            get: (target, prop) => {
+                const value = Reflect.get(target, prop);
+                if (typeof value !== 'function')
+                    return value;
+                return async (...args) => {
+                    return this.callMethodAcrossOpeners(prop, args, src);
+                };
+            },
+        });
+    }
+    async callMethodAcrossOpeners(methodName, args, src) {
+        const result = await this.executeWithFallback((config) => {
+            const contract = config.opener.open(src);
+            const method = Reflect.get(contract, methodName);
+            if (typeof method !== 'function') {
+                throw new Error(`Method ${String(methodName)} is not a function`);
+            }
+            return method.call(contract, ...args);
+        });
+        if (result.success)
+            return result.data;
+        throw result.lastError || (0, instances_1.allContractOpenerFailedError)('failed to call method in contract');
+    }
+}
+exports.RetryableContractOpener = RetryableContractOpener;
+async function createDefaultRetryableOpener(artifacts, maxRetries = 3, retryDelay = 1000) {
+    const tonClient = new ton_1.TonClient({
+        endpoint: new URL('api/v2/jsonRPC', artifacts.TON_RPC_ENDPOINT_BY_TAC).toString(),
+    });
+    const network = artifacts === artifacts_1.testnet ? Struct_1.Network.TESTNET : Struct_1.Network.MAINNET;
+    const opener4 = await (0, contractOpener_1.orbsOpener4)(network);
+    const opener = await (0, contractOpener_1.orbsOpener)(network);
+    return new RetryableContractOpener([
+        { opener: tonClient, retries: maxRetries, retryDelay },
+        { opener: opener4, retries: maxRetries, retryDelay },
+        { opener: opener, retries: maxRetries, retryDelay },
+    ]);
+}

package/dist/errors/index.d.ts

@@ -1,2 +1,2 @@
-export { emptyContractError, operationFetchError, statusFetchError, tvmAddressError, evmAddressError, unknownWalletError, unsupportedKeyError, unsupportedFormatError, notMultiplyOf8Error, prefixError, emptySettingError, invalidMethodNameError, simulationError, emptyArrayError, profilingFetchError, } from './instances';
+export { emptyContractError, operationFetchError, statusFetchError, tvmAddressError, evmAddressError, unknownWalletError, unsupportedKeyError, unsupportedFormatError, notMultiplyOf8Error, prefixError, emptySettingError, invalidMethodNameError, simulationError, emptyArrayError, profilingFetchError, allEndpointsFailedError, } from './instances';
 export { ContractError, FetchError, AddressError, WalletError, KeyError, FormatError, BitError, MetadataError, SettingError, EVMCallError, } from './errors';

package/dist/errors/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EVMCallError = exports.SettingError = exports.MetadataError = exports.BitError = exports.FormatError = exports.KeyError = exports.WalletError = exports.AddressError = exports.FetchError = exports.ContractError = exports.profilingFetchError = exports.emptyArrayError = exports.simulationError = exports.invalidMethodNameError = exports.emptySettingError = exports.prefixError = exports.notMultiplyOf8Error = exports.unsupportedFormatError = exports.unsupportedKeyError = exports.unknownWalletError = exports.evmAddressError = exports.tvmAddressError = exports.statusFetchError = exports.operationFetchError = exports.emptyContractError = void 0;
+exports.EVMCallError = exports.SettingError = exports.MetadataError = exports.BitError = exports.FormatError = exports.KeyError = exports.WalletError = exports.AddressError = exports.FetchError = exports.ContractError = exports.allEndpointsFailedError = exports.profilingFetchError = exports.emptyArrayError = exports.simulationError = exports.invalidMethodNameError = exports.emptySettingError = exports.prefixError = exports.notMultiplyOf8Error = exports.unsupportedFormatError = exports.unsupportedKeyError = exports.unknownWalletError = exports.evmAddressError = exports.tvmAddressError = exports.statusFetchError = exports.operationFetchError = exports.emptyContractError = void 0;
 var instances_1 = require("./instances");
 Object.defineProperty(exports, "emptyContractError", { enumerable: true, get: function () { return instances_1.emptyContractError; } });
 Object.defineProperty(exports, "operationFetchError", { enumerable: true, get: function () { return instances_1.operationFetchError; } });
@@ -17,6 +17,7 @@ Object.defineProperty(exports, "invalidMethodNameError", { enumerable: true, get
 Object.defineProperty(exports, "simulationError", { enumerable: true, get: function () { return instances_1.simulationError; } });
 Object.defineProperty(exports, "emptyArrayError", { enumerable: true, get: function () { return instances_1.emptyArrayError; } });
 Object.defineProperty(exports, "profilingFetchError", { enumerable: true, get: function () { return instances_1.profilingFetchError; } });
+Object.defineProperty(exports, "allEndpointsFailedError", { enumerable: true, get: function () { return instances_1.allEndpointsFailedError; } });
 var errors_1 = require("./errors");
 Object.defineProperty(exports, "ContractError", { enumerable: true, get: function () { return errors_1.ContractError; } });
 Object.defineProperty(exports, "FetchError", { enumerable: true, get: function () { return errors_1.FetchError; } });

package/dist/errors/instances.d.ts

@@ -1,7 +1,7 @@
 import { ContractError, FetchError, AddressError, WalletError, KeyError, FormatError, BitError, MetadataError, SettingError, EVMCallError, NoValidGroupFoundError, PrepareMessageGroupError } from './errors';
 export declare const emptyContractError: ContractError;
-export declare const operationFetchError: FetchError;
-export declare const statusFetchError: (msg: string) => FetchError;
+export declare const operationFetchError: (msg: string, inner?: unknown) => FetchError;
+export declare const statusFetchError: (msg: string, inner?: unknown) => FetchError;
 export declare const tvmAddressError: (addr: string) => AddressError;
 export declare const evmAddressError: (addr: string) => AddressError;
 export declare const unknownWalletError: (version: string) => WalletError;
@@ -12,8 +12,10 @@ export declare const prefixError: MetadataError;
 export declare const emptySettingError: (setting: string) => SettingError;
 export declare const invalidMethodNameError: (methodName: string) => EVMCallError;
 export declare const simulationError: (inner: unknown) => FetchError;
-export declare const profilingFetchError: (msg: string) => FetchError;
+export declare const profilingFetchError: (msg: string, inner?: unknown) => FetchError;
 export declare const emptyArrayError: (msg: string) => FetchError;
 export declare const invalidAssetType: FormatError;
 export declare const prepareMessageGroupError: (isBocSizeValid: boolean, isDepthValid: boolean) => PrepareMessageGroupError;
 export declare const noValidGroupFoundError: NoValidGroupFoundError;
+export declare const allEndpointsFailedError: (inner: unknown) => FetchError;
+export declare const allContractOpenerFailedError: (inner: unknown) => FetchError;

package/dist/errors/instances.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.noValidGroupFoundError = exports.prepareMessageGroupError = exports.invalidAssetType = exports.emptyArrayError = exports.profilingFetchError = exports.simulationError = exports.invalidMethodNameError = exports.emptySettingError = exports.prefixError = exports.notMultiplyOf8Error = exports.unsupportedFormatError = exports.unsupportedKeyError = exports.unknownWalletError = exports.evmAddressError = exports.tvmAddressError = exports.statusFetchError = exports.operationFetchError = exports.emptyContractError = void 0;
+exports.allContractOpenerFailedError = exports.allEndpointsFailedError = exports.noValidGroupFoundError = exports.prepareMessageGroupError = exports.invalidAssetType = exports.emptyArrayError = exports.profilingFetchError = exports.simulationError = exports.invalidMethodNameError = exports.emptySettingError = exports.prefixError = exports.notMultiplyOf8Error = exports.unsupportedFormatError = exports.unsupportedKeyError = exports.unknownWalletError = exports.evmAddressError = exports.tvmAddressError = exports.statusFetchError = exports.operationFetchError = exports.emptyContractError = void 0;
 const errors_1 = require("./errors");
 exports.emptyContractError = new errors_1.ContractError('unexpected empty contract code of given jetton.', 100);
-exports.operationFetchError = new errors_1.FetchError('failed to fetch OperationId', 101);
-const statusFetchError = (msg) => new errors_1.FetchError(`failed to fetch status transaction: ${msg}`, 102);
+const operationFetchError = (msg, inner) => new errors_1.FetchError(`failed to fetch OperationId: ${msg}`, 101, inner);
+exports.operationFetchError = operationFetchError;
+const statusFetchError = (msg, inner) => new errors_1.FetchError(`failed to fetch status transaction: ${msg}`, 102, inner);
 exports.statusFetchError = statusFetchError;
 const tvmAddressError = (addr) => new errors_1.AddressError(`invalid tvm address ${addr}`, 103);
 exports.tvmAddressError = tvmAddressError;
@@ -23,7 +24,7 @@ const invalidMethodNameError = (methodName) => new errors_1.EVMCallError(`Invali
 exports.invalidMethodNameError = invalidMethodNameError;
 const simulationError = (inner) => new errors_1.FetchError(`Failed to simulate EVM call: ${inner}`, 112, inner);
 exports.simulationError = simulationError;
-const profilingFetchError = (msg) => new errors_1.FetchError(`failed to fetch stage profiling: ${msg}`, 113);
+const profilingFetchError = (msg, inner) => new errors_1.FetchError(`failed to fetch stage profiling: ${msg}`, 113, inner);
 exports.profilingFetchError = profilingFetchError;
 const emptyArrayError = (msg) => new errors_1.FetchError(`empty array: ${msg}`, 114);
 exports.emptyArrayError = emptyArrayError;
@@ -31,3 +32,7 @@ exports.invalidAssetType = new errors_1.FormatError('Invalid asset type', 115);
 const prepareMessageGroupError = (isBocSizeValid, isDepthValid) => new errors_1.PrepareMessageGroupError(`Failed to prepare message group: BOC size valid: ${isBocSizeValid}, depth valid: ${isDepthValid}`, 116);
 exports.prepareMessageGroupError = prepareMessageGroupError;
 exports.noValidGroupFoundError = new errors_1.NoValidGroupFoundError('Failed to prepare valid message group', 117);
+const allEndpointsFailedError = (inner) => new errors_1.FetchError('All endpoints failed', 118, inner);
+exports.allEndpointsFailedError = allEndpointsFailedError;
+const allContractOpenerFailedError = (inner) => new errors_1.FetchError('All contract opener failed', 119, inner);
+exports.allContractOpenerFailedError = allContractOpenerFailedError;

package/dist/index.d.ts

@@ -1,13 +1,13 @@
-export { TacSdk } from './sdk/TacSdk';
+export { liteClientOpener, orbsOpener } from './adapters/contractOpener';
+export * from './errors';
+export { LiteSequencerClient } from './sdk/LiteSequencerClient';
 export { OperationTracker } from './sdk/OperationTracker';
 export { startTracking, startTrackingMultiple } from './sdk/StartTracking';
+export { TacSdk } from './sdk/TacSdk';
 export * from './sender';
 export * from './structs/Struct';
 export { Network, SimplifiedStatuses } from './structs/Struct';
+export { readJettonMetadata } from './wrappers/ContentUtils';
+export { HighloadWalletV3 } from './wrappers/HighloadWalletV3';
 export type { JettonWalletData } from './wrappers/JettonWallet';
 export { JettonWallet, JettonWalletOpCodes } from './wrappers/JettonWallet';
-export { HighloadWalletV3 } from './wrappers/HighloadWalletV3';
-export { orbsOpener, liteClientOpener } from './adapters/contractOpener';
-export * from './errors';
-export { readJettonMetadata } from './wrappers/ContentUtils';
-export { LiteSequencerClient } from './sdk/LiteSequencerClient';

package/dist/index.js

@@ -14,29 +14,29 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LiteSequencerClient = exports.readJettonMetadata = exports.liteClientOpener = exports.orbsOpener = exports.HighloadWalletV3 = exports.JettonWalletOpCodes = exports.JettonWallet = exports.SimplifiedStatuses = exports.Network = exports.startTrackingMultiple = exports.startTracking = exports.OperationTracker = exports.TacSdk = void 0;
-var TacSdk_1 = require("./sdk/TacSdk");
-Object.defineProperty(exports, "TacSdk", { enumerable: true, get: function () { return TacSdk_1.TacSdk; } });
+exports.JettonWalletOpCodes = exports.JettonWallet = exports.HighloadWalletV3 = exports.readJettonMetadata = exports.SimplifiedStatuses = exports.Network = exports.TacSdk = exports.startTrackingMultiple = exports.startTracking = exports.OperationTracker = exports.LiteSequencerClient = exports.orbsOpener = exports.liteClientOpener = void 0;
+var contractOpener_1 = require("./adapters/contractOpener");
+Object.defineProperty(exports, "liteClientOpener", { enumerable: true, get: function () { return contractOpener_1.liteClientOpener; } });
+Object.defineProperty(exports, "orbsOpener", { enumerable: true, get: function () { return contractOpener_1.orbsOpener; } });
+__exportStar(require("./errors"), exports);
+var LiteSequencerClient_1 = require("./sdk/LiteSequencerClient");
+Object.defineProperty(exports, "LiteSequencerClient", { enumerable: true, get: function () { return LiteSequencerClient_1.LiteSequencerClient; } });
 var OperationTracker_1 = require("./sdk/OperationTracker");
 Object.defineProperty(exports, "OperationTracker", { enumerable: true, get: function () { return OperationTracker_1.OperationTracker; } });
 var StartTracking_1 = require("./sdk/StartTracking");
 Object.defineProperty(exports, "startTracking", { enumerable: true, get: function () { return StartTracking_1.startTracking; } });
 Object.defineProperty(exports, "startTrackingMultiple", { enumerable: true, get: function () { return StartTracking_1.startTrackingMultiple; } });
+var TacSdk_1 = require("./sdk/TacSdk");
+Object.defineProperty(exports, "TacSdk", { enumerable: true, get: function () { return TacSdk_1.TacSdk; } });
 __exportStar(require("./sender"), exports);
 __exportStar(require("./structs/Struct"), exports);
 var Struct_1 = require("./structs/Struct");
 Object.defineProperty(exports, "Network", { enumerable: true, get: function () { return Struct_1.Network; } });
 Object.defineProperty(exports, "SimplifiedStatuses", { enumerable: true, get: function () { return Struct_1.SimplifiedStatuses; } });
+var ContentUtils_1 = require("./wrappers/ContentUtils");
+Object.defineProperty(exports, "readJettonMetadata", { enumerable: true, get: function () { return ContentUtils_1.readJettonMetadata; } });
+var HighloadWalletV3_1 = require("./wrappers/HighloadWalletV3");
+Object.defineProperty(exports, "HighloadWalletV3", { enumerable: true, get: function () { return HighloadWalletV3_1.HighloadWalletV3; } });
 var JettonWallet_1 = require("./wrappers/JettonWallet");
 Object.defineProperty(exports, "JettonWallet", { enumerable: true, get: function () { return JettonWallet_1.JettonWallet; } });
 Object.defineProperty(exports, "JettonWalletOpCodes", { enumerable: true, get: function () { return JettonWallet_1.JettonWalletOpCodes; } });
-var HighloadWalletV3_1 = require("./wrappers/HighloadWalletV3");
-Object.defineProperty(exports, "HighloadWalletV3", { enumerable: true, get: function () { return HighloadWalletV3_1.HighloadWalletV3; } });
-var contractOpener_1 = require("./adapters/contractOpener");
-Object.defineProperty(exports, "orbsOpener", { enumerable: true, get: function () { return contractOpener_1.orbsOpener; } });
-Object.defineProperty(exports, "liteClientOpener", { enumerable: true, get: function () { return contractOpener_1.liteClientOpener; } });
-__exportStar(require("./errors"), exports);
-var ContentUtils_1 = require("./wrappers/ContentUtils");
-Object.defineProperty(exports, "readJettonMetadata", { enumerable: true, get: function () { return ContentUtils_1.readJettonMetadata; } });
-var LiteSequencerClient_1 = require("./sdk/LiteSequencerClient");
-Object.defineProperty(exports, "LiteSequencerClient", { enumerable: true, get: function () { return LiteSequencerClient_1.LiteSequencerClient; } });

package/dist/sdk/LiteSequencerClient.d.ts

@@ -1,4 +1,4 @@
-import { TransactionLinker, StatusInfosByOperationId, OperationIdsByShardsKey, ExecutionStagesByOperationId, OperationType } from '../structs/Struct';
+import { ExecutionStagesByOperationId, OperationIdsByShardsKey, OperationType, StatusInfosByOperationId, TransactionLinker } from '../structs/Struct';
 export declare class LiteSequencerClient {
     private readonly endpoint;
     private readonly maxChunkSize;

package/dist/sdk/LiteSequencerClient.js

@@ -22,8 +22,7 @@ class LiteSequencerClient {
             return response.data.response || '';
         }
         catch (error) {
-            console.error(`Failed to get operationType with ${this.endpoint}:`, error);
-            throw errors_1.operationFetchError;
+            throw (0, errors_1.operationFetchError)(`endpoint ${this.endpoint} failed to complete request`, error);
         }
     }
     async getOperationId(transactionLinker) {
@@ -40,12 +39,10 @@ class LiteSequencerClient {
         catch (error) {
             if (axios_1.default.isAxiosError(error)) {
                 if (error.response?.status === 404) {
-                    console.warn(`404 Not Found: ${new URL('ton/operation-id', this.endpoint).toString()}`);
                     return '';
                 }
             }
-            console.error(`Failed to get OperationId with ${this.endpoint}:`, error);
-            throw errors_1.operationFetchError;
+            throw (0, errors_1.operationFetchError)(`endpoint ${this.endpoint} failed to complete request`, error);
         }
     }
     async getOperationIdsByShardsKeys(shardsKeys, caller, chunkSize = this.maxChunkSize) {
@@ -63,8 +60,7 @@ class LiteSequencerClient {
             return response.response;
         }
         catch (error) {
-            console.error(`Failed to get OperationIds with ${this.endpoint}:`, error);
-            throw errors_1.operationFetchError;
+            throw (0, errors_1.operationFetchError)(`endpoint ${this.endpoint} failed to complete request`, error);
         }
     }
     async getStageProfilings(operationIds, chunkSize = this.maxChunkSize) {
@@ -83,8 +79,7 @@ class LiteSequencerClient {
             return response.response;
         }
         catch (error) {
-            console.error(`Error fetching stage profiling with ${this.endpoint}:`, error);
-            throw (0, errors_1.profilingFetchError)('endpoint failed to complete request');
+            throw (0, errors_1.profilingFetchError)(`endpoint ${this.endpoint} failed to complete request`, error);
         }
     }
     async getOperationStatuses(operationIds, chunkSize = this.maxChunkSize) {
@@ -103,8 +98,7 @@ class LiteSequencerClient {
             return response.response;
         }
         catch (error) {
-            console.error(`Error fetching status transaction with ${this.endpoint}:`, error);
-            throw (0, errors_1.statusFetchError)('endpoint failed to complete request');
+            throw (0, errors_1.statusFetchError)(`endpoint ${this.endpoint} failed to complete request`, error);
         }
     }
     async processChunkedRequest(identificators, requestFn, chunkSize = this.maxChunkSize) {

package/dist/sdk/OperationTracker.d.ts

@@ -1,13 +1,15 @@
-import { Network, TransactionLinker, SimplifiedStatuses, OperationType, OperationIdsByShardsKey, ExecutionStages, ExecutionStagesByOperationId, StatusInfosByOperationId, StatusInfo } from '../structs/Struct';
+import { ExecutionStages, ExecutionStagesByOperationId, Network, OperationIdsByShardsKey, OperationType, SimplifiedStatuses, StatusInfo, StatusInfosByOperationId, TransactionLinker, WaitOptions } from '../structs/Struct';
 export declare class OperationTracker {
     private readonly clients;
-    constructor(network: Network, customLiteSequencerEndpoints?: string[]);
-    getOperationType(operationId: string): Promise<OperationType>;
-    getOperationId(transactionLinker: TransactionLinker): Promise<string>;
-    getOperationIdsByShardsKeys(shardsKeys: string[], caller: string, chunkSize?: number): Promise<OperationIdsByShardsKey>;
-    getStageProfiling(operationId: string): Promise<ExecutionStages>;
-    getStageProfilings(operationIds: string[], chunkSize?: number): Promise<ExecutionStagesByOperationId>;
-    getOperationStatuses(operationIds: string[], chunkSize?: number): Promise<StatusInfosByOperationId>;
-    getOperationStatus(operationId: string): Promise<StatusInfo>;
+    private readonly debug;
+    constructor(network: Network, customLiteSequencerEndpoints?: string[], debug?: boolean);
+    private debugLog;
+    getOperationType(operationId: string, waitOptions?: WaitOptions<OperationType>): Promise<OperationType>;
+    getOperationId(transactionLinker: TransactionLinker, waitOptions?: WaitOptions<string>): Promise<string>;
+    getOperationIdsByShardsKeys(shardsKeys: string[], caller: string, waitOptions?: WaitOptions<OperationIdsByShardsKey>, chunkSize?: number): Promise<OperationIdsByShardsKey>;
+    getStageProfiling(operationId: string, waitOptions?: WaitOptions<ExecutionStages>): Promise<ExecutionStages>;
+    getStageProfilings(operationIds: string[], waitOptions?: WaitOptions<ExecutionStagesByOperationId>, chunkSize?: number): Promise<ExecutionStagesByOperationId>;
+    getOperationStatuses(operationIds: string[], waitOptions?: WaitOptions<StatusInfosByOperationId>, chunkSize?: number): Promise<StatusInfosByOperationId>;
+    getOperationStatus(operationId: string, waitOptions?: WaitOptions<StatusInfo>): Promise<StatusInfo>;
     getSimplifiedOperationStatus(transactionLinker: TransactionLinker): Promise<SimplifiedStatuses>;
 }

package/dist/sdk/OperationTracker.js

@@ -1,110 +1,188 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OperationTracker = void 0;
-const Struct_1 = require("../structs/Struct");
 const artifacts_1 = require("@tonappchain/artifacts");
+const errors_1 = require("../errors");
+const Struct_1 = require("../structs/Struct");
 const LiteSequencerClient_1 = require("./LiteSequencerClient");
+const Utils_1 = require("./Utils");
 class OperationTracker {
-    constructor(network, customLiteSequencerEndpoints) {
+    constructor(network, customLiteSequencerEndpoints, debug = false) {
         const endpoints = customLiteSequencerEndpoints ??
             (network === Struct_1.Network.TESTNET
                 ? artifacts_1.testnet.PUBLIC_LITE_SEQUENCER_ENDPOINTS
                 : artifacts_1.mainnet.PUBLIC_LITE_SEQUENCER_ENDPOINTS);
         this.clients = endpoints.map((endpoint) => new LiteSequencerClient_1.LiteSequencerClient(endpoint));
+        this.debug = debug;
     }
-    async getOperationType(operationId) {
-        for (const client of this.clients) {
-            try {
-                return await client.getOperationType(operationId);
-            }
-            catch (error) {
-                console.error('Failed to get operationType:', error);
-            }
+    debugLog(message) {
+        if (this.debug) {
+            console.log(`[OperationTracker Debug] ${message}`);
         }
-        throw new Error('All endpoints failed to get operation type');
     }
-    async getOperationId(transactionLinker) {
-        for (const client of this.clients) {
-            try {
-                return await client.getOperationId(transactionLinker);
-            }
-            catch (error) {
-                console.error('Failed to get OperationId:', error);
+    async getOperationType(operationId, waitOptions) {
+        this.debugLog(`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.debugLog(`Operation retrieved successfully`);
+                    return type;
+                }
+                catch (error) {
+                    this.debugLog(`Failed to get operationType using one of the endpoints`);
+                    lastError = error;
+                }
             }
-        }
-        throw new Error('All endpoints failed to get operation id');
+            this.debugLog('All endpoints failed to get operation type');
+            throw (0, errors_1.allEndpointsFailedError)(lastError);
+        };
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : await requestFn();
     }
-    async getOperationIdsByShardsKeys(shardsKeys, caller, chunkSize = 100) {
-        for (const client of this.clients) {
-            try {
-                return await client.getOperationIdsByShardsKeys(shardsKeys, caller, chunkSize);
-            }
-            catch (error) {
-                console.error('Failed to get OperationIds:', error);
+    async getOperationId(transactionLinker, waitOptions) {
+        this.debugLog(`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.debugLog(`Operation ID ${id == '' ? 'does not exist' : 'retrieved successfully'}`);
+                    return id;
+                }
+                catch (error) {
+                    this.debugLog(`Failed to get OperationId using one of the endpoints`);
+                    lastError = error;
+                }
             }
-        }
-        throw new Error('All endpoints failed to get operation ids by shards keys');
+            this.debugLog('All endpoints failed to get operation id');
+            throw (0, errors_1.allEndpointsFailedError)(lastError);
+        };
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : await requestFn();
     }
-    async getStageProfiling(operationId) {
-        for (const client of this.clients) {
-            try {
-                const map = await client.getStageProfilings([operationId]);
-                const result = map[operationId];
-                if (!result) {
-                    throw new Error(`No stageProfiling data for operationId=${operationId}`);
+    async getOperationIdsByShardsKeys(shardsKeys, caller, waitOptions, chunkSize = 100) {
+        this.debugLog(`Getting operation IDs for shards keys: ${(0, Utils_1.formatObjectForLogging)(shardsKeys)}`);
+        this.debugLog(`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.debugLog(`Operation IDs by shards keys retrieved successfully`);
+                    return result;
+                }
+                catch (error) {
+                    this.debugLog(`Failed to get OperationIds using one of the endpoints`);
+                    lastError = error;
                 }
-                return result;
-            }
-            catch (error) {
-                console.error('Failed to get stage profiling:', error);
             }
-        }
-        throw new Error('All endpoints failed to get stage profiling');
+            this.debugLog('All endpoints failed to get operation ids by shards keys');
+            throw (0, errors_1.allEndpointsFailedError)(lastError);
+        };
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : await requestFn();
     }
-    async getStageProfilings(operationIds, chunkSize = 100) {
-        for (const client of this.clients) {
-            try {
-                return await client.getStageProfilings(operationIds, chunkSize);
-            }
-            catch (error) {
-                console.error('Failed to get stage profilings:', error);
+    async getStageProfiling(operationId, waitOptions) {
+        this.debugLog(`Getting stage profiling for operation ${operationId}`);
+        const requestFn = async () => {
+            let lastError;
+            for (const client of this.clients) {
+                try {
+                    const map = await client.getStageProfilings([operationId]);
+                    const result = map[operationId];
+                    if (!result) {
+                        this.debugLog(`No stageProfiling data for operationId=${operationId}`);
+                        throw new Error(`No stageProfiling data for operationId=${operationId}`);
+                    }
+                    this.debugLog(`Stage profiling retrieved successfully`);
+                    return result;
+                }
+                catch (error) {
+                    this.debugLog(`Failed to get stage profiling using one of the endpoints`);
+                    lastError = error;
+                }
             }
-        }
-        throw new Error('All endpoints failed to get stage profilings');
+            this.debugLog('All endpoints failed to get stage profiling');
+            throw (0, errors_1.allEndpointsFailedError)(lastError);
+        };
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : await requestFn();
     }
-    async getOperationStatuses(operationIds, chunkSize = 100) {
-        for (const client of this.clients) {
-            try {
-                return await client.getOperationStatuses(operationIds, chunkSize);
-            }
-            catch (error) {
-                console.error('Failed to get operation statuses:', error);
+    async getStageProfilings(operationIds, waitOptions, chunkSize = 100) {
+        this.debugLog(`Getting stage profilings for operations: ${operationIds.join(', ')}`);
+        this.debugLog(`Chunk size: ${chunkSize}`);
+        const requestFn = async () => {
+            let lastError;
+            for (const client of this.clients) {
+                try {
+                    const result = await client.getStageProfilings(operationIds, chunkSize);
+                    this.debugLog(`Stage profilings retrieved successfully`);
+                    return result;
+                }
+                catch (error) {
+                    this.debugLog(`Failed to get stage profilings using one of the endpoints`);
+                    lastError = error;
+                }
             }
-        }
-        throw new Error('All endpoints failed to get operation statuses');
+            this.debugLog('All endpoints failed to get stage profilings');
+            throw (0, errors_1.allEndpointsFailedError)(lastError);
+        };
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : await requestFn();
     }
-    async getOperationStatus(operationId) {
-        for (const client of this.clients) {
-            try {
-                const map = await client.getOperationStatuses([operationId]);
-                const result = map[operationId];
-                if (!result) {
-                    throw new Error(`No operation status for operationId=${operationId}`);
+    async getOperationStatuses(operationIds, waitOptions, chunkSize = 100) {
+        this.debugLog(`Getting operation statuses for operations: ${(0, Utils_1.formatObjectForLogging)(operationIds)}`);
+        this.debugLog(`Chunk size: ${chunkSize}`);
+        const requestFn = async () => {
+            let lastError;
+            for (const client of this.clients) {
+                try {
+                    const result = await client.getOperationStatuses(operationIds, chunkSize);
+                    this.debugLog(`Operation statuses retrieved successfully`);
+                    return result;
+                }
+                catch (error) {
+                    this.debugLog(`Failed to get operation statuses using one of the endpoints`);
+                    lastError = error;
                 }
-                return result;
             }
-            catch (error) {
-                console.error('Failed to get operation status:', error);
+            this.debugLog('All endpoints failed to get operation statuses');
+            throw (0, errors_1.allEndpointsFailedError)(lastError);
+        };
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : await requestFn();
+    }
+    async getOperationStatus(operationId, waitOptions) {
+        this.debugLog(`Getting operation status for ${(0, Utils_1.formatObjectForLogging)(operationId)}`);
+        const requestFn = async () => {
+            let lastError;
+            for (const client of this.clients) {
+                try {
+                    const map = await client.getOperationStatuses([operationId]);
+                    const result = map[operationId];
+                    if (!result) {
+                        this.debugLog(`No operation status for operationId=${operationId}`);
+                        throw new Error(`No operation status for operationId=${operationId}`);
+                    }
+                    this.debugLog(`Operation status retrieved successfully`);
+                    return result;
+                }
+                catch (error) {
+                    this.debugLog(`Failed to get operation status using one of the endpoints`);
+                    lastError = error;
+                }
             }
-        }
-        throw new Error('All endpoints failed to get operation status');
+            this.debugLog('All endpoints failed to get operation status');
+            throw (0, errors_1.allEndpointsFailedError)(lastError);
+        };
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : await requestFn();
     }
     async getSimplifiedOperationStatus(transactionLinker) {
+        this.debugLog(`Getting simplified operation status for transaction linker: ${(0, Utils_1.formatObjectForLogging)(transactionLinker)}`);
         const operationId = await this.getOperationId(transactionLinker);
         if (operationId == '') {
+            this.debugLog('Operation ID not found');
             return Struct_1.SimplifiedStatuses.OPERATION_ID_NOT_FOUND;
         }
+        this.debugLog(`Operation ID: ${operationId}`);
         const operationType = await this.getOperationType(operationId);
+        this.debugLog(`Operation type: ${operationType}`);
         if (operationType == Struct_1.OperationType.PENDING || operationType == Struct_1.OperationType.UNKNOWN) {
             return Struct_1.SimplifiedStatuses.PENDING;
         }