@tonappchain/sdk 0.7.3-rc7 → 0.8.0

package/dist/src/sdk/StartTracking.d.ts

@@ -1,6 +1,10 @@
 import { ContractOpener, ILogger } from '../interfaces';
 import { ITxFinalizer } from '../interfaces/ITxFinalizer';
 import { ExecutionStages, Network, TransactionLinkerWithOperationId } from '../structs/Struct';
+/**
+ * @deprecated Use `TacSdk.sendCrossChainTransaction(...)` instead. It already waits for operation ID
+ * and full cross-chain finalization by default via `waitOperationId` and `waitFinalization` options.
+ */
 export declare function startTracking(transactionLinker: TransactionLinkerWithOperationId, network: Network, options?: {
     customLiteSequencerEndpoints?: string[];
     delay?: number;
@@ -12,6 +16,10 @@ export declare function startTracking(transactionLinker: TransactionLinkerWithOp
     contractOpener?: ContractOpener;
     cclAddress?: string;
 }): Promise<void | ExecutionStages>;
+/**
+ * @deprecated Use `TacSdk.sendCrossChainTransaction(...)` for new single-transaction flows. It already waits
+ * for operation ID and full cross-chain finalization by default via `waitOperationId` and `waitFinalization` options.
+ */
 export declare function startTrackingMultiple(transactionLinkers: TransactionLinkerWithOperationId[], network: Network, options?: {
     customLiteSequencerEndpoints?: string[];
     delay?: number;

package/dist/src/sdk/StartTracking.js

@@ -4,13 +4,27 @@ exports.startTracking = startTracking;
 exports.startTrackingMultiple = startTrackingMultiple;
 exports.printExecutionStagesTable = printExecutionStagesTable;
 const Struct_1 = require("../structs/Struct");
+const Artifacts_1 = require("./Artifacts");
+const Configuration_1 = require("./Configuration");
 const Consts_1 = require("./Consts");
 const Logger_1 = require("./Logger");
 const OperationTracker_1 = require("./OperationTracker");
 const Utils_1 = require("./Utils");
+/**
+ * @deprecated Use `TacSdk.sendCrossChainTransaction(...)` instead. It already waits for operation ID
+ * and full cross-chain finalization by default via `waitOperationId` and `waitFinalization` options.
+ */
 async function startTracking(transactionLinker, network, options) {
     const { customLiteSequencerEndpoints, delay = 10, maxIterationCount = Consts_1.MAX_ITERATION_COUNT, returnValue = false, tableView = true, logger = new Logger_1.NoopLogger(), txFinalizer, contractOpener, cclAddress, } = options || {};
-    const tracker = new OperationTracker_1.OperationTracker(network, customLiteSequencerEndpoints, logger);
+    const artifacts = (0, Artifacts_1.getArtifacts)(network);
+    const liteSequencerEndpoints = customLiteSequencerEndpoints && customLiteSequencerEndpoints.length !== 0
+        ? customLiteSequencerEndpoints
+        : artifacts.PUBLIC_LITE_SEQUENCER_ENDPOINTS;
+    if (network === Struct_1.Network.DEV && liteSequencerEndpoints.length === 0) {
+        throw new Error('For DEV network, custom lite sequencer endpoints must be provided');
+    }
+    const trackerConfig = new Configuration_1.Configuration(network, artifacts, {}, {}, liteSequencerEndpoints, logger);
+    const tracker = new OperationTracker_1.OperationTracker(trackerConfig, logger);
     logger.debug(`Start tracking operation\n` +
         `caller: ${transactionLinker.caller}\n` +
         `shardsKey: ${transactionLinker.shardsKey}\n` +
@@ -102,6 +116,10 @@ async function startTracking(transactionLinker, network, options) {
         logger.debug(formatExecutionStages(profilingData));
     }
 }
+/**
+ * @deprecated Use `TacSdk.sendCrossChainTransaction(...)` for new single-transaction flows. It already waits
+ * for operation ID and full cross-chain finalization by default via `waitOperationId` and `waitFinalization` options.
+ */
 async function startTrackingMultiple(transactionLinkers, network, options) {
     const { customLiteSequencerEndpoints, delay = 10, maxIterationCount = Consts_1.MAX_ITERATION_COUNT, returnValue = false, tableView = true, txFinalizer, contractOpener, cclAddress, logger = new Logger_1.NoopLogger(), } = options || {};
     logger.debug(`Start tracking ${transactionLinkers.length} operations`);

package/dist/src/sdk/TACTransactionManager.js

@@ -37,7 +37,7 @@ class TACTransactionManager {
             tvmExecutorFee = BigInt(suggestedFee.inTAC);
         }
         const protocolFee = await this.config.TACParams.crossChainLayer.getProtocolFee();
-        const shardsKey = BigInt(Math.round(Math.random() * Consts_1.SHARDS_KEY_RANDOM_RANGE));
+        const shardsKey = BigInt((0, Utils_1.generateRandomNumberByTimestamp)().randomNumber);
         this.logger.debug(`Shards key: ${shardsKey}, Protocol fee: ${protocolFee}`);
         const [toBridge, toBridgeNFT] = await Promise.all([
             Promise.all(assets
@@ -189,11 +189,11 @@ class TACTransactionManager {
         if (!shouldWaitForOperationId) {
             return { txHash: tx.hash };
         }
-        const waitOptions = options?.waitOptions ?? {};
-        waitOptions.successCheck = waitOptions.successCheck ?? ((id) => !!id);
-        waitOptions.logger = waitOptions.logger ?? this.logger;
+        const waitOperationIdOptions = options?.waitOperationIdOptions ?? {};
+        waitOperationIdOptions.successCheck = waitOperationIdOptions.successCheck ?? ((id) => !!id);
+        waitOperationIdOptions.logger = waitOperationIdOptions.logger ?? this.logger;
         const operationId = await this.operationTracker
-            .getOperationIdByTransactionHash(tx.hash, waitOptions)
+            .getOperationIdByTransactionHash(tx.hash, waitOperationIdOptions)
             .catch((error) => {
             this.logger.error(`Error while waiting for operation ID by transaction hash: ${error}`);
             return undefined;

package/dist/src/sdk/TONTransactionManager.d.ts

@@ -11,6 +11,7 @@ export declare class TONTransactionManager implements ITONTransactionManager {
     private prepareCrossChainTransaction;
     private generateCrossChainMessages;
     sendCrossChainTransaction(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, tx: CrosschainTx): Promise<TransactionLinkerWithOperationId>;
+    private resolveOperationId;
     sendCrossChainTransactions(sender: SenderAbstraction, txs: BatchCrossChainTx[], options?: CrossChainTransactionsOptions): Promise<TransactionLinkerWithOperationId[]>;
     private prepareBatchTransactions;
     private waitForOperationIds;

package/dist/src/sdk/TONTransactionManager.js

@@ -188,18 +188,13 @@ class TONTransactionManager {
             await this.config.TONParams.contractOpener.trackTransactionTree(sender.getSenderAddress(), hash);
             this.logger.info(`Transaction tree successful`);
         }
-        const waitOptions = tx.options?.waitOptions ?? {};
-        waitOptions.successCheck = waitOptions.successCheck ?? ((id) => !!id);
-        waitOptions.logger = waitOptions.logger ?? this.logger;
-        const operationId = await this.operationTracker
-            .getOperationId(transactionLinker, waitOptions)
-            .catch((error) => {
-            this.logger.error(`Error while waiting for operation ID: ${error}`);
-            return undefined;
-        });
+        const waitOperationIdOptions = tx.options?.waitOperationIdOptions ?? {};
+        waitOperationIdOptions.successCheck = waitOperationIdOptions.successCheck ?? ((id) => !!id);
+        waitOperationIdOptions.logger = waitOperationIdOptions.logger ?? this.logger;
+        const operationId = await this.resolveOperationId(sendTransactionResult.boc, transactionLinker, waitOperationIdOptions);
         const shouldWaitForFinalization = tx.options?.waitFinalization ?? true;
         if (!shouldWaitForFinalization) {
-            return { sendTransactionResult, ...transactionLinker };
+            return { sendTransactionResult, operationId, ...transactionLinker };
         }
         if (!operationId) {
             throw errors_1.operationIdRequiredForFinalizationError;
@@ -224,6 +219,24 @@ class TONTransactionManager {
         await this.operationTracker.getStageProfiling(operationId, finalizationWaitOptions);
         return { sendTransactionResult, operationId, ...transactionLinker };
     }
+    async resolveOperationId(boc, transactionLinker, waitOperationIdOptions) {
+        if (this.config.TONParams.tonIndexer) {
+            const operationId = await this.operationTracker
+                .getOperationIdByTonTransactionBoc(boc, waitOperationIdOptions)
+                .catch((error) => {
+                this.logger.error(`Error while waiting for operation ID by TON transaction BOC: ${error}`);
+                return undefined;
+            });
+            if (operationId) {
+                return operationId;
+            }
+            this.logger.debug('Operation ID by TON transaction BOC not found; trying transaction linker');
+        }
+        return this.operationTracker.getOperationId(transactionLinker, waitOperationIdOptions).catch((error) => {
+            this.logger.error(`Error while waiting for operation ID by transaction linker: ${error}`);
+            return undefined;
+        });
+    }
     async sendCrossChainTransactions(sender, txs, options) {
         const caller = sender.getSenderAddress();
         this.logger.debug(`Preparing ${txs.length} cross-chain transactions for ${caller}`);
@@ -238,7 +251,7 @@ class TONTransactionManager {
         }
         const shouldWaitForOperationIds = options?.waitOperationIds ?? true;
         return shouldWaitForOperationIds
-            ? await this.waitForOperationIds(transactionLinkers, caller, options?.waitOptions ?? {})
+            ? await this.waitForOperationIds(transactionLinkers, caller, options?.waitOperationIdOptions ?? {})
             : transactionLinkers;
     }
     async prepareBatchTransactions(txs, sender) {
@@ -260,15 +273,15 @@ class TONTransactionManager {
             transactionLinkers: results.map((r) => r.transactionLinker),
         };
     }
-    async waitForOperationIds(transactionLinkers, caller, waitOptions) {
+    async waitForOperationIds(transactionLinkers, caller, waitOperationIdOptions) {
         this.logger.debug(`Waiting for operation IDs`);
         try {
-            waitOptions.successCheck =
-                waitOptions.successCheck ??
+            waitOperationIdOptions.successCheck =
+                waitOperationIdOptions.successCheck ??
                     ((operationIds) => Object.keys(operationIds).length == transactionLinkers.length &&
                         Object.values(operationIds).every((ids) => ids.operationIds.length > 0));
-            waitOptions.logger = waitOptions.logger ?? this.logger;
-            const operationIds = await this.operationTracker.getOperationIdsByShardsKeys(transactionLinkers.map((linker) => linker.shardsKey), caller, waitOptions);
+            waitOperationIdOptions.logger = waitOperationIdOptions.logger ?? this.logger;
+            const operationIds = await this.operationTracker.getOperationIdsByShardsKeys(transactionLinkers.map((linker) => linker.shardsKey), caller, waitOperationIdOptions);
             this.logger.debug(`Operation IDs: ${(0, Utils_1.formatObjectForLogging)(operationIds)}`);
             return transactionLinkers.map((linker) => ({
                 ...linker,

package/dist/src/sdk/TacExplorerClient.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TacExplorerClient = void 0;
-const instances_1 = require("../errors/instances");
+const errors_1 = require("../errors");
 const AxiosHttpClient_1 = require("./AxiosHttpClient");
+const Consts_1 = require("./Consts");
 const Utils_1 = require("./Utils");
 class TacExplorerClient {
-    constructor(explorerApiEndpoint, httpClient = new AxiosHttpClient_1.AxiosHttpClient()) {
+    constructor(explorerApiEndpoint, httpClient = new AxiosHttpClient_1.AxiosHttpClient({ timeout: Consts_1.DEFAULT_HTTP_CLIENT_TIMEOUT_MS })) {
         this.explorerApiEndpoint = explorerApiEndpoint;
         this.httpClient = httpClient;
     }
@@ -15,7 +16,7 @@ class TacExplorerClient {
             return response.data;
         }
         catch (error) {
-            throw (0, instances_1.gasPriceFetchError)(`endpoint ${this.explorerApiEndpoint} failed to complete request`, error);
+            throw (0, errors_1.gasPriceFetchError)(`endpoint ${this.explorerApiEndpoint} failed to complete request`, error);
         }
     }
 }

package/dist/src/sdk/TacSdk.d.ts

@@ -3,7 +3,7 @@ import { JettonMinterData, NFTItemData } from '../../artifacts/tonTypes';
 import { FT, NFT, TAC, TON } from '../assets';
 import { ContractOpener, IConfiguration, ILogger, IOperationTracker, ITacExplorerClient, ITacSDK } from '../interfaces';
 import type { SenderAbstraction } from '../sender';
-import { AssetFromFTArg, AssetFromNFTCollectionArg, AssetFromNFTItemArg, AssetLike, BatchCrossChainTxWithAssetLike, CrossChainPayloadResult, CrossChainTransactionOptions, CrossChainTransactionsOptions, CrossChainTransactionToTONOptions, CrosschainTx, EVMAddress, EvmProxyMsg, ExecutionFeeEstimationResult, NFTAddressType, SDKParams, SuggestedTVMExecutorFee, TACCrossChainTransactionResult, TacGasPrice, TACSimulationParams, TACSimulationResult, TransactionLinkerWithOperationId, TVMAddress, UserWalletBalanceExtended, WaitOptions } from '../structs/Struct';
+import { AssetFromFTArg, AssetFromNFTCollectionArg, AssetFromNFTItemArg, AssetLike, BatchCrossChainTxWithAssetLike, CrossChainPayloadResult, CrossChainTransactionOptions, CrossChainTransactionsOptions, CrossChainTransactionToTONOptions, CrosschainTx, EVMAddress, EvmProxyMsg, ExecutionFeeEstimationResult, NFTAddressType, SDKParams, SuggestedTVMExecutorFee, TACCrossChainTransactionResult, TacGasPrice, TACSimulationParams, TACSimulationResult, TransactionLinkerWithOperationId, TVMAddress, UserWalletBalanceExtended } from '../structs/Struct';
 export declare class TacSdk implements ITacSDK {
     readonly config: IConfiguration;
     readonly contactOpener: ContractOpener;
@@ -12,7 +12,6 @@ export declare class TacSdk implements ITacSDK {
     private readonly simulator;
     private readonly tonTransactionManager;
     private readonly tacTransactionManager;
-    private readonly tonIndexer;
     private constructor();
     static create(sdkParams: SDKParams, logger?: ILogger): Promise<TacSdk>;
     closeConnections(): unknown;
@@ -26,8 +25,6 @@ export declare class TacSdk implements ITacSDK {
     sendCrossChainTransaction(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: AssetLike[], options?: CrossChainTransactionOptions): Promise<TransactionLinkerWithOperationId>;
     sendCrossChainTransactionToTON(signer: Wallet, tonTarget: string, assets?: AssetLike[], options?: CrossChainTransactionToTONOptions): Promise<TACCrossChainTransactionResult>;
     sendCrossChainTransactions(sender: SenderAbstraction, txs: BatchCrossChainTxWithAssetLike[], options?: CrossChainTransactionsOptions): Promise<TransactionLinkerWithOperationId[]>;
-    getOperationIdByTonTransactionHash(transactionHash: string, waitOptions?: WaitOptions<string> | null): Promise<string>;
-    getOperationIdByTonTransactionBoc(boc: string, waitOptions?: WaitOptions<string> | null): Promise<string>;
     bridgeTokensToTON(signer: Wallet, value: bigint, tonTarget: string, assets?: AssetLike[], tvmExecutorFee?: bigint, tvmValidExecutors?: string[]): Promise<string>;
     isContractDeployedOnTVM(address: string): Promise<boolean>;
     simulateTACMessage(req: TACSimulationParams): Promise<TACSimulationResult>;
@@ -51,5 +48,4 @@ export declare class TacSdk implements ITacSDK {
     prepareCrossChainTransactionPayload(evmProxyMsg: EvmProxyMsg, senderAddress: string, assets?: AssetLike[], options?: CrossChainTransactionOptions): Promise<CrossChainPayloadResult[]>;
     getTACGasPrice(): Promise<TacGasPrice>;
     getTonContractOpener(): ContractOpener;
-    private toSequencerTonTransactionHash;
 }

package/dist/src/sdk/TacSdk.js

@@ -1,12 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TacSdk = void 0;
-const ton_1 = require("@ton/ton");
-const artifacts_1 = require("../../artifacts");
-const adapters_1 = require("../adapters");
 const assets_1 = require("../assets");
-const errors_1 = require("../errors");
 const Struct_1 = require("../structs/Struct");
+const Artifacts_1 = require("./Artifacts");
 const Configuration_1 = require("./Configuration");
 const Consts_1 = require("./Consts");
 const Logger_1 = require("./Logger");
@@ -17,7 +14,7 @@ const TACTransactionManager_1 = require("./TACTransactionManager");
 const TONTransactionManager_1 = require("./TONTransactionManager");
 const Utils_1 = require("./Utils");
 class TacSdk {
-    constructor(config, simulator, tonTransactionManager, tacTransactionManager, operationTracker, explorerClient, tonIndexer) {
+    constructor(config, simulator, tonTransactionManager, tacTransactionManager, operationTracker, explorerClient) {
         this.config = config;
         this.contactOpener = config.TONParams.contractOpener;
         this.simulator = simulator;
@@ -25,34 +22,19 @@ class TacSdk {
         this.tacTransactionManager = tacTransactionManager;
         this.operationTracker = operationTracker;
         this.explorerClient = explorerClient;
-        this.tonIndexer = tonIndexer;
     }
     static async create(sdkParams, logger = new Logger_1.NoopLogger()) {
         const network = sdkParams.network;
         const delay = sdkParams.delay ?? Consts_1.DEFAULT_DELAY;
         const passLoggerToOpeners = sdkParams.passLoggerToOpeners ?? true;
-        let artifacts;
-        switch (network) {
-            case Struct_1.Network.MAINNET:
-                artifacts = artifacts_1.mainnet;
-                break;
-            case Struct_1.Network.TESTNET:
-                artifacts = artifacts_1.testnet;
-                break;
-            case Struct_1.Network.DEV:
-                artifacts = artifacts_1.dev;
-                break;
-            default:
-                throw new Error(`Unsupported network: ${network}`);
-        }
+        const artifacts = (0, Artifacts_1.getArtifacts)(network);
         const config = await Configuration_1.Configuration.create(network, artifacts, sdkParams.TONParams, sdkParams.TACParams, sdkParams.customLiteSequencerEndpoints, delay, logger, passLoggerToOpeners);
-        const operationTracker = new OperationTracker_1.OperationTracker(network, config.liteSequencerEndpoints, logger);
+        const operationTracker = new OperationTracker_1.OperationTracker(config, logger);
         const explorerClient = new TacExplorerClient_1.TacExplorerClient(artifacts.TAC_EXPLORER_API_ENDPOINT);
         const simulator = new Simulator_1.Simulator(config, operationTracker, logger);
         const tonTransactionManager = new TONTransactionManager_1.TONTransactionManager(config, simulator, operationTracker, logger);
         const tacTransactionManager = new TACTransactionManager_1.TACTransactionManager(config, operationTracker, logger);
-        const tonIndexer = sdkParams.TONParams?.tonIndexer ?? new adapters_1.ToncenterV3Indexer(artifacts.TONCENTER_V3_INDEXER_ENDPOINT);
-        return new TacSdk(config, simulator, tonTransactionManager, tacTransactionManager, operationTracker, explorerClient, tonIndexer);
+        return new TacSdk(config, simulator, tonTransactionManager, tacTransactionManager, operationTracker, explorerClient);
     }
     closeConnections() {
         return this.config.closeConnections();
@@ -104,32 +86,6 @@ class TacSdk {
         })));
         return this.tonTransactionManager.sendCrossChainTransactions(sender, normalizedTxs, options);
     }
-    async getOperationIdByTonTransactionHash(transactionHash, waitOptions) {
-        const cclTransaction = await this.tonIndexer.findCollectibleCrossChainLayerTransaction(transactionHash, this.config.TONParams.crossChainLayerAddress);
-        if (!cclTransaction) {
-            return '';
-        }
-        return this.operationTracker.getOperationIdByTonTransactionHash(this.toSequencerTonTransactionHash(cclTransaction), waitOptions);
-    }
-    async getOperationIdByTonTransactionBoc(boc, waitOptions) {
-        let message;
-        try {
-            message = (0, ton_1.loadMessage)(ton_1.Cell.fromBase64(boc).beginParse());
-        }
-        catch (error) {
-            const reason = error instanceof Error ? error.message : undefined;
-            throw (0, errors_1.invalidTonExternalMessageBocError)(reason);
-        }
-        if (message.info.type !== 'external-in') {
-            throw (0, errors_1.externalInMessageRequiredError)(message.info.type);
-        }
-        const destination = message.info.dest;
-        const transaction = await this.contactOpener.getTransactionByHash(ton_1.Address.parse(destination.toString()), (0, Utils_1.getNormalizedExtMessageHash)(message));
-        if (!transaction) {
-            return '';
-        }
-        return this.getOperationIdByTonTransactionHash(transaction.hash().toString('base64'), waitOptions);
-    }
     async bridgeTokensToTON(signer, value, tonTarget, assets, tvmExecutorFee, tvmValidExecutors) {
         const normalizedAssets = await (0, Utils_1.normalizeAssets)(this.config, assets);
         return this.tacTransactionManager.bridgeTokensToTON(signer, value, tonTarget, normalizedAssets, tvmExecutorFee, tvmValidExecutors);
@@ -235,8 +191,5 @@ class TacSdk {
     getTonContractOpener() {
         return this.contactOpener;
     }
-    toSequencerTonTransactionHash(transaction) {
-        return `0x${(0, Utils_1.normalizeHashToHex)(transaction.hash)}`;
-    }
 }
 exports.TacSdk = TacSdk;

package/dist/src/sdk/TxFinalizer.js

@@ -7,7 +7,7 @@ const Consts_1 = require("./Consts");
 const Logger_1 = require("./Logger");
 const Utils_1 = require("./Utils");
 class TonTxFinalizer {
-    constructor(apiConfig, logger = new Logger_1.NoopLogger(), httpClient = new AxiosHttpClient_1.AxiosHttpClient()) {
+    constructor(apiConfig, logger = new Logger_1.NoopLogger(), httpClient = new AxiosHttpClient_1.AxiosHttpClient({ timeout: Consts_1.DEFAULT_HTTP_CLIENT_TIMEOUT_MS })) {
         this.apiConfig = apiConfig;
         this.logger = logger;
         this.httpClient = httpClient;

package/dist/src/sdk/Utils.js

@@ -108,11 +108,44 @@ const convertKeysToCamelCase = (data) => {
     return data;
 };
 exports.convertKeysToCamelCase = convertKeysToCamelCase;
+function formatFiniteNumber(amount) {
+    const amountString = amount.toString();
+    if (!amountString.includes('e')) {
+        return amountString;
+    }
+    const [coefficient, exponentString] = amountString.split('e');
+    const exponent = Number(exponentString);
+    const [integerPart, fractionalPart = ''] = coefficient.split('.');
+    const digits = integerPart + fractionalPart;
+    const decimalIndex = integerPart.length + exponent;
+    let expanded;
+    if (decimalIndex <= 0) {
+        expanded = `0.${'0'.repeat(-decimalIndex)}${digits}`;
+    }
+    else if (decimalIndex >= digits.length) {
+        expanded = `${digits}${'0'.repeat(decimalIndex - digits.length)}`;
+    }
+    else {
+        expanded = `${digits.slice(0, decimalIndex)}.${digits.slice(decimalIndex)}`;
+    }
+    return expanded;
+}
 const calculateRawAmount = (amount, decimals) => {
-    const [integerPart, fractionalPart = ''] = amount.toString().split('.');
-    // Ensure the fractional part has enough digits
-    const paddedFraction = fractionalPart.padEnd(decimals, '0').slice(0, decimals);
-    return BigInt(integerPart + paddedFraction);
+    if (!Number.isFinite(amount)) {
+        throw (0, errors_1.invalidAmountError)('Amount must be finite');
+    }
+    if (amount < 0) {
+        throw (0, errors_1.invalidAmountError)('Amount must be non-negative');
+    }
+    if (!Number.isInteger(decimals) || decimals < 0) {
+        throw (0, errors_1.invalidAmountError)('Token decimals must be a non-negative integer');
+    }
+    const amountString = formatFiniteNumber(amount);
+    const [integerPart, fractionalPart = ''] = amountString.split('.');
+    if (fractionalPart.length > decimals) {
+        throw (0, errors_1.invalidAmountError)('Amount has more fractional digits than token decimals');
+    }
+    return BigInt(integerPart + fractionalPart.padEnd(decimals, '0'));
 };
 exports.calculateRawAmount = calculateRawAmount;
 const calculateAmount = (rawAmount, decimals) => {

package/dist/src/structs/InternalStruct.d.ts

@@ -1,7 +1,7 @@
 import type { Address, Cell, Message } from '@ton/ton';
 import { AbstractProvider, ethers } from 'ethers';
 import { ICrossChainLayer, ISAFactory, ISettings, ITokenUtils } from '../../artifacts/tacTypes';
-import { ContractOpener } from '../interfaces';
+import { ContractOpener, IToncenterV3Indexer } from '../interfaces';
 import { CurrencyType, ExecutionStagesByOperationId, ExecutionStagesV2ByOperationId, Network, OperationIdsByShardsKey, OperationIdWithLogIndex, OperationType, OperationTypeV2Info, StatusInfosByOperationId, SuggestedTVMExecutorFee, TACSimulationResult, ToncenterV3IndexedTransaction, TransactionLinker } from './Struct';
 export type ShardMessage = {
     address: string;
@@ -37,6 +37,7 @@ export type RandomNumberByTimestamp = {
 };
 export type InternalTONParams = {
     contractOpener: ContractOpener;
+    tonIndexer?: IToncenterV3Indexer;
     jettonProxyAddress: string;
     nftProxyAddress: string;
     crossChainLayerAddress: string;

package/dist/src/structs/Struct.d.ts

@@ -468,7 +468,7 @@ export type CrossChainTransactionOptions = {
      * Retry policy used while resolving the operation ID.
      * Use this to control timeout, attempts, delay, logger, callbacks, and success criteria.
      */
-    waitOptions?: WaitOptions<string>;
+    waitOperationIdOptions?: WaitOptions<string>;
     /**
      * If true, waits for full cross-chain finalization after the operation ID is known:
      * the SDK waits for a final operation type, fetches stage profiling, and validates
@@ -489,10 +489,10 @@ export type CrossChainTransactionOptions = {
      */
     evmDataBuilder?: evmDataBuilder;
 };
-export type BatchCrossChainTransactionOptions = Omit<CrossChainTransactionOptions, 'waitOperationId' | 'waitOptions' | 'ensureTxExecuted' | 'waitFinalization' | 'finalizationWaitOptions'>;
+export type BatchCrossChainTransactionOptions = Omit<CrossChainTransactionOptions, 'waitOperationId' | 'waitOperationIdOptions' | 'ensureTxExecuted' | 'waitFinalization' | 'finalizationWaitOptions'>;
 export type CrossChainTransactionsOptions = {
     waitOperationIds?: boolean;
-    waitOptions?: WaitOptions<OperationIdsByShardsKey>;
+    waitOperationIdOptions?: WaitOptions<OperationIdsByShardsKey>;
 };
 export type CrossChainTransactionToTONOptions = {
     /**
@@ -522,7 +522,7 @@ export type CrossChainTransactionToTONOptions = {
      * Retry policy used while resolving the operation ID.
      * Use this to control timeout, attempts, delay, logger, callbacks, and success criteria.
      */
-    waitOptions?: WaitOptions<string>;
+    waitOperationIdOptions?: WaitOptions<string>;
     /**
      * Wait options used to finalize the cross-chain operation after operationId resolution.
      * Use this to configure retries, delay, logger, successCheck, and onSuccess callback

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@tonappchain/sdk",
-    "version": "0.7.3-rc7",
+    "version": "0.8.0",
     "repository": "https://github.com/TacBuild/tac-sdk.git",
     "author": "TAC. <developers@tac>",
     "license": "MIT",