@tonappchain/sdk 0.6.1-v3.0.4 → 0.6.1

package/README.md

@@ -155,11 +155,14 @@ const evmProxyMsg: EvmProxyMsg = {
 const assets: AssetBridgingData[] = [
     {
         address: TVMtokenAAddress,
-        amount: tokenAAmount
+        amount: tokenAAmount,
+        type: AssetType.FT,
+
     },
     {
         address: TVMtokenBAddress,
-        amount: tokenBAmount
+        amount: tokenBAmount,
+        type: AssetType.FT,
     }
 ];
 

package/dist/errors/errors.d.ts

@@ -6,7 +6,8 @@ export declare class ContractError extends ErrorWithStatusCode {
     constructor(message: string, errorCode: number);
 }
 export declare class FetchError extends ErrorWithStatusCode {
-    constructor(message: string, errorCode: number);
+    readonly inner?: unknown;
+    constructor(message: string, errorCode: number, inner?: unknown);
 }
 export declare class AddressError extends ErrorWithStatusCode {
     constructor(message: string, errorCode: number);
@@ -32,3 +33,9 @@ export declare class SettingError extends ErrorWithStatusCode {
 export declare class EVMCallError extends ErrorWithStatusCode {
     constructor(message: string, errorCode: number);
 }
+export declare class PrepareMessageGroupError extends ErrorWithStatusCode {
+    constructor(message: string, errorCode: number);
+}
+export declare class NoValidGroupFoundError extends ErrorWithStatusCode {
+    constructor(message: string, errorCode: number);
+}

package/dist/errors/errors.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.ErrorWithStatusCode = void 0;
+exports.NoValidGroupFoundError = exports.PrepareMessageGroupError = exports.EVMCallError = exports.SettingError = exports.MetadataError = exports.BitError = exports.FormatError = exports.KeyError = exports.WalletError = exports.AddressError = exports.FetchError = exports.ContractError = exports.ErrorWithStatusCode = void 0;
 class ErrorWithStatusCode extends Error {
     constructor(message, errorCode) {
         super(message);
@@ -16,9 +16,10 @@ class ContractError extends ErrorWithStatusCode {
 }
 exports.ContractError = ContractError;
 class FetchError extends ErrorWithStatusCode {
-    constructor(message, errorCode) {
+    constructor(message, errorCode, inner) {
         super(message, errorCode);
         this.name = 'FetchError';
+        this.inner = inner;
     }
 }
 exports.FetchError = FetchError;
@@ -78,3 +79,17 @@ class EVMCallError extends ErrorWithStatusCode {
     }
 }
 exports.EVMCallError = EVMCallError;
+class PrepareMessageGroupError extends ErrorWithStatusCode {
+    constructor(message, errorCode) {
+        super(message, errorCode);
+        this.name = 'PrepareMessageGroupError';
+    }
+}
+exports.PrepareMessageGroupError = PrepareMessageGroupError;
+class NoValidGroupFoundError extends ErrorWithStatusCode {
+    constructor(message, errorCode) {
+        super(message, errorCode);
+        this.name = 'NoValidGroupFoundError';
+    }
+}
+exports.NoValidGroupFoundError = NoValidGroupFoundError;

package/dist/errors/instances.d.ts

@@ -1,4 +1,4 @@
-import { ContractError, FetchError, AddressError, WalletError, KeyError, FormatError, BitError, MetadataError, SettingError, EVMCallError } from './errors';
+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;
@@ -11,7 +11,9 @@ export declare const notMultiplyOf8Error: BitError;
 export declare const prefixError: MetadataError;
 export declare const emptySettingError: (setting: string) => SettingError;
 export declare const invalidMethodNameError: (methodName: string) => EVMCallError;
-export declare const simulationError: FetchError;
+export declare const simulationError: (inner: unknown) => FetchError;
 export declare const profilingFetchError: (msg: string) => 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;

package/dist/errors/instances.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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.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);
@@ -21,9 +21,13 @@ const emptySettingError = (setting) => new errors_1.SettingError(`unexpected emp
 exports.emptySettingError = emptySettingError;
 const invalidMethodNameError = (methodName) => new errors_1.EVMCallError(`Invalid Solidity method name: "${methodName}". Method must be either a valid identifier or have parameters (bytes,bytes).`, 111);
 exports.invalidMethodNameError = invalidMethodNameError;
-exports.simulationError = new errors_1.FetchError('Failed to simulate EVM call', 112);
+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);
 exports.profilingFetchError = profilingFetchError;
 const emptyArrayError = (msg) => new errors_1.FetchError(`empty array: ${msg}`, 114);
 exports.emptyArrayError = emptyArrayError;
 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);

package/dist/index.d.ts

@@ -1,10 +1,13 @@
 export { TacSdk } from './sdk/TacSdk';
 export { OperationTracker } from './sdk/OperationTracker';
-export { startTracking } from './sdk/StartTracking';
+export { startTracking, startTrackingMultiple } from './sdk/StartTracking';
 export * from './sender';
 export * from './structs/Struct';
 export { Network, SimplifiedStatuses } from './structs/Struct';
 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,13 +14,14 @@ 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.liteClientOpener = exports.orbsOpener = exports.JettonWalletOpCodes = exports.JettonWallet = exports.SimplifiedStatuses = exports.Network = exports.startTracking = exports.OperationTracker = exports.TacSdk = void 0;
+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; } });
 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; } });
 __exportStar(require("./sender"), exports);
 __exportStar(require("./structs/Struct"), exports);
 var Struct_1 = require("./structs/Struct");
@@ -29,7 +30,13 @@ Object.defineProperty(exports, "SimplifiedStatuses", { enumerable: true, get: fu
 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/Consts.d.ts

@@ -5,3 +5,8 @@ export declare const MAX_ITERATION_COUNT = 120;
 export declare const DEFAULT_DELAY = 0;
 export declare const SOLIDITY_SIGNATURE_REGEX: RegExp;
 export declare const SOLIDITY_METHOD_NAME_REGEX: RegExp;
+export declare const MAX_EXT_MSG_SIZE = 65535;
+export declare const MAX_HIGHLOAD_GROUP_MSG_NUM = 254;
+export declare const MAX_MSG_DEPTH = 512;
+export declare const TON_SYMBOL = "TON";
+export declare const TAC_SYMBOL = "TAC";

package/dist/sdk/Consts.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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 = exports.TRANSACTION_TON_AMOUNT = void 0;
+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 = exports.TRANSACTION_TON_AMOUNT = void 0;
 const ton_1 = require("@ton/ton");
 exports.TRANSACTION_TON_AMOUNT = (0, ton_1.toNano)(0.55);
 exports.JETTON_TRANSFER_FORWARD_TON_AMOUNT = (0, ton_1.toNano)(0.2);
@@ -9,3 +9,8 @@ exports.MAX_ITERATION_COUNT = 120;
 exports.DEFAULT_DELAY = 0;
 exports.SOLIDITY_SIGNATURE_REGEX = /^[a-zA-Z_][a-zA-Z0-9_]*(\((bytes,bytes)\))?$/;
 exports.SOLIDITY_METHOD_NAME_REGEX = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+exports.MAX_EXT_MSG_SIZE = 65535;
+exports.MAX_HIGHLOAD_GROUP_MSG_NUM = 254;
+exports.MAX_MSG_DEPTH = 512;
+exports.TON_SYMBOL = "TON";
+exports.TAC_SYMBOL = "TAC";

package/dist/sdk/LiteSequencerClient.d.ts

@@ -0,0 +1,12 @@
+import { TransactionLinker, StatusInfosByOperationId, OperationIdsByShardsKey, ExecutionStagesByOperationId, OperationType } from '../structs/Struct';
+export declare class LiteSequencerClient {
+    private readonly endpoint;
+    private readonly maxChunkSize;
+    constructor(endpoint: string, maxChunkSize?: number);
+    getOperationType(operationId: string): Promise<OperationType>;
+    getOperationId(transactionLinker: TransactionLinker): Promise<string>;
+    getOperationIdsByShardsKeys(shardsKeys: string[], caller: string, chunkSize?: number): Promise<OperationIdsByShardsKey>;
+    getStageProfilings(operationIds: string[], chunkSize?: number): Promise<ExecutionStagesByOperationId>;
+    getOperationStatuses(operationIds: string[], chunkSize?: number): Promise<StatusInfosByOperationId>;
+    private processChunkedRequest;
+}

package/dist/sdk/LiteSequencerClient.js

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiteSequencerClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const errors_1 = require("../errors");
+const Utils_1 = require("./Utils");
+class LiteSequencerClient {
+    constructor(endpoint, maxChunkSize = 100) {
+        this.endpoint = endpoint;
+        this.maxChunkSize = maxChunkSize;
+    }
+    async getOperationType(operationId) {
+        try {
+            const response = await axios_1.default.get(new URL('operation-type', this.endpoint).toString(), {
+                params: {
+                    operationId,
+                },
+            });
+            return response.data.response || '';
+        }
+        catch (error) {
+            console.error(`Failed to get operationType with ${this.endpoint}:`, error);
+            throw errors_1.operationFetchError;
+        }
+    }
+    async getOperationId(transactionLinker) {
+        const requestBody = {
+            shardsKey: transactionLinker.shardsKey,
+            caller: transactionLinker.caller,
+            shardCount: transactionLinker.shardCount,
+            timestamp: transactionLinker.timestamp,
+        };
+        try {
+            const response = await axios_1.default.post(new URL('ton/operation-id', this.endpoint).toString(), requestBody);
+            return response.data.response || '';
+        }
+        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;
+        }
+    }
+    async getOperationIdsByShardsKeys(shardsKeys, caller, chunkSize = this.maxChunkSize) {
+        if (!shardsKeys || shardsKeys.length === 0) {
+            throw (0, errors_1.emptyArrayError)('shardsKeys');
+        }
+        try {
+            const response = await this.processChunkedRequest(shardsKeys, async (chunk) => {
+                const response = await axios_1.default.post(new URL('operation-ids-by-shards-keys', this.endpoint).toString(), {
+                    shardsKeys: chunk,
+                    caller: caller,
+                });
+                return response.data;
+            }, chunkSize);
+            return response.response;
+        }
+        catch (error) {
+            console.error(`Failed to get OperationIds with ${this.endpoint}:`, error);
+            throw errors_1.operationFetchError;
+        }
+    }
+    async getStageProfilings(operationIds, chunkSize = this.maxChunkSize) {
+        if (!operationIds || operationIds.length === 0) {
+            throw (0, errors_1.emptyArrayError)('operationIds');
+        }
+        try {
+            const response = await this.processChunkedRequest(operationIds, async (chunk) => {
+                const response = await axios_1.default.post(new URL('stage-profiling', this.endpoint).toString(), {
+                    operationIds: chunk,
+                }, {
+                    transformResponse: [Utils_1.toCamelCaseTransformer],
+                });
+                return response.data;
+            }, chunkSize);
+            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');
+        }
+    }
+    async getOperationStatuses(operationIds, chunkSize = this.maxChunkSize) {
+        if (!operationIds || operationIds.length === 0) {
+            throw (0, errors_1.emptyArrayError)('operationIds');
+        }
+        try {
+            const response = await this.processChunkedRequest(operationIds, async (chunk) => {
+                const response = await axios_1.default.post(new URL('status', this.endpoint).toString(), {
+                    operationIds: chunk,
+                }, {
+                    transformResponse: [Utils_1.toCamelCaseTransformer],
+                });
+                return response.data;
+            }, chunkSize);
+            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');
+        }
+    }
+    async processChunkedRequest(identificators, requestFn, chunkSize = this.maxChunkSize) {
+        const results = [];
+        for (let i = 0; i < identificators.length; i += chunkSize) {
+            const chunk = identificators.slice(i, i + chunkSize);
+            const result = await requestFn(chunk);
+            results.push(result);
+        }
+        // Combine results based on the type
+        if (Array.isArray(results[0])) {
+            return results.flat();
+        }
+        else if (typeof results[0] === 'object') {
+            return Object.assign({}, ...results);
+        }
+        return results[0];
+    }
+}
+exports.LiteSequencerClient = LiteSequencerClient;

package/dist/sdk/OperationTracker.d.ts

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

package/dist/sdk/OperationTracker.js

@@ -1,137 +1,103 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OperationTracker = void 0;
-const axios_1 = __importDefault(require("axios"));
 const Struct_1 = require("../structs/Struct");
-const errors_1 = require("../errors");
-const Utils_1 = require("./Utils");
 const artifacts_1 = require("@tonappchain/artifacts");
+const LiteSequencerClient_1 = require("./LiteSequencerClient");
 class OperationTracker {
     constructor(network, customLiteSequencerEndpoints) {
-        this.network = network;
-        this.customLiteSequencerEndpoints =
-            customLiteSequencerEndpoints ??
-                (this.network === Struct_1.Network.TESTNET
-                    ? artifacts_1.testnet.PUBLIC_LITE_SEQUENCER_ENDPOINTS
-                    : artifacts_1.mainnet.PUBLIC_LITE_SEQUENCER_ENDPOINTS);
+        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));
     }
     async getOperationType(operationId) {
-        for (const endpoint of this.customLiteSequencerEndpoints) {
+        for (const client of this.clients) {
             try {
-                const response = await axios_1.default.get(`${endpoint}/operation-type`, {
-                    params: {
-                        operationId,
-                    },
-                });
-                return response.data.response || '';
+                return await client.getOperationType(operationId);
             }
             catch (error) {
-                console.error(`Failed to get operationType with ${endpoint}:`, error);
+                console.error('Failed to get operationType:', error);
             }
         }
-        throw errors_1.operationFetchError;
+        throw new Error('All endpoints failed to get operation type');
     }
     async getOperationId(transactionLinker) {
-        const requestBody = {
-            shardsKey: transactionLinker.shardsKey,
-            caller: transactionLinker.caller,
-            shardCount: transactionLinker.shardCount,
-            timestamp: transactionLinker.timestamp,
-        };
-        let operationId = undefined;
-        for (const endpoint of this.customLiteSequencerEndpoints) {
+        for (const client of this.clients) {
             try {
-                const response = await axios_1.default.post(`${endpoint}/ton/operation-id`, requestBody);
-                return response.data.response || '';
+                return await client.getOperationId(transactionLinker);
             }
             catch (error) {
-                if (axios_1.default.isAxiosError(error)) {
-                    if (error.response?.status === 404) {
-                        console.warn(`404 Not Found: ${endpoint}/ton/operation-id`);
-                        operationId = '';
-                        continue;
-                    }
-                }
-                console.error(`Failed to get OperationId with ${endpoint}:`, error);
+                console.error('Failed to get OperationId:', error);
             }
         }
-        if (operationId !== undefined) {
-            return operationId;
-        }
-        throw errors_1.operationFetchError;
+        throw new Error('All endpoints failed to get operation id');
     }
-    async getOperationIdsByShardsKeys(shardsKeys, caller) {
-        const requestBody = {
-            shardsKeys: shardsKeys,
-            caller: caller,
-        };
-        for (const endpoint of this.customLiteSequencerEndpoints) {
+    async getOperationIdsByShardsKeys(shardsKeys, caller, chunkSize = 100) {
+        for (const client of this.clients) {
             try {
-                const response = await axios_1.default.post(`${endpoint}/operation-ids-by-shards-keys`, requestBody);
-                return response.data.response;
+                return await client.getOperationIdsByShardsKeys(shardsKeys, caller, chunkSize);
             }
             catch (error) {
-                console.error(`Failed to get OperationIds with ${endpoint}:`, error);
+                console.error('Failed to get OperationIds:', error);
             }
         }
-        throw errors_1.operationFetchError;
+        throw new Error('All endpoints failed to get operation ids by shards keys');
     }
     async getStageProfiling(operationId) {
-        const map = await this.getStageProfilings([operationId]);
-        const result = map[operationId];
-        if (!result) {
-            throw new Error(`No stageProfiling data for operationId=${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}`);
+                }
+                return result;
+            }
+            catch (error) {
+                console.error('Failed to get stage profiling:', error);
+            }
         }
-        return result;
+        throw new Error('All endpoints failed to get stage profiling');
     }
-    async getStageProfilings(operationIds) {
-        if (!operationIds || operationIds.length === 0) {
-            throw (0, errors_1.emptyArrayError)('operationIds');
-        }
-        for (const endpoint of this.customLiteSequencerEndpoints) {
+    async getStageProfilings(operationIds, chunkSize = 100) {
+        for (const client of this.clients) {
             try {
-                const response = await axios_1.default.post(`${endpoint}/stage-profiling`, {
-                    operationIds,
-                }, {
-                    transformResponse: [Utils_1.toCamelCaseTransformer],
-                });
-                return response.data.response;
+                return await client.getStageProfilings(operationIds, chunkSize);
             }
             catch (error) {
-                console.error(`Error fetching status transaction with ${endpoint}:`, error);
+                console.error('Failed to get stage profilings:', error);
             }
         }
-        throw (0, errors_1.profilingFetchError)('all endpoints failed to complete request');
+        throw new Error('All endpoints failed to get stage profilings');
     }
-    async getOperationStatuses(operationIds) {
-        if (!operationIds || operationIds.length === 0) {
-            throw (0, errors_1.emptyArrayError)('operationIds');
-        }
-        for (const endpoint of this.customLiteSequencerEndpoints) {
+    async getOperationStatuses(operationIds, chunkSize = 100) {
+        for (const client of this.clients) {
             try {
-                const response = await axios_1.default.post(`${endpoint}/status`, {
-                    operationIds,
-                }, {
-                    transformResponse: [Utils_1.toCamelCaseTransformer],
-                });
-                return response.data.response;
+                return await client.getOperationStatuses(operationIds, chunkSize);
             }
             catch (error) {
-                console.error(`Error fetching status transaction with ${endpoint}:`, error);
+                console.error('Failed to get operation statuses:', error);
             }
         }
-        throw (0, errors_1.statusFetchError)('all endpoints failed to complete request');
+        throw new Error('All endpoints failed to get operation statuses');
     }
     async getOperationStatus(operationId) {
-        const result = await this.getOperationStatuses([operationId]);
-        const currentStatus = result[operationId];
-        if (!currentStatus) {
-            throw (0, errors_1.statusFetchError)('operation is not found in response');
+        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}`);
+                }
+                return result;
+            }
+            catch (error) {
+                console.error('Failed to get operation status:', error);
+            }
         }
-        return currentStatus;
+        throw new Error('All endpoints failed to get operation status');
     }
     async getSimplifiedOperationStatus(transactionLinker) {
         const operationId = await this.getOperationId(transactionLinker);

package/dist/sdk/StartTracking.d.ts

@@ -6,3 +6,10 @@ export declare function startTracking(transactionLinker: TransactionLinker, netw
     returnValue?: boolean;
     tableView?: boolean;
 }): Promise<void | ExecutionStages>;
+export declare function startTrackingMultiple(transactionLinkers: TransactionLinker[], network: Network, options?: {
+    customLiteSequencerEndpoints?: string[];
+    delay?: number;
+    maxIterationCount?: number;
+    returnValue?: boolean;
+    tableView?: boolean;
+}): Promise<void | ExecutionStages[]>;

package/dist/sdk/StartTracking.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startTracking = startTracking;
+exports.startTrackingMultiple = startTrackingMultiple;
 const Struct_1 = require("../structs/Struct");
 const Consts_1 = require("./Consts");
 const OperationTracker_1 = require("./OperationTracker");
@@ -74,6 +75,35 @@ async function startTracking(transactionLinker, network, options) {
         console.log(formatExecutionStages(profilingData));
     }
 }
+async function startTrackingMultiple(transactionLinkers, network, options) {
+    const { customLiteSequencerEndpoints, delay = 10, maxIterationCount = Consts_1.MAX_ITERATION_COUNT, returnValue = false, tableView = true, } = options || {};
+    console.log(`Start tracking ${transactionLinkers.length} operations`);
+    const results = await Promise.all(transactionLinkers.map((linker, index) => {
+        console.log(`\nProcessing operation ${index + 1}/${transactionLinkers.length}`);
+        return startTracking(linker, network, {
+            customLiteSequencerEndpoints,
+            delay,
+            maxIterationCount,
+            returnValue: true,
+            tableView: false,
+        });
+    }));
+    if (returnValue) {
+        return results;
+    }
+    if (tableView) {
+        results.forEach((result, index) => {
+            console.log(`\nResults for operation ${index + 1}:`);
+            printExecutionStagesTable(result);
+        });
+    }
+    else {
+        results.forEach((result, index) => {
+            console.log(`\nResults for operation ${index + 1}:`);
+            console.log(formatExecutionStages(result));
+        });
+    }
+}
 function formatExecutionStages(stages) {
     const { operationType, metaInfo, ...stagesData } = stages;
     return Object.entries(stagesData).map(([stage, data]) => ({

package/dist/sdk/TacSdk.d.ts

@@ -1,6 +1,6 @@
 import { Wallet } from 'ethers';
 import type { SenderAbstraction } from '../sender';
-import { AssetBridgingData, EvmProxyMsg, Network, SDKParams, TransactionLinker, RawAssetBridgingData, UserWalletBalanceExtended, TACSimulationResult, TACSimulationRequest, CrossChainTransactionOptions, ExecutionFeeEstimationResult, CrosschainTx, WithAddressNFT_CollectionItem, NFTAddressType, NFTItemData } from '../structs/Struct';
+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';
 export declare class TacSdk {
@@ -24,7 +24,6 @@ export declare class TacSdk {
     private getJettonBurnPayload;
     private getNFTBurnPayload;
     private getNFTTransferPayload;
-    private generateFeeData;
     private getTonTransferPayload;
     private getJettonOpType;
     private getNFTOpType;
@@ -38,10 +37,11 @@ export declare class TacSdk {
     private convertAssetsToRawFormat;
     private getFeeInfo;
     getTransactionSimulationInfo(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: AssetBridgingData[]): Promise<ExecutionFeeEstimationResult>;
+    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[]>;
-    bridgeTokensToTON(signer: Wallet, value: bigint, tonTarget: string, assets?: RawAssetBridgingData<WithAddressNFT_CollectionItem>[], tvmExecutorFee?: bigint): Promise<string>;
+    bridgeTokensToTON(signer: Wallet, value: bigint, tonTarget: string, assets?: RawAssetBridgingData<WithAddressNFTCollectionItem>[], tvmExecutorFee?: bigint): Promise<string>;
     get getTrustedTACExecutors(): string[];
     get getTrustedTONExecutors(): string[];
     getEVMTokenAddress(tvmTokenAddress: string): Promise<string>;