@tonappchain/sdk 0.7.0-rc24-test-8 → 0.7.0-rc24-test-9

package/dist/{src/sdk → sdk}/Utils.d.ts

@@ -1,9 +1,10 @@
 import { Address, Cell } from '@ton/ton';
 import { AbiCoder } from 'ethers';
-import type { FT, NFT, TON } from '../assets';
-import { Asset, IConfiguration } from '../interfaces';
+import { FT } from '../assets/FT';
+import { NFT } from '../assets/NFT';
+import { TON } from '../assets/TON';
 import { RandomNumberByTimestamp } from '../structs/InternalStruct';
-import { AssetLike, EvmProxyMsg, FeeParams, TONAsset, TransactionLinker, ValidExecutors, WaitOptions } from '../structs/Struct';
+import { Asset, EvmProxyMsg, FeeParams, TransactionLinker, ValidExecutors, WaitOptions } from '../structs/Struct';
 export declare const sleep: (ms: number) => Promise<unknown>;
 export declare function generateRandomNumber(interval: number): number;
 export declare function generateRandomNumberByTimestamp(): RandomNumberByTimestamp;
@@ -17,18 +18,10 @@ export declare const calculateRawAmount: (amount: number, decimals: number) => b
 export declare const calculateAmount: (rawAmount: bigint, decimals: number) => number;
 export declare const toCamelCaseTransformer: (data: string) => any;
 export declare const generateFeeData: (feeParams?: FeeParams) => Cell | undefined;
-export declare function waitUntilSuccess<T, TContext = unknown, A extends unknown[] = unknown[]>(options: WaitOptions<T, TContext> | undefined, operation: (...args: A) => Promise<T>, operationDescription?: string, ...args: A): Promise<T>;
+export declare function waitUntilSuccess<T, A extends unknown[]>(options: WaitOptions<T> | undefined, operation: (...args: A) => Promise<T>, ...args: A): Promise<T>;
 export declare function formatObjectForLogging(obj: unknown): string;
-export declare function getBouncedAddress(tvmAddress: string): string;
 export declare function aggregateTokens(assets?: Asset[]): Promise<{
     jettons: FT[];
     nfts: NFT[];
     ton?: TON;
 }>;
-export declare function sha256toBigInt(ContractName: string): bigint;
-export declare function mapAssetsToTonAssets(assets: Asset[]): TONAsset[];
-export declare function normalizeAsset(config: IConfiguration, input: AssetLike): Promise<Asset>;
-export declare function normalizeAssets(config: IConfiguration, assets?: AssetLike[]): Promise<Asset[]>;
-export declare function getAddressString(cell?: Cell): string;
-export declare function getNumber(len: number, cell?: Cell): number;
-export declare function getString(cell?: Cell): string;

package/dist/{src/sdk → sdk}/Utils.js

@@ -10,19 +10,9 @@ exports.generateTransactionLinker = generateTransactionLinker;
 exports.calculateEVMTokenAddress = calculateEVMTokenAddress;
 exports.waitUntilSuccess = waitUntilSuccess;
 exports.formatObjectForLogging = formatObjectForLogging;
-exports.getBouncedAddress = getBouncedAddress;
 exports.aggregateTokens = aggregateTokens;
-exports.sha256toBigInt = sha256toBigInt;
-exports.mapAssetsToTonAssets = mapAssetsToTonAssets;
-exports.normalizeAsset = normalizeAsset;
-exports.normalizeAssets = normalizeAssets;
-exports.getAddressString = getAddressString;
-exports.getNumber = getNumber;
-exports.getString = getString;
 const ton_1 = require("@ton/ton");
 const ethers_1 = require("ethers");
-const ton_crypto_1 = require("ton-crypto");
-const assets_1 = require("../assets");
 const errors_1 = require("../errors");
 const Struct_1 = require("../structs/Struct");
 const Consts_1 = require("./Consts");
@@ -141,14 +131,12 @@ const generateFeeData = (feeParams) => {
     }
 };
 exports.generateFeeData = generateFeeData;
-async function waitUntilSuccess(options = {}, operation, operationDescription, ...args) {
+async function waitUntilSuccess(options = {}, operation, ...args) {
     const timeout = options.timeout ?? 300000;
     const maxAttempts = options.maxAttempts ?? 30;
     const delay = options.delay ?? 10000;
     const successCheck = options.successCheck;
-    const context = options.context;
-    const contextPrefix = operationDescription ? `[${operationDescription}] ` : '';
-    options.logger?.debug(`${contextPrefix}Starting wait for success with timeout=${timeout}ms, maxAttempts=${maxAttempts}, delay=${delay}ms`);
+    options.logger?.debug(`Starting wait for success with timeout=${timeout}ms, maxAttempts=${maxAttempts}, delay=${delay}ms`);
     const startTime = Date.now();
     let attempt = 1;
     while (true) {
@@ -156,36 +144,27 @@ async function waitUntilSuccess(options = {}, operation, operationDescription, .
         const elapsedTime = currentTime - startTime;
         try {
             const result = await operation(...args);
-            if (result === undefined || result === null) {
+            if (!result) {
                 throw new Error(`Empty result`);
             }
-            options.logger?.debug(`${contextPrefix}Result: ${formatObjectForLogging(result)}`);
-            if (successCheck && !successCheck(result, context)) {
+            options.logger?.debug(`Result: ${formatObjectForLogging(result)}`);
+            if (successCheck && !successCheck(result)) {
                 throw new Error(`Result is not successful`);
             }
-            options.logger?.debug(`${contextPrefix}Attempt ${attempt} successful`);
-            // Execute custom onSuccess callback if provided
-            if (options.onSuccess) {
-                try {
-                    await options.onSuccess(result, context);
-                }
-                catch (callbackError) {
-                    options.logger?.warn(`${contextPrefix}onSuccess callback error: ${callbackError}`);
-                }
-            }
+            options.logger?.debug(`Attempt ${attempt} successful`);
             return result;
         }
         catch (error) {
             if (elapsedTime >= timeout) {
-                options.logger?.debug(`${contextPrefix}Timeout after ${elapsedTime}ms`);
+                options.logger?.debug(`Timeout after ${elapsedTime}ms`);
                 throw error;
             }
             if (attempt >= maxAttempts) {
-                options.logger?.debug(`${contextPrefix}Max attempts (${maxAttempts}) reached`);
+                options.logger?.debug(`Max attempts (${maxAttempts}) reached`);
                 throw error;
             }
-            options.logger?.debug(`${contextPrefix}Error on attempt ${attempt}: ${error}`);
-            options.logger?.debug(`${contextPrefix}Waiting ${delay}ms before next attempt`);
+            options.logger?.debug(`Error on attempt ${attempt}: ${error}`);
+            options.logger?.debug(`Waiting ${delay}ms before next attempt`);
             await (0, exports.sleep)(delay);
             attempt++;
         }
@@ -194,21 +173,14 @@ async function waitUntilSuccess(options = {}, operation, operationDescription, .
 function formatObjectForLogging(obj) {
     return JSON.stringify(obj, (key, value) => (typeof value === 'bigint' ? value.toString() : value));
 }
-function getBouncedAddress(tvmAddress) {
-    return ton_1.Address.parse(tvmAddress).toString({
-        bounceable: true,
-    });
-}
 async function aggregateTokens(assets) {
     const uniqueAssetsMap = new Map();
     let ton;
     for await (const asset of assets ?? []) {
-        if (asset.rawAmount === 0n)
-            continue;
         if (asset.type !== Struct_1.AssetType.FT)
             continue;
         if (!asset.address) {
-            ton = ton ? ton.addRawAmount(asset.rawAmount) : asset.clone;
+            ton = ton ? await ton.addAmount({ rawAmount: asset.rawAmount }) : asset.clone;
             continue;
         }
         let jetton = uniqueAssetsMap.get(asset.address);
@@ -216,7 +188,7 @@ async function aggregateTokens(assets) {
             jetton = asset.clone;
         }
         else {
-            jetton = jetton.addRawAmount(asset.rawAmount);
+            jetton = await jetton.addAmount({ rawAmount: asset.rawAmount });
         }
         uniqueAssetsMap.set(asset.address, jetton);
     }
@@ -234,66 +206,3 @@ async function aggregateTokens(assets) {
         ton,
     };
 }
-function sha256toBigInt(ContractName) {
-    const hash = (0, ton_crypto_1.sha256_sync)(ContractName);
-    return BigInt('0x' + hash.toString('hex'));
-}
-function mapAssetsToTonAssets(assets) {
-    return assets.map((asset) => ({
-        amount: asset.rawAmount.toString(),
-        tokenAddress: asset.address || '',
-        assetType: asset.type,
-    }));
-}
-async function normalizeAsset(config, input) {
-    if (typeof input.generatePayload === 'function') {
-        return input;
-    }
-    const address = 'address' in input && input.address ? input.address : '';
-    if ('itemIndex' in input) {
-        const args = {
-            address,
-            tokenType: Struct_1.AssetType.NFT,
-            addressType: Struct_1.NFTAddressType.COLLECTION,
-            index: BigInt(input.itemIndex),
-        };
-        return await assets_1.AssetFactory.from(config, args);
-    }
-    try {
-        const ftArgs = {
-            address,
-            tokenType: Struct_1.AssetType.FT,
-        };
-        const asset = await assets_1.AssetFactory.from(config, ftArgs);
-        const rawAmount = 'rawAmount' in input ? input.rawAmount : undefined;
-        const amount = 'amount' in input ? input.amount : 0;
-        return rawAmount ? asset.withRawAmount(rawAmount) : asset.withAmount(amount);
-    }
-    catch (e) {
-        console.warn('Failed to normalize FT asset', e);
-    }
-    const itemArgs = {
-        address,
-        tokenType: Struct_1.AssetType.NFT,
-        addressType: Struct_1.NFTAddressType.ITEM,
-    };
-    return await assets_1.AssetFactory.from(config, itemArgs);
-}
-async function normalizeAssets(config, assets) {
-    if (!assets || assets.length === 0)
-        return [];
-    const normalized = [];
-    for (const a of assets) {
-        normalized.push(await normalizeAsset(config, a));
-    }
-    return normalized;
-}
-function getAddressString(cell) {
-    return cell?.beginParse().loadAddress().toString({ bounceable: true, testOnly: false }) ?? '';
-}
-function getNumber(len, cell) {
-    return cell?.beginParse().loadUint(len) ?? 0;
-}
-function getString(cell) {
-    return cell?.beginParse().loadStringTail() ?? '';
-}

package/dist/{src/sdk → sdk}/Validator.d.ts

@@ -1,6 +1,6 @@
-import { EvmProxyMsg, TACSimulationParams } from '../structs/Struct';
+import { EvmProxyMsg, TACSimulationRequest } from '../structs/Struct';
 export declare class Validator {
-    static validateTACSimulationParams(req: TACSimulationParams): void;
+    static validateTACSimulationRequest(req: TACSimulationRequest): void;
     static validateEVMProxyMsg(evmProxyMsg: EvmProxyMsg): void;
     static validateTVMAddresses(addresses?: string[]): void;
     static validateEVMAddresses(addresses?: string[]): void;

package/dist/{src/sdk → sdk}/Validator.js

@@ -3,12 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Validator = void 0;
 const ton_1 = require("@ton/ton");
 const ethers_1 = require("ethers");
-const errors_1 = require("../errors");
+const instances_1 = require("../errors/instances");
 class Validator {
-    static validateTACSimulationParams(req) {
+    static validateTACSimulationRequest(req) {
         this.validateEVMAddress(req.tacCallParams.target);
-        req.evmValidExecutors?.forEach(this.validateEVMAddress);
-        req.tvmValidExecutors?.forEach(this.validateTVMAddress);
+        req.evmValidExecutors.forEach(this.validateEVMAddress);
+        req.tvmValidExecutors.forEach(this.validateTVMAddress);
         req.tonAssets.forEach((asset) => {
             // if empty then it's native TON
             if (asset.tokenAddress !== '') {
@@ -31,12 +31,12 @@ class Validator {
             ton_1.Address.parse(address); // will throw on error address
         }
         catch {
-            throw (0, errors_1.tvmAddressError)(address);
+            throw (0, instances_1.tvmAddressError)(address);
         }
     }
     static validateEVMAddress(address) {
         if (!address.startsWith('0x') || !(0, ethers_1.isAddress)(address)) {
-            throw (0, errors_1.evmAddressError)(address);
+            throw (0, instances_1.evmAddressError)(address);
         }
     }
 }

package/dist/{src/sender → sender}/BatchSender.d.ts

@@ -1,7 +1,8 @@
-import type { Asset, ContractOpener, SenderAbstraction } from '../interfaces';
 import type { SendResult, ShardTransaction } from '../structs/InternalStruct';
+import type { Asset, ContractOpener } from '../structs/Struct';
 import { Network } from '../structs/Struct';
 import { HighloadWalletV3 } from '../wrappers/HighloadWalletV3';
+import { SenderAbstraction } from './SenderAbstraction';
 export declare class BatchSender implements SenderAbstraction {
     private wallet;
     private secretKey;

package/dist/{src/sender → sender}/RawSender.d.ts

@@ -1,12 +1,12 @@
-import type { Asset, ContractOpener } from '../interfaces';
-import { SenderAbstraction, WalletInstanse } from '../interfaces';
 import type { SendResult, ShardTransaction } from '../structs/InternalStruct';
+import type { Asset, ContractOpener } from '../structs/Struct';
 import { Network } from '../structs/Struct';
+import { SenderAbstraction, WalletInstance } from './SenderAbstraction';
 export declare class RawSender implements SenderAbstraction {
     private wallet;
     private secretKey;
     private maxBatchSize;
-    constructor(wallet: WalletInstanse, secretKey: Buffer, maxBatchSize?: number);
+    constructor(wallet: WalletInstance, secretKey: Buffer, maxBatchSize?: number);
     getBalanceOf(asset: Asset): Promise<bigint>;
     getBalance(contractOpener: ContractOpener): Promise<bigint>;
     sendShardTransactions(shardTransactions: ShardTransaction[], _chain: Network, contractOpener: ContractOpener): Promise<SendResult[]>;

package/dist/sender/SenderAbstraction.d.ts

@@ -0,0 +1,22 @@
+import type { Contract, ContractProvider, MessageRelaxed, SendMode } from '@ton/ton';
+import type { SendResult, ShardTransaction } from '../structs/InternalStruct';
+import type { Asset, ContractOpener } from '../structs/Struct';
+import { Network } from '../structs/Struct';
+export declare const sleep: (ms: number) => Promise<unknown>;
+export interface WalletInstance extends Contract {
+    getSeqno(provider: ContractProvider): Promise<number>;
+    sendTransfer(provider: ContractProvider, args: {
+        seqno: number;
+        secretKey: Buffer;
+        messages: MessageRelaxed[];
+        sendMode: SendMode;
+        timeout?: number;
+    }): Promise<void>;
+}
+export interface SenderAbstraction {
+    sendShardTransaction(shardTransaction: ShardTransaction, chain?: Network, contractOpener?: ContractOpener): Promise<SendResult>;
+    sendShardTransactions(shardTransactions: ShardTransaction[], chain?: Network, contractOpener?: ContractOpener): Promise<SendResult[]>;
+    getSenderAddress(): string;
+    getBalance(contractOpener: ContractOpener): Promise<bigint>;
+    getBalanceOf(asset: Asset): Promise<bigint>;
+}

package/dist/sender/SenderAbstraction.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = void 0;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+exports.sleep = sleep;

package/dist/{src/sender → sender}/SenderFactory.d.ts

@@ -1,8 +1,8 @@
 import { WalletContractV2R1, WalletContractV2R2, WalletContractV3R1, WalletContractV3R2, WalletContractV4, WalletContractV5R1 } from '@ton/ton';
 import { TonConnectUI } from '@tonconnect/ui';
-import { SenderAbstraction } from '../interfaces';
 import { Network } from '../structs/Struct';
 import { HighloadWalletV3 } from '../wrappers/HighloadWalletV3';
+import { SenderAbstraction } from './SenderAbstraction';
 export type WalletVersion = 'V2R1' | 'V2R2' | 'V3R1' | 'V3R2' | 'V4' | 'V5R1' | 'HIGHLOAD_V3';
 export declare const wallets: {
     V2R1: typeof WalletContractV2R1;

package/dist/{src/sender → sender}/TonConnectSender.d.ts

@@ -1,7 +1,7 @@
 import { TonConnectUI } from '@tonconnect/ui';
-import { Asset, ContractOpener, SenderAbstraction } from '../interfaces';
 import type { SendResult, ShardTransaction } from '../structs/InternalStruct';
-import { Network } from '../structs/Struct';
+import { Asset, ContractOpener, Network } from '../structs/Struct';
+import { SenderAbstraction } from './SenderAbstraction';
 export declare class TonConnectSender implements SenderAbstraction {
     readonly tonConnect: TonConnectUI;
     constructor(tonConnect: TonConnectUI);

package/dist/{src/sender → sender}/TonConnectSender.js

@@ -4,8 +4,8 @@ exports.TonConnectSender = void 0;
 const ton_1 = require("@ton/ton");
 const protocol_1 = require("@tonconnect/protocol");
 const ui_1 = require("@tonconnect/ui");
-const Utils_1 = require("../sdk/Utils");
 const Struct_1 = require("../structs/Struct");
+const SenderAbstraction_1 = require("./SenderAbstraction");
 const CHUNK_SIZE = 4;
 class TonConnectSender {
     constructor(tonConnect) {
@@ -48,7 +48,7 @@ class TonConnectSender {
                 break; // Stop sending after first error
             }
             if (i + chunkSize < messages.length) {
-                await (0, Utils_1.sleep)(1000);
+                await (0, SenderAbstraction_1.sleep)(1000);
             }
         }
         return responses;

package/dist/{src/sender → sender}/index.d.ts

@@ -1,3 +1,3 @@
-export * from '../interfaces/SenderAbstraction';
 export * from './BatchSender';
+export * from './SenderAbstraction';
 export * from './SenderFactory';

package/dist/{src/sender → sender}/index.js

@@ -14,6 +14,6 @@ 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 });
-__exportStar(require("../interfaces/SenderAbstraction"), exports);
 __exportStar(require("./BatchSender"), exports);
+__exportStar(require("./SenderAbstraction"), exports);
 __exportStar(require("./SenderFactory"), exports);

package/dist/{src/structs → structs}/InternalStruct.d.ts

@@ -1,8 +1,7 @@
 import { Cell } from '@ton/ton';
+import { mainnet, testnet } from '@tonappchain/artifacts';
 import { AbstractProvider, ethers } from 'ethers';
-import { ICrossChainLayer, ISettings, ISAFactory, ITokenUtils } from '../../artifacts/tacTypes';
-import { ContractOpener } from '../interfaces';
-import { CurrencyType, ExecutionStagesByOperationId, Network, OperationIdsByShardsKey, OperationType, StatusInfosByOperationId, SuggestedTVMExecutorFee, TACSimulationResult } from './Struct';
+import { ContractOpener, ExecutionStagesByOperationId, Network, OperationIdsByShardsKey, OperationType, StatusInfosByOperationId, SuggestedTONExecutorFee, TACSimulationResult } from './Struct';
 export type ShardMessage = {
     address: string;
     value: bigint;
@@ -35,13 +34,13 @@ export type InternalTONParams = {
 };
 export type InternalTACParams = {
     provider: AbstractProvider;
-    crossChainLayer: ICrossChainLayer;
-    settings: ISettings;
-    tokenUtils: ITokenUtils;
-    smartAccountFactory: ISAFactory;
+    crossChainLayer: testnet.tac.wrappers.CrossChainLayerTAC | mainnet.tac.wrappers.CrossChainLayerTAC;
+    settings: testnet.tac.wrappers.SettingsTAC | mainnet.tac.wrappers.SettingsTAC;
+    tokenUtils: testnet.tac.wrappers.TokenUtilsTAC | mainnet.tac.wrappers.TokenUtilsTAC;
     trustedTACExecutors: string[];
     trustedTONExecutors: string[];
     abiCoder: ethers.AbiCoder;
+    smartAccountFactory: testnet.tac.wrappers.TacSAFactoryTAC | mainnet.tac.wrappers.TacSAFactoryTAC;
 };
 export type ResponseBase<T> = {
     response: T;
@@ -52,8 +51,7 @@ export type StatusesResponse = ResponseBase<StatusInfosByOperationId>;
 export type OperationIdsByShardsKeyResponse = ResponseBase<OperationIdsByShardsKey>;
 export type StageProfilingResponse = ResponseBase<ExecutionStagesByOperationId>;
 export type TACSimulationResponse = ResponseBase<TACSimulationResult>;
-export type SuggestedTVMExecutorFeeResponse = ResponseBase<SuggestedTVMExecutorFee>;
-export type ConvertCurrencyResponse = ResponseBase<ConvertedCurrencyRawResult>;
+export type SuggestedTONExecutorFeeResponse = ResponseBase<SuggestedTONExecutorFee>;
 export interface SendResult {
     success: boolean;
     result?: unknown;
@@ -78,9 +76,6 @@ export type ToncenterTransaction = {
         hash: string;
         opcode: string;
     };
-    outMsgs: {
-        hash: string;
-    }[];
 };
 export type TransactionDepth = {
     hash: string;
@@ -96,16 +91,3 @@ export type TxFinalizerConfig = {
         value: string;
     };
 };
-export type USDPriceInfoRaw = {
-    spot: string;
-    ema: string;
-    decimals: number;
-};
-export type ConvertedCurrencyRawResult = {
-    spotValue: string;
-    emaValue: string;
-    decimals: number;
-    currency: CurrencyType;
-    tacPrice: USDPriceInfoRaw;
-    tonPrice: USDPriceInfoRaw;
-};

package/dist/structs/Services.d.ts

@@ -0,0 +1,41 @@
+import { mainnet, testnet } from '@tonappchain/artifacts';
+import type { SenderAbstraction } from '../sender';
+import { InternalTACParams, InternalTONParams } from './InternalStruct';
+import { Asset, CrosschainTx, EvmProxyMsg, ExecutionFeeEstimationResult, ExecutionStages, ExecutionStagesByOperationId, Network, OperationIdsByShardsKey, OperationType, SimplifiedStatuses, StatusInfo, StatusInfosByOperationId, SuggestedTONExecutorFee, TACSimulationRequest, TACSimulationResult, TransactionLinker, WaitOptions } from './Struct';
+export interface IConfiguration {
+    readonly network: Network;
+    readonly artifacts: typeof testnet | typeof mainnet;
+    readonly TONParams: InternalTONParams;
+    readonly TACParams: InternalTACParams;
+    readonly liteSequencerEndpoints: string[];
+    readonly nativeTONAddress: string;
+    nativeTACAddress(): Promise<string>;
+    readonly getTrustedTACExecutors: string[];
+    readonly getTrustedTONExecutors: string[];
+    closeConnections(): unknown;
+    isContractDeployedOnTVM(address: string): Promise<boolean>;
+}
+export interface ILogger {
+    debug(...arg: unknown[]): void;
+    info(...arg: unknown[]): void;
+    warn(...arg: unknown[]): void;
+    error(...arg: unknown[]): void;
+}
+export interface ISimulator {
+    simulateTACMessage(req: TACSimulationRequest): Promise<TACSimulationResult>;
+    simulateTransactions(sender: SenderAbstraction, txs: CrosschainTx[]): Promise<TACSimulationResult[]>;
+    getTVMExecutorFeeInfo(assets: Asset[], feeSymbol: string): Promise<SuggestedTONExecutorFee>;
+    getTransactionSimulationInfo(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: Asset[]): Promise<ExecutionFeeEstimationResult>;
+    getSimulationInfoForTransaction(evmProxyMsg: EvmProxyMsg, transactionLinker: TransactionLinker, assets: Asset[], allowSimulationError?: boolean, isRoundTrip?: boolean, evmValidExecutors?: string[], tvmValidExecutors?: string[]): Promise<ExecutionFeeEstimationResult>;
+}
+export interface IOperationTracker {
+    getOperationType(operationId: string, waitOptions?: WaitOptions<OperationType>): Promise<OperationType>;
+    getOperationId(transactionLinker: TransactionLinker, waitOptions?: WaitOptions<string>): Promise<string>;
+    getOperationIdByTransactionHash(transactionHash: string, 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>;
+}