@tonappchain/sdk 0.5.0

package/dist/adapters/contractOpener.d.ts

@@ -0,0 +1,19 @@
+import { ContractOpener, Network } from '../structs/Struct';
+import { Blockchain } from '@ton/sandbox';
+type LiteServer = {
+    ip: number;
+    port: number;
+    id: {
+        '@type': string;
+        key: string;
+    };
+};
+export declare function liteClientOpener(options: {
+    liteservers: LiteServer[];
+} | {
+    network: Network;
+}): Promise<ContractOpener>;
+export declare function sandboxOpener(blockchain: Blockchain): ContractOpener;
+export declare function orbsOpener(network: Network): Promise<ContractOpener>;
+export declare function orbsOpener4(network: Network, timeout?: number): Promise<ContractOpener>;
+export {};

package/dist/adapters/contractOpener.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.liteClientOpener = liteClientOpener;
+exports.sandboxOpener = sandboxOpener;
+exports.orbsOpener = orbsOpener;
+exports.orbsOpener4 = orbsOpener4;
+const ton_lite_client_1 = require("@tonappchain/ton-lite-client");
+const Struct_1 = require("../structs/Struct");
+const ton_access_1 = require("@orbs-network/ton-access");
+const ton_1 = require("@ton/ton");
+const artifacts_1 = require("@tonappchain/artifacts");
+function intToIP(int) {
+    var part1 = int & 255;
+    var part2 = (int >> 8) & 255;
+    var part3 = (int >> 16) & 255;
+    var part4 = (int >> 24) & 255;
+    return part4 + '.' + part3 + '.' + part2 + '.' + part1;
+}
+async function getDefaultLiteServers(network) {
+    const url = network === Struct_1.Network.Testnet ? artifacts_1.testnet.DEFAULT_LITESERVERS : artifacts_1.mainnet.DEFAULT_LITESERVERS;
+    const resp = await fetch(url);
+    const liteClients = await resp.json();
+    return liteClients.liteservers;
+}
+async function liteClientOpener(options) {
+    const liteservers = 'liteservers' in options ? options.liteservers : await getDefaultLiteServers(options.network);
+    const engines = [];
+    for (const server of liteservers) {
+        const engine = await ton_lite_client_1.LiteSingleEngine.create({
+            host: `tcp://${intToIP(server.ip)}:${server.port}`,
+            publicKey: Buffer.from(server.id.key, 'base64'),
+        });
+        engines.push(engine);
+    }
+    const engine = new ton_lite_client_1.LiteRoundRobinEngine(engines);
+    const client = new ton_lite_client_1.LiteClient({ engine });
+    const closeConnections = () => {
+        engine.close();
+    };
+    return {
+        getContractState: async (addr) => {
+            const block = await client.getMasterchainInfo();
+            const state = await client.getAccountState(addr, block.last);
+            const accountState = state.state?.storage?.state;
+            const code = accountState?.type === 'active' ? accountState?.state?.code?.toBoc() : null;
+            return {
+                balance: state.balance.coins,
+                state: state.state.storage.state.type === 'uninit' ? 'uninitialized' : state.state.storage.state.type,
+                code: code ?? null,
+            };
+        },
+        open: (contract) => client.open(contract),
+        closeConnections,
+    };
+}
+function sandboxOpener(blockchain) {
+    return {
+        open: (contract) => blockchain.openContract(contract),
+        getContractState: async (address) => {
+            const state = await blockchain.provider(address).getState();
+            return {
+                balance: state.balance,
+                code: 'code' in state.state ? (state.state.code ?? null) : null,
+                state: state.state.type === 'uninit' ? 'uninitialized' : state.state.type,
+            };
+        },
+    };
+}
+async function orbsOpener(network) {
+    const endpoint = await (0, ton_access_1.getHttpEndpoint)({
+        network,
+    });
+    const client = new ton_1.TonClient({ endpoint });
+    return client;
+}
+async function orbsOpener4(network, timeout = 10000) {
+    const endpoint = await (0, ton_access_1.getHttpV4Endpoint)({ network });
+    const client4 = new ton_1.TonClient4({ endpoint, timeout });
+    return {
+        open: (contract) => client4.open(contract),
+        getContractState: async (address) => {
+            const latestBlock = await client4.getLastBlock();
+            const latestBlockNumber = latestBlock.last.seqno;
+            const state = await client4.getAccount(latestBlockNumber, address);
+            return {
+                balance: BigInt(state.account.balance.coins),
+                code: 'code' in state.account.state && state.account.state.code !== null
+                    ? Buffer.from(state.account.state.code, 'base64')
+                    : null,
+                state: state.account.state.type === 'uninit' ? 'uninitialized' : state.account.state.type,
+            };
+        },
+    };
+}

package/dist/errors/errors.d.ts

@@ -0,0 +1,34 @@
+export declare class ErrorWithStatusCode extends Error {
+    readonly errorCode: number;
+    constructor(message: string, errorCode: number);
+}
+export declare class ContractError extends ErrorWithStatusCode {
+    constructor(message: string, errorCode: number);
+}
+export declare class FetchError extends ErrorWithStatusCode {
+    constructor(message: string, errorCode: number);
+}
+export declare class AddressError extends ErrorWithStatusCode {
+    constructor(message: string, errorCode: number);
+}
+export declare class WalletError extends ErrorWithStatusCode {
+    constructor(message: string, errorCode: number);
+}
+export declare class KeyError extends ErrorWithStatusCode {
+    constructor(message: string, errorCode: number);
+}
+export declare class FormatError extends ErrorWithStatusCode {
+    constructor(message: string, errorCode: number);
+}
+export declare class BitError extends ErrorWithStatusCode {
+    constructor(message: string, errorCode: number);
+}
+export declare class MetadataError extends ErrorWithStatusCode {
+    constructor(message: string, errorCode: number);
+}
+export declare class SettingError extends ErrorWithStatusCode {
+    constructor(message: string, errorCode: number);
+}
+export declare class EVMCallError extends ErrorWithStatusCode {
+    constructor(message: string, errorCode: number);
+}

package/dist/errors/errors.js

@@ -0,0 +1,80 @@
+"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;
+class ErrorWithStatusCode extends Error {
+    constructor(message, errorCode) {
+        super(message);
+        this.errorCode = errorCode;
+    }
+}
+exports.ErrorWithStatusCode = ErrorWithStatusCode;
+class ContractError extends ErrorWithStatusCode {
+    constructor(message, errorCode) {
+        super(message, errorCode);
+        this.name = 'ContractError';
+    }
+}
+exports.ContractError = ContractError;
+class FetchError extends ErrorWithStatusCode {
+    constructor(message, errorCode) {
+        super(message, errorCode);
+        this.name = 'FetchError';
+    }
+}
+exports.FetchError = FetchError;
+class AddressError extends ErrorWithStatusCode {
+    constructor(message, errorCode) {
+        super(message, errorCode);
+        this.name = 'AddressError';
+    }
+}
+exports.AddressError = AddressError;
+class WalletError extends ErrorWithStatusCode {
+    constructor(message, errorCode) {
+        super(message, errorCode);
+        this.name = 'WalletError';
+    }
+}
+exports.WalletError = WalletError;
+class KeyError extends ErrorWithStatusCode {
+    constructor(message, errorCode) {
+        super(message, errorCode);
+        this.name = 'KeyError';
+    }
+}
+exports.KeyError = KeyError;
+class FormatError extends ErrorWithStatusCode {
+    constructor(message, errorCode) {
+        super(message, errorCode);
+        this.name = 'FormatError';
+    }
+}
+exports.FormatError = FormatError;
+class BitError extends ErrorWithStatusCode {
+    constructor(message, errorCode) {
+        super(message, errorCode);
+        this.name = 'BitError';
+    }
+}
+exports.BitError = BitError;
+class MetadataError extends ErrorWithStatusCode {
+    constructor(message, errorCode) {
+        super(message, errorCode);
+        this.name = 'MetadataError';
+    }
+}
+exports.MetadataError = MetadataError;
+class SettingError extends ErrorWithStatusCode {
+    constructor(message, errorCode) {
+        super(message, errorCode);
+        this.name = 'SettingError';
+    }
+}
+exports.SettingError = SettingError;
+class EVMCallError extends ErrorWithStatusCode {
+    constructor(message, errorCode) {
+        super(message, errorCode);
+        this.name = 'EVMCallError';
+    }
+}
+exports.EVMCallError = EVMCallError;

package/dist/errors/index.d.ts

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

package/dist/errors/index.js

@@ -0,0 +1,30 @@
+"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;
+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; } });
+Object.defineProperty(exports, "statusFetchError", { enumerable: true, get: function () { return instances_1.statusFetchError; } });
+Object.defineProperty(exports, "tvmAddressError", { enumerable: true, get: function () { return instances_1.tvmAddressError; } });
+Object.defineProperty(exports, "evmAddressError", { enumerable: true, get: function () { return instances_1.evmAddressError; } });
+Object.defineProperty(exports, "unknownWalletError", { enumerable: true, get: function () { return instances_1.unknownWalletError; } });
+Object.defineProperty(exports, "unsupportedKeyError", { enumerable: true, get: function () { return instances_1.unsupportedKeyError; } });
+Object.defineProperty(exports, "unsupportedFormatError", { enumerable: true, get: function () { return instances_1.unsupportedFormatError; } });
+Object.defineProperty(exports, "notMultiplyOf8Error", { enumerable: true, get: function () { return instances_1.notMultiplyOf8Error; } });
+Object.defineProperty(exports, "prefixError", { enumerable: true, get: function () { return instances_1.prefixError; } });
+Object.defineProperty(exports, "emptySettingError", { enumerable: true, get: function () { return instances_1.emptySettingError; } });
+Object.defineProperty(exports, "invalidMethodNameError", { enumerable: true, get: function () { return instances_1.invalidMethodNameError; } });
+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; } });
+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; } });
+Object.defineProperty(exports, "AddressError", { enumerable: true, get: function () { return errors_1.AddressError; } });
+Object.defineProperty(exports, "WalletError", { enumerable: true, get: function () { return errors_1.WalletError; } });
+Object.defineProperty(exports, "KeyError", { enumerable: true, get: function () { return errors_1.KeyError; } });
+Object.defineProperty(exports, "FormatError", { enumerable: true, get: function () { return errors_1.FormatError; } });
+Object.defineProperty(exports, "BitError", { enumerable: true, get: function () { return errors_1.BitError; } });
+Object.defineProperty(exports, "MetadataError", { enumerable: true, get: function () { return errors_1.MetadataError; } });
+Object.defineProperty(exports, "SettingError", { enumerable: true, get: function () { return errors_1.SettingError; } });
+Object.defineProperty(exports, "EVMCallError", { enumerable: true, get: function () { return errors_1.EVMCallError; } });

package/dist/errors/instances.d.ts

@@ -0,0 +1,16 @@
+import { ContractError, FetchError, AddressError, WalletError, KeyError, FormatError, BitError, MetadataError, SettingError, EVMCallError } from './errors';
+export declare const emptyContractError: ContractError;
+export declare const operationFetchError: FetchError;
+export declare const statusFetchError: (msg: string) => FetchError;
+export declare const tvmAddressError: (addr: string) => AddressError;
+export declare const evmAddressError: (addr: string) => AddressError;
+export declare const unknownWalletError: (version: string) => WalletError;
+export declare const unsupportedKeyError: (key: string) => KeyError;
+export declare const unsupportedFormatError: FormatError;
+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 profilingFetchError: (msg: string) => FetchError;
+export declare const emptyArrayError: (msg: string) => FetchError;

package/dist/errors/instances.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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);
+exports.statusFetchError = statusFetchError;
+const tvmAddressError = (addr) => new errors_1.AddressError(`invalid tvm address ${addr}`, 103);
+exports.tvmAddressError = tvmAddressError;
+const evmAddressError = (addr) => new errors_1.AddressError(`invalid evm address ${addr}`, 104);
+exports.evmAddressError = evmAddressError;
+const unknownWalletError = (version) => new errors_1.WalletError(`Unknown wallet version ${version}`, 105);
+exports.unknownWalletError = unknownWalletError;
+const unsupportedKeyError = (key) => new errors_1.KeyError(`Unsupported onchain key: ${key}`, 106);
+exports.unsupportedKeyError = unsupportedKeyError;
+exports.unsupportedFormatError = new errors_1.FormatError('Only snake format is supported', 107);
+exports.notMultiplyOf8Error = new errors_1.BitError('Number remaining of bits is not multiply of 8', 108);
+exports.prefixError = new errors_1.MetadataError('Unexpected wrappers metadata content prefix', 109);
+const emptySettingError = (setting) => new errors_1.SettingError(`unexpected empty ${setting}. Make sure the settings contract is valid.`, 110);
+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 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;

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { TacSdk } from './sdk/TacSdk';
+export { OperationTracker } from './sdk/OperationTracker';
+export { startTracking } 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 { orbsOpener, liteClientOpener } from './adapters/contractOpener';
+export * from './errors';

package/dist/index.js

@@ -0,0 +1,35 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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;
+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; } });
+__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 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 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);

package/dist/sdk/Consts.d.ts

@@ -0,0 +1,6 @@
+export declare const TRANSACTION_TON_AMOUNT: bigint;
+export declare const JETTON_TRANSFER_FORWARD_TON_AMOUNT: bigint;
+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;

package/dist/sdk/Consts.js

@@ -0,0 +1,10 @@
+"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.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.35);
+exports.JETTON_TRANSFER_FORWARD_TON_AMOUNT = (0, ton_1.toNano)(0.2);
+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_]*$/;

package/dist/sdk/OperationTracker.d.ts

@@ -0,0 +1,15 @@
+import { Network, TransactionLinker, SimplifiedStatuses, StatusInfosByOperationId, StatusInfo, OperationIdsByShardsKey, ExecutionStages, ExecutionStagesByOperationId } from '../structs/Struct';
+export declare class OperationTracker {
+    readonly TERMINATED_STATUS = "TVMMerkleMessageExecuted";
+    readonly BRIDGE_TERMINATED_STATUS = "EVMMerkleMessageExecuted";
+    readonly network: Network;
+    readonly customLiteSequencerEndpoints: string[];
+    constructor(network: Network, customLiteSequencerEndpoints?: string[]);
+    getOperationId(transactionLinker: TransactionLinker): Promise<string>;
+    getOperationIdsByShardsKeys(shardsKeys: string[], caller: string): Promise<OperationIdsByShardsKey>;
+    getStageProfiling(operationId: string): Promise<ExecutionStages>;
+    getStageProfilings(operationIds: string[]): Promise<ExecutionStagesByOperationId>;
+    getOperationStatuses(operationIds: string[]): Promise<StatusInfosByOperationId>;
+    getOperationStatus(operationId: string): Promise<StatusInfo>;
+    getSimplifiedOperationStatus(transactionLinker: TransactionLinker, isBridgeOperation?: boolean): Promise<SimplifiedStatuses>;
+}

package/dist/sdk/OperationTracker.js

@@ -0,0 +1,128 @@
+"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");
+class OperationTracker {
+    constructor(network, customLiteSequencerEndpoints) {
+        this.TERMINATED_STATUS = 'TVMMerkleMessageExecuted';
+        this.BRIDGE_TERMINATED_STATUS = 'EVMMerkleMessageExecuted';
+        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);
+    }
+    async getOperationId(transactionLinker) {
+        for (const endpoint of this.customLiteSequencerEndpoints) {
+            try {
+                const response = await axios_1.default.get(`${endpoint}/operation-id`, {
+                    params: {
+                        shardsKey: transactionLinker.shardsKey,
+                        caller: transactionLinker.caller,
+                        shardCount: transactionLinker.shardCount,
+                        timestamp: transactionLinker.timestamp,
+                    },
+                });
+                return response.data.response || '';
+            }
+            catch (error) {
+                console.error(`Failed to get OperationId with ${endpoint}:`, error);
+            }
+        }
+        throw errors_1.operationFetchError;
+    }
+    async getOperationIdsByShardsKeys(shardsKeys, caller) {
+        const requestBody = {
+            shardsKeys: shardsKeys,
+            caller: caller,
+        };
+        for (const endpoint of this.customLiteSequencerEndpoints) {
+            try {
+                const response = await axios_1.default.post(`${endpoint}/operation-ids-by-shards-keys`, requestBody);
+                return response.data.response;
+            }
+            catch (error) {
+                console.error(`Failed to get OperationIds with ${endpoint}:`, error);
+            }
+        }
+        throw errors_1.operationFetchError;
+    }
+    async getStageProfiling(operationId) {
+        const map = await this.getStageProfilings([operationId]);
+        const result = map[operationId];
+        if (!result) {
+            throw new Error(`No stageProfiling data for operationId=${operationId}`);
+        }
+        return result;
+    }
+    async getStageProfilings(operationIds) {
+        if (!operationIds || operationIds.length === 0) {
+            throw (0, errors_1.emptyArrayError)('operationIds');
+        }
+        for (const endpoint of this.customLiteSequencerEndpoints) {
+            try {
+                const response = await axios_1.default.post(`${endpoint}/stage-profiling`, {
+                    operationIds,
+                }, {
+                    transformResponse: [Utils_1.toCamelCaseTransformer],
+                });
+                return response.data.response;
+            }
+            catch (error) {
+                console.error(`Error fetching status transaction with ${endpoint}:`, error);
+            }
+        }
+        throw (0, errors_1.profilingFetchError)('all endpoints failed to complete request');
+    }
+    async getOperationStatuses(operationIds) {
+        if (!operationIds || operationIds.length === 0) {
+            throw (0, errors_1.emptyArrayError)('operationIds');
+        }
+        for (const endpoint of this.customLiteSequencerEndpoints) {
+            try {
+                const response = await axios_1.default.post(`${endpoint}/status`, {
+                    operationIds,
+                }, {
+                    transformResponse: [Utils_1.toCamelCaseTransformer],
+                });
+                return response.data.response;
+            }
+            catch (error) {
+                console.error(`Error fetching status transaction with ${endpoint}:`, error);
+            }
+        }
+        throw (0, errors_1.statusFetchError)('all endpoints failed to complete request');
+    }
+    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');
+        }
+        return currentStatus;
+    }
+    async getSimplifiedOperationStatus(transactionLinker, isBridgeOperation = false) {
+        const operationId = await this.getOperationId(transactionLinker);
+        if (operationId == '') {
+            return Struct_1.SimplifiedStatuses.OperationIdNotFound;
+        }
+        const status = await this.getOperationStatus(operationId);
+        if (!status.success) {
+            return Struct_1.SimplifiedStatuses.Failed;
+        }
+        const finalStatus = isBridgeOperation ? this.BRIDGE_TERMINATED_STATUS : this.TERMINATED_STATUS;
+        if (status.stage == finalStatus) {
+            return Struct_1.SimplifiedStatuses.Successful;
+        }
+        return Struct_1.SimplifiedStatuses.Pending;
+    }
+}
+exports.OperationTracker = OperationTracker;

package/dist/sdk/StartTracking.d.ts

@@ -0,0 +1,2 @@
+import { Network, TransactionLinker } from '../structs/Struct';
+export declare function startTracking(transactionLinker: TransactionLinker, network: Network, isBridgeOperation?: boolean, customLiteSequencerEndpoints?: string[]): Promise<void>;

package/dist/sdk/StartTracking.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startTracking = startTracking;
+const Consts_1 = require("./Consts");
+const OperationTracker_1 = require("./OperationTracker");
+const Utils_1 = require("./Utils");
+async function startTracking(transactionLinker, network, isBridgeOperation = false, customLiteSequencerEndpoints) {
+    const tracker = new OperationTracker_1.OperationTracker(network, customLiteSequencerEndpoints);
+    console.log('Start tracking operation');
+    console.log('caller: ', transactionLinker.caller);
+    console.log('shardsKey: ', transactionLinker.shardsKey);
+    console.log('shardCount: ', transactionLinker.shardCount);
+    console.log('timestamp: ', transactionLinker.timestamp);
+    let operationId = '';
+    let currentStatus = '';
+    let iteration = 0; // number of iterations
+    let ok = true; // finished successfully
+    let errorMessage;
+    while (true) {
+        ++iteration;
+        if (iteration >= Consts_1.MAX_ITERATION_COUNT) {
+            ok = false;
+            errorMessage = 'maximum number of iterations has been exceeded';
+            break;
+        }
+        console.log();
+        const finalStatus = isBridgeOperation ? tracker.BRIDGE_TERMINATED_STATUS : tracker.TERMINATED_STATUS;
+        if (currentStatus == finalStatus) {
+            break;
+        }
+        if (operationId == '') {
+            console.log('request operationId');
+            try {
+                operationId = await tracker.getOperationId(transactionLinker);
+            }
+            catch {
+                console.log('get operationId error');
+            }
+        }
+        else {
+            console.log('request operationStatus');
+            try {
+                const status = await tracker.getOperationStatuses([operationId]);
+                currentStatus = status[operationId].stage;
+                if (!status[operationId].success) {
+                    if (status[operationId].transactions != null && status[operationId].transactions.length > 0) {
+                        console.log('transactionHash: ', status[operationId].transactions[0]);
+                    }
+                    console.log(status[operationId]);
+                    ok = false;
+                    errorMessage = status[operationId].note != null ? status[operationId].note.errorName : '';
+                    break;
+                }
+            }
+            catch (err) {
+                console.log('get status error:', err);
+            }
+            console.log('operationId:', operationId);
+            console.log('status: ', currentStatus);
+            console.log('time: ', Math.floor(+new Date() / 1000));
+        }
+        await (0, Utils_1.sleep)(10 * 1000);
+    }
+    if (!ok) {
+        console.log(`Finished with error: ${errorMessage}`);
+    }
+    else {
+        console.log('Tracking successfully finished');
+    }
+    const stages = await tracker.getStageProfiling(operationId);
+    formatExecutionStages(stages);
+}
+const formatExecutionStages = (stages) => {
+    const tableData = Object.entries(stages).map(([stage, data]) => ({
+        Stage: stage,
+        Exists: data.exists ? 'Yes' : 'No',
+        Success: data.exists && data.stageData ? (data.stageData.success ? 'Yes' : 'No') : '-',
+        Timestamp: data.exists && data.stageData ? new Date(data.stageData.timestamp * 1000).toLocaleString() : '-',
+        Transactions: data.exists &&
+            data.stageData &&
+            data.stageData.transactions != null &&
+            data.stageData.transactions.length > 0
+            ? data.stageData.transactions.map((t) => t.hash).join(', ')
+            : '-',
+        'Note Content': data.exists && data.stageData && data.stageData.note != null ? data.stageData.note.content : '-',
+        'Error Name': data.exists && data.stageData && data.stageData.note != null ? data.stageData.note.errorName : '-',
+        'Internal Msg': data.exists && data.stageData && data.stageData.note != null ? data.stageData.note.internalMsg : '-',
+        'Bytes Error': data.exists && data.stageData && data.stageData.note != null ? data.stageData.note.internalBytesError : '-',
+    }));
+    console.table(tableData);
+};