@tonappchain/sdk 0.6.4 → 0.6.5-smart-accounts-1

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

package/dist/sdk/TacSdk.d.ts

@@ -1,8 +1,9 @@
+import { mainnet, testnet } from '@tonappchain/artifacts';
 import { Wallet } from 'ethers';
 import type { SenderAbstraction } from '../sender';
-import { AssetBridgingData, EvmProxyMsg, Network, SDKParams, TransactionLinker, RawAssetBridgingData, UserWalletBalanceExtended, TACSimulationResult, TACSimulationRequest, SuggestedTONExecutorFee, CrossChainTransactionOptions, ExecutionFeeEstimationResult, CrosschainTx, WithAddressNFTCollectionItem, NFTAddressType, NFTItemData } from '../structs/Struct';
-import { InternalTONParams, InternalTACParams } from '../structs/InternalStruct';
-import { mainnet, testnet } from '@tonappchain/artifacts';
+import { InternalTACParams, InternalTONParams } from '../structs/InternalStruct';
+import { AssetBridgingData, CrossChainTransactionOptions, CrosschainTx, EvmProxyMsg, ExecutionFeeEstimationResult, Network, NFTAddressType, NFTItemData, OperationIdsByShardsKey, RawAssetBridgingData, SDKParams, SuggestedTONExecutorFee, TACSimulationRequest, TACSimulationResult, TransactionLinkerWithOperationId, UserWalletBalanceExtended, WaitOptions, WithAddressNFTCollectionItem } from '../structs/Struct';
+import { OperationTracker } from './OperationTracker';
 export declare class TacSdk {
     readonly network: Network;
     readonly delay: number;
@@ -10,6 +11,8 @@ export declare class TacSdk {
     readonly TONParams: InternalTONParams;
     readonly TACParams: InternalTACParams;
     readonly liteSequencerEndpoints: string[];
+    readonly operationTracker: OperationTracker;
+    readonly debug: boolean;
     private constructor();
     static create(sdkParams: SDKParams): Promise<TacSdk>;
     private static prepareTONParams;
@@ -19,12 +22,14 @@ export declare class TacSdk {
     nativeTACAddress(): Promise<string>;
     getUserJettonWalletAddress(userAddress: string, tokenAddress: string): Promise<string>;
     getUserJettonBalance(userAddress: string, tokenAddress: string): Promise<bigint>;
+    getTacSmartAccountAddress(tvmUserAddress: string, evmApplicationAddress: string): Promise<string>;
     getUserJettonBalanceExtended(userAddress: string, tokenAddress: string): Promise<UserWalletBalanceExtended>;
     private getJettonTransferPayload;
     private getJettonBurnPayload;
     private getNFTBurnPayload;
     private getNFTTransferPayload;
     private getTonTransferPayload;
+    private debugLog;
     private getJettonOpType;
     private getNFTOpType;
     private getNFTItemAddressTON;
@@ -37,10 +42,10 @@ export declare class TacSdk {
     private convertAssetsToRawFormat;
     private getFeeInfo;
     getTransactionSimulationInfo(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: AssetBridgingData[]): Promise<ExecutionFeeEstimationResult>;
-    getTVMExecutorFeeInfo(assets: AssetBridgingData[], feeSymbol: String): Promise<SuggestedTONExecutorFee>;
+    getTVMExecutorFeeInfo(assets: AssetBridgingData[], feeSymbol: string): Promise<SuggestedTONExecutorFee>;
     private prepareCrossChainTransaction;
-    sendCrossChainTransaction(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: AssetBridgingData[], options?: CrossChainTransactionOptions): Promise<TransactionLinker>;
-    sendCrossChainTransactions(sender: SenderAbstraction, txs: CrosschainTx[]): Promise<TransactionLinker[]>;
+    sendCrossChainTransaction(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: AssetBridgingData[], options?: CrossChainTransactionOptions, waitOptions?: WaitOptions<string>): Promise<TransactionLinkerWithOperationId>;
+    sendCrossChainTransactions(sender: SenderAbstraction, txs: CrosschainTx[], waitOptions?: WaitOptions<OperationIdsByShardsKey>): Promise<TransactionLinkerWithOperationId[]>;
     bridgeTokensToTON(signer: Wallet, value: bigint, tonTarget: string, assets?: RawAssetBridgingData<WithAddressNFTCollectionItem>[], tvmExecutorFee?: bigint): Promise<string>;
     get getTrustedTACExecutors(): string[];
     get getTrustedTONExecutors(): string[];