@tonappchain/sdk 0.7.3-rc1 → 0.7.3-rc2

package/dist/src/interfaces/ITacSDK.d.ts

@@ -2,7 +2,7 @@ import { Wallet } from 'ethers';
 import { JettonMinterData, NFTItemData } from '../../artifacts/tonTypes';
 import { FT, NFT, TAC, TON } from '../assets';
 import type { SenderAbstraction } from '../sender';
-import { AssetFromFTArg, AssetFromNFTCollectionArg, AssetFromNFTItemArg, AssetLike, BatchCrossChainTxWithAssetLike, BridgeTokensToTONOptions, CrossChainPayloadResult, CrossChainTransactionOptions, CrossChainTransactionsOptions, CrosschainTx, EVMAddress, EvmProxyMsg, ExecutionFeeEstimationResult, NFTAddressType, SuggestedTVMExecutorFee, TACCrossChainTransactionResult, TacGasPrice, TACSimulationParams, TACSimulationResult, TransactionLinkerWithOperationId, TVMAddress, UserWalletBalanceExtended } from '../structs/Struct';
+import { AssetFromFTArg, AssetFromNFTCollectionArg, AssetFromNFTItemArg, AssetLike, BatchCrossChainTxWithAssetLike, CrossChainPayloadResult, CrossChainTransactionOptions, CrossChainTransactionsOptions, CrossChainTransactionToTONOptions, CrosschainTx, EVMAddress, EvmProxyMsg, ExecutionFeeEstimationResult, NFTAddressType, SuggestedTVMExecutorFee, TACCrossChainTransactionResult, TacGasPrice, TACSimulationParams, TACSimulationResult, TransactionLinkerWithOperationId, TVMAddress, UserWalletBalanceExtended, WaitOptions } from '../structs/Struct';
 import { Asset } from './Asset';
 import { ContractOpener } from './ContractOpener';
 import { IConfiguration } from './IConfiguration';
@@ -29,8 +29,8 @@ export interface ITacSDK {
      */
     get getTrustedTONExecutors(): string[];
     /**
-     * Closes any underlying network connections, clients, or subscriptions established by the SDK.
-     * Implementations should be idempotent and safe to call multiple times.
+     * Closes TON liteclient connections.
+     * Use only with LiteClientOpener.
      */
     closeConnections(): unknown;
     /**
@@ -106,14 +106,15 @@ export interface ITacSDK {
      * the bridged native TAC amount. The SDK requires EIP-1559 fee data from the TAC provider, can
      * validate balances / ownership of non-native TAC assets, uses provider gas estimates as-is,
      * validates those estimates against the latest TAC block gas limit,
-     * computes the worst-case upfront TAC balance requirement, and only then submits the TAC transactions.
+     * first estimates approval gas and checks TAC balance for approvals, submits approvals,
+     * then estimates the bridge message and checks the remaining TAC balance before sending it.
      * @param signer Ethers Wallet used to sign EVM transaction on TAC side.
      * @param tonTarget Recipient TVM address on TON.
      * @param assets Optional list of TAC assets to include in the bridge transaction.
      * @param options Optional TAC -> TON bridge configuration.
      * @returns Promise with TAC transaction hash and optional operationId.
      */
-    sendCrossChainTransactionToTON(signer: Wallet, tonTarget: string, assets?: AssetLike[], options?: BridgeTokensToTONOptions): Promise<TACCrossChainTransactionResult>;
+    sendCrossChainTransactionToTON(signer: Wallet, tonTarget: string, assets?: AssetLike[], options?: CrossChainTransactionToTONOptions): Promise<TACCrossChainTransactionResult>;
     /**
      * Sends multiple cross-chain transactions in one batch and optionally waits for tracking info.
      * @param sender Sender abstraction for signing/sending TVM messages.
@@ -122,6 +123,26 @@ export interface ITacSDK {
      * @returns Promise with an array of TransactionLinkerWithOperationId for each submitted transaction.
      */
     sendCrossChainTransactions(sender: SenderAbstraction, txs: BatchCrossChainTxWithAssetLike[], options?: CrossChainTransactionsOptions): Promise<TransactionLinkerWithOperationId[]>;
+    /**
+     * Resolves operation id by any TON hash from a linked chain of TON transactions.
+     * The SDK first resolves indexed TON transaction context, traverses adjacent TON transactions
+     * until it finds the crossChainLayer transaction that the sequencer would collect as a TVM event,
+     * and only then queries the sequencer with that exact transaction hash.
+     * @param transactionHash Any TON transaction hash from the relevant linked chain of TON transactions.
+     * @param waitOptions Optional waiting settings for the final sequencer lookup. Pass `null` to disable retries.
+     * @returns Promise resolving to operation id, or empty string when the sequencer-collected crossChainLayer event transaction is not found.
+     */
+    getOperationIdByTonTransactionHash(transactionHash: string, waitOptions?: WaitOptions<string> | null): Promise<string>;
+    /**
+     * Resolves operation id by the BOC of an external TON message that was sent to the blockchain.
+     * The SDK derives the normalized external-in message hash from the BOC, finds the root TON transaction
+     * that processed that external message through the configured contract opener, and then reuses the same
+     * linked chain of TON transactions lookup as `getOperationIdByTonTransactionHash(...)`.
+     * @param boc BOC of the external TON message that was sent to the blockchain.
+     * @param waitOptions Optional waiting settings for the final sequencer lookup. Pass `null` to disable retries.
+     * @returns Promise resolving to operation id, or empty string when the sequencer-collected crossChainLayer event transaction is not found.
+     */
+    getOperationIdByTonTransactionBoc(boc: string, waitOptions?: WaitOptions<string> | null): Promise<string>;
     /**
      * Bridges tokens/value from EVM to TON chain via the executor.
      * This is a low-level send-only method. It prepares the TAC -> TON message, performs approvals,

package/dist/src/interfaces/IToncenterV3Indexer.d.ts

@@ -0,0 +1,35 @@
+import { ToncenterV3IndexedTransaction, ToncenterV3TraversalParams } from '../structs/Struct';
+/**
+ * Contract for indexed TON transaction lookup by hash.
+ * Used when the SDK must resolve any TON transaction hash from a linked chain of TON transactions
+ * into indexed transaction context and then find the sequencer-collected event transaction on crossChainLayer.
+ */
+export interface IToncenterV3Indexer {
+    /** Indexed Toncenter v3 endpoint used by this client. */
+    readonly endpoint: string;
+    /**
+     * Resolves TON transaction context by hash using an indexed backend.
+     * Accepts any TON transaction hash format supported by the indexer, including hashes from
+     * any point in the same linked chain of TON transactions.
+     * @param transactionHash TON transaction hash to resolve in the indexed backend.
+     * @returns Indexed transaction with owning account context, or null if not found.
+     */
+    getTransactionByHash(transactionHash: string): Promise<ToncenterV3IndexedTransaction | null>;
+    /**
+     * Resolves adjacent indexed transactions for the provided hash from the same linked chain of TON transactions.
+     * The result may contain both parent and child transactions.
+     * @param transactionHash TON transaction hash to resolve around.
+     * @returns Adjacent indexed transactions, or an empty array when none were found.
+     */
+    getAdjacentTransactions(transactionHash: string): Promise<ToncenterV3IndexedTransaction[]>;
+    /**
+     * Traverses the linked chain of TON transactions in both directions starting from any TON transaction hash
+     * from that linked transaction chain, and returns the transaction on crossChainLayer that the sequencer would collect
+     * as a TVM event.
+     * @param transactionHash Any TON transaction hash from the target linked chain of TON transactions.
+     * @param crossChainLayerAddress crossChainLayer address whose sequencer-collected event transaction should be found in that linked chain of TON transactions.
+     * @param params Optional traversal settings. Defaults are applied when omitted.
+     * @returns Indexed crossChainLayer transaction that matches the sequencer event collector rules, or null if it was not found.
+     */
+    findCollectibleCrossChainLayerTransaction(transactionHash: string, crossChainLayerAddress: string, params?: ToncenterV3TraversalParams): Promise<ToncenterV3IndexedTransaction | null>;
+}

package/dist/src/interfaces/IToncenterV3Indexer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/interfaces/index.d.ts

@@ -10,6 +10,7 @@ export * from './ISimulator';
 export * from './ITacExplorerClient';
 export * from './ITacSDK';
 export * from './ITACTransactionManager';
+export * from './IToncenterV3Indexer';
 export * from './ITONTransactionManager';
 export * from './SenderAbstraction';
 export * from './WalletInstanse';

package/dist/src/interfaces/index.js

@@ -26,6 +26,7 @@ __exportStar(require("./ISimulator"), exports);
 __exportStar(require("./ITacExplorerClient"), exports);
 __exportStar(require("./ITacSDK"), exports);
 __exportStar(require("./ITACTransactionManager"), exports);
+__exportStar(require("./IToncenterV3Indexer"), exports);
 __exportStar(require("./ITONTransactionManager"), exports);
 __exportStar(require("./SenderAbstraction"), exports);
 __exportStar(require("./WalletInstanse"), exports);

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

@@ -19,6 +19,8 @@ export declare const TON_BURN_ADDRESS = "EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
 export declare const DEFAULT_HTTP_CLIENT_TIMEOUT_MS = 30000;
 export declare const DEFAULT_RETRY_MAX_COUNT = 5;
 export declare const DEFAULT_RETRY_DELAY_MS = 1000;
+export declare const DEFAULT_RETRY_MAX_DELAY_MS = 30000;
+export declare const DEFAULT_RETRY_BACKOFF_MULTIPLIER = 3;
 export declare const DEFAULT_WAIT_TIMEOUT_MS = 300000;
 export declare const DEFAULT_WAIT_MAX_ATTEMPTS = 30;
 export declare const DEFAULT_WAIT_DELAY_MS = 10000;

package/dist/src/sdk/Consts.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IGNORE_OPCODE = exports.SHARDS_KEY_RANDOM_RANGE = exports.DEFAULT_EIP1559_PRIORITY_FEE = exports.NFT_BRIDGE_AMOUNT = exports.CROSS_CHAIN_MESSAGE_VERSION_V1 = exports.IGNORE_MSG_VALUE_1_NANO = exports.DEFAULT_RETRY_ON_NOT_FOUND_DELAY_MS = exports.DEFAULT_RETRY_ON_NOT_FOUND_RETRIES = exports.DEFAULT_RETRY_ON_NOT_FOUND = exports.DEFAULT_FIND_TX_MAX_DEPTH = exports.DEFAULT_FIND_TX_ARCHIVAL = exports.DEFAULT_MAX_SCANNED_TRANSACTIONS = exports.DEFAULT_FIND_TX_LIMIT = exports.DEFAULT_WAIT_DELAY_MS = exports.DEFAULT_WAIT_MAX_ATTEMPTS = exports.DEFAULT_WAIT_TIMEOUT_MS = exports.DEFAULT_RETRY_DELAY_MS = exports.DEFAULT_RETRY_MAX_COUNT = exports.DEFAULT_HTTP_CLIENT_TIMEOUT_MS = exports.TON_BURN_ADDRESS = exports.MINUTE = exports.FIVE_MINUTES = exports.TAC_DECIMALS = exports.TON_DECIMALS = exports.ONE_YEAR_SECONDS = exports.FIFTEEN_MINUTES = 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 = void 0;
+exports.IGNORE_OPCODE = exports.SHARDS_KEY_RANDOM_RANGE = exports.DEFAULT_EIP1559_PRIORITY_FEE = exports.NFT_BRIDGE_AMOUNT = exports.CROSS_CHAIN_MESSAGE_VERSION_V1 = exports.IGNORE_MSG_VALUE_1_NANO = exports.DEFAULT_RETRY_ON_NOT_FOUND_DELAY_MS = exports.DEFAULT_RETRY_ON_NOT_FOUND_RETRIES = exports.DEFAULT_RETRY_ON_NOT_FOUND = exports.DEFAULT_FIND_TX_MAX_DEPTH = exports.DEFAULT_FIND_TX_ARCHIVAL = exports.DEFAULT_MAX_SCANNED_TRANSACTIONS = exports.DEFAULT_FIND_TX_LIMIT = exports.DEFAULT_WAIT_DELAY_MS = exports.DEFAULT_WAIT_MAX_ATTEMPTS = exports.DEFAULT_WAIT_TIMEOUT_MS = exports.DEFAULT_RETRY_BACKOFF_MULTIPLIER = exports.DEFAULT_RETRY_MAX_DELAY_MS = exports.DEFAULT_RETRY_DELAY_MS = exports.DEFAULT_RETRY_MAX_COUNT = exports.DEFAULT_HTTP_CLIENT_TIMEOUT_MS = exports.TON_BURN_ADDRESS = exports.MINUTE = exports.FIVE_MINUTES = exports.TAC_DECIMALS = exports.TON_DECIMALS = exports.ONE_YEAR_SECONDS = exports.FIFTEEN_MINUTES = 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 = void 0;
 const ton_1 = require("@ton/ton");
 exports.JETTON_TRANSFER_FORWARD_TON_AMOUNT = (0, ton_1.toNano)(0.2);
 exports.NFT_TRANSFER_FORWARD_TON_AMOUNT = (0, ton_1.toNano)(0.3);
@@ -23,6 +23,8 @@ exports.TON_BURN_ADDRESS = 'EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c';
 exports.DEFAULT_HTTP_CLIENT_TIMEOUT_MS = 30000;
 exports.DEFAULT_RETRY_MAX_COUNT = 5;
 exports.DEFAULT_RETRY_DELAY_MS = 1000;
+exports.DEFAULT_RETRY_MAX_DELAY_MS = 30000;
+exports.DEFAULT_RETRY_BACKOFF_MULTIPLIER = 3;
 exports.DEFAULT_WAIT_TIMEOUT_MS = 300000; // 5 minutes
 exports.DEFAULT_WAIT_MAX_ATTEMPTS = 30;
 exports.DEFAULT_WAIT_DELAY_MS = 10000; // 10 seconds

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

@@ -1,12 +1,13 @@
 import { IHttpClient, ILiteSequencerClient } from '../interfaces';
 import { ConvertCurrencyParams, ConvertedCurrencyResult, ExecutionStagesByOperationId, ExecutionStagesV2ByOperationId, GetTVMExecutorFeeParams, OperationIdsByShardsKey, OperationType, OperationTypeV2Info, StatusInfosByOperationId, SuggestedTVMExecutorFee, TACSimulationParams, TACSimulationResult, TransactionLinker } from '../structs/Struct';
 export declare class LiteSequencerClient implements ILiteSequencerClient {
-    private readonly endpoint;
+    readonly endpoint: string;
     private readonly maxChunkSize;
     private readonly httpClient;
     constructor(endpoint: string, maxChunkSize?: number, httpClient?: IHttpClient);
     private getRequestLabel;
     getOperationIdByTransactionHash(transactionHash: string): Promise<string>;
+    getOperationIdByTonTransactionHash(transactionHash: string): Promise<string>;
     getOperationType(operationId: string): Promise<OperationType>;
     getOperationTypeV2(operationId: string): Promise<OperationTypeV2Info>;
     getOperationId(transactionLinker: TransactionLinker): Promise<string>;

package/dist/src/sdk/LiteSequencerClient.js

@@ -23,7 +23,11 @@ class LiteSequencerClient {
                 const response = await this.httpClient.get(new URL(path, this.endpoint).toString(), {
                     params: { transactionHash },
                 });
-                return response.data.response?.operationId || '';
+                const operationResponse = response.data.response;
+                if (operationResponse.length > 0) {
+                    return operationResponse[0].operationId;
+                }
+                return '';
             }
             else {
                 const response = await this.httpClient.get(new URL(path, this.endpoint).toString(), {
@@ -40,6 +44,23 @@ class LiteSequencerClient {
             throw (0, errors_1.operationFetchError)(`request ${requestLabel} failed to complete request`, error);
         }
     }
+    async getOperationIdByTonTransactionHash(transactionHash) {
+        const path = 'ton/operation-id';
+        const requestLabel = this.getRequestLabel('GET', path);
+        try {
+            const response = await this.httpClient.get(new URL(path, this.endpoint).toString(), {
+                params: { transactionHash },
+            });
+            return response.data.response || '';
+        }
+        catch (error) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            if (error?.response?.status === 404) {
+                return '';
+            }
+            throw (0, errors_1.operationFetchError)(`request ${requestLabel} failed to complete request`, error);
+        }
+    }
     async getOperationType(operationId) {
         const path = 'operation-type';
         const requestLabel = this.getRequestLabel('GET', path);

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

@@ -8,6 +8,7 @@ export declare class OperationTracker implements IOperationTracker {
     private readonly logger;
     constructor(network: Network, customLiteSequencerEndpoints?: string[], logger?: ILogger, clientFactory?: ILiteSequencerClientFactory);
     getOperationIdByTransactionHash(transactionHash: string, waitOptions?: WaitOptions<string> | null): Promise<string>;
+    getOperationIdByTonTransactionHash(transactionHash: string, waitOptions?: WaitOptions<string> | null): Promise<string>;
     getOperationType(operationId: string, waitOptions?: WaitOptions<OperationType> | null): Promise<OperationType>;
     getOperationTypeV2(operationId: string, waitOptions?: WaitOptions<OperationTypeV2Info> | null): Promise<OperationTypeV2Info>;
     getOperationId(transactionLinker: TransactionLinker, waitOptions?: WaitOptions<string> | null): Promise<string>;

package/dist/src/sdk/OperationTracker.js

@@ -52,6 +52,24 @@ class OperationTracker {
             ? await requestFn()
             : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, `OperationTracker: Getting operation ID by transaction hash ${(0, Utils_1.formatObjectForLogging)(transactionHash)}`);
     }
+    async getOperationIdByTonTransactionHash(transactionHash, waitOptions) {
+        const requestFn = async () => {
+            let lastError;
+            for (const client of this.clients) {
+                try {
+                    const id = await client.getOperationIdByTonTransactionHash(transactionHash);
+                    return id;
+                }
+                catch (error) {
+                    lastError = error;
+                }
+            }
+            throw (0, errors_1.allEndpointsFailedError)(lastError, waitOptions?.includeErrorTrace ?? false);
+        };
+        return waitOptions === null
+            ? await requestFn()
+            : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, `OperationTracker: Getting operation ID by TON transaction hash ${(0, Utils_1.formatObjectForLogging)(transactionHash)}`);
+    }
     async getOperationType(operationId, waitOptions) {
         const requestFn = async () => {
             let lastError;

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

@@ -1,6 +1,6 @@
 import { Wallet } from 'ethers';
 import { Asset, IConfiguration, ILogger, IOperationTracker, ITACTransactionManager } from '../interfaces';
-import { BridgeTokensToTONOptions, TACCrossChainTransactionResult } from '../structs/Struct';
+import { CrossChainTransactionToTONOptions, TACCrossChainTransactionResult } from '../structs/Struct';
 export declare class TACTransactionManager implements ITACTransactionManager {
     private readonly config;
     private readonly operationTracker;
@@ -8,6 +8,7 @@ export declare class TACTransactionManager implements ITACTransactionManager {
     constructor(config: IConfiguration, operationTracker: IOperationTracker, logger?: ILogger);
     private prepareBridgeTokensToTON;
     private approveAsset;
-    sendCrossChainTransactionToTON(signer: Wallet, tonTarget: string, assets?: Asset[], options?: BridgeTokensToTONOptions): Promise<TACCrossChainTransactionResult>;
+    private estimateApprovalGas;
+    sendCrossChainTransactionToTON(signer: Wallet, tonTarget: string, assets?: Asset[], options?: CrossChainTransactionToTONOptions): Promise<TACCrossChainTransactionResult>;
     bridgeTokensToTON(signer: Wallet, value: bigint, tonTarget: string, assets?: Asset[], tvmExecutorFee?: bigint, tvmValidExecutors?: string[]): Promise<string>;
 }

package/dist/src/sdk/TACTransactionManager.js

@@ -36,7 +36,6 @@ class TACTransactionManager {
             this.logger.debug(`Suggested TON executor fee: ${(0, Utils_1.formatObjectForLogging)(suggestedFee)}`);
             tvmExecutorFee = BigInt(suggestedFee.inTAC);
         }
-        const crossChainLayerAddress = await this.config.TACParams.crossChainLayer.getAddress();
         const protocolFee = await this.config.TACParams.crossChainLayer.getProtocolFee();
         const shardsKey = BigInt(Math.round(Math.random() * Consts_1.SHARDS_KEY_RANDOM_RANGE));
         this.logger.debug(`Shards key: ${shardsKey}, Protocol fee: ${protocolFee}`);
@@ -66,29 +65,44 @@ class TACTransactionManager {
             toBridgeNFT,
         };
         return {
-            crossChainLayerAddress,
             outMessagePayload: this.config.artifacts.tac.utils.encodeOutMessageV1(outMessage),
             totalValue: value + BigInt(outMessage.tvmProtocolFee) + BigInt(outMessage.tvmExecutorFee),
         };
     }
     async approveAsset(asset, signer, spenderAddress, transactionParams = {}) {
         const evmAddress = await asset.getEVMAddress();
+        const hasTransactionParams = Object.keys(transactionParams).length > 0;
         if (asset.type === Struct_1.AssetType.FT) {
             this.logger.debug(`Approving FT ${evmAddress} for ${spenderAddress}`);
             const contract = new ethers_1.ethers.Contract(evmAddress, this.config.artifacts.tac.compilationArtifacts.IERC20WithDecimals.abi, this.config.TACParams.provider);
-            const tx = await contract.connect(signer).approve(spenderAddress, asset.rawAmount, transactionParams);
+            const tx = hasTransactionParams
+                ? await contract.connect(signer).approve(spenderAddress, asset.rawAmount, transactionParams)
+                : await contract.connect(signer).approve(spenderAddress, asset.rawAmount);
             await tx.wait();
         }
         else {
             this.logger.debug(`Approving NFT ${evmAddress} for ${spenderAddress}`);
             const contract = new ethers_1.ethers.Contract(evmAddress, this.config.artifacts.tac.compilationArtifacts.IERC721.abi, this.config.TACParams.provider);
-            const tx = await contract
-                .connect(signer)
-                .approve(spenderAddress, asset.addresses.index, transactionParams);
+            const tx = hasTransactionParams
+                ? await contract
+                    .connect(signer)
+                    .approve(spenderAddress, asset.addresses.index, transactionParams)
+                : await contract.connect(signer).approve(spenderAddress, asset.addresses.index);
             await tx.wait();
         }
         this.logger.debug(`Approved ${evmAddress} for ${spenderAddress}`);
     }
+    async estimateApprovalGas(asset, signer, spenderAddress, transactionParams = {}) {
+        const evmAddress = await asset.getEVMAddress();
+        if (asset.type === Struct_1.AssetType.FT) {
+            const contract = new ethers_1.ethers.Contract(evmAddress, this.config.artifacts.tac.compilationArtifacts.IERC20WithDecimals.abi, this.config.TACParams.provider);
+            return contract.connect(signer).approve.estimateGas(spenderAddress, asset.rawAmount, transactionParams);
+        }
+        const contract = new ethers_1.ethers.Contract(evmAddress, this.config.artifacts.tac.compilationArtifacts.IERC721.abi, this.config.TACParams.provider);
+        return contract
+            .connect(signer)
+            .approve.estimateGas(spenderAddress, asset.addresses.index, transactionParams);
+    }
     async sendCrossChainTransactionToTON(signer, tonTarget, assets = [], options) {
         const signerAddress = signer.address;
         const nativeTACAsset = await assets_1.AssetFactory.from(this.config, {
@@ -98,21 +112,22 @@ class TACTransactionManager {
         let value = 0n;
         const bridgeAssets = [];
         for (const asset of assets) {
-            if (asset.origin === Struct_1.Origin.TAC && asset.type === Struct_1.AssetType.FT && asset.address === nativeTACAsset.address) {
+            if (asset.origin === Struct_1.Origin.TAC &&
+                asset.type === Struct_1.AssetType.FT &&
+                asset.address === nativeTACAsset.address) {
                 value += asset.rawAmount;
                 continue;
             }
             bridgeAssets.push(asset);
         }
+        const crossChainLayerAddress = await this.config.TACParams.crossChainLayer.getAddress();
         const preparedBridge = await this.prepareBridgeTokensToTON(value, tonTarget, bridgeAssets, options?.tvmExecutorFee, options?.tvmValidExecutors);
         const feeData = await this.config.TACParams.provider.getFeeData();
         const maxFeePerGas = feeData.maxFeePerGas;
         if (maxFeePerGas === null) {
             throw (0, errors_1.gasPriceFetchError)('TAC provider did not return maxFeePerGas');
         }
-        const latestBlock = await this.config.TACParams.provider
-            .getBlock('latest')
-            .catch((error) => {
+        const latestBlock = await this.config.TACParams.provider.getBlock('latest').catch((error) => {
             throw (0, errors_1.blockGasLimitFetchError)('provider failed to return latest block', error);
         });
         const blockGasLimit = latestBlock?.gasLimit;
@@ -127,28 +142,26 @@ class TACTransactionManager {
         if (shouldValidateAssetsBalance) {
             await Promise.all(bridgeAssets.map((asset) => asset.checkCanBeTransferredBy(signerAddress, Struct_1.BlockchainType.TAC)));
         }
-        let requiredBalance = preparedBridge.totalValue;
+        let requiredApprovalBalance = 0n;
         const approvalPlans = [];
         for (const asset of bridgeAssets) {
-            let estimatedGas;
-            if (asset.type === Struct_1.AssetType.FT) {
-                const contract = new ethers_1.ethers.Contract(await asset.getEVMAddress(), this.config.artifacts.tac.compilationArtifacts.IERC20WithDecimals.abi, this.config.TACParams.provider);
-                estimatedGas = await contract
-                    .connect(signer)
-                    .approve.estimateGas(preparedBridge.crossChainLayerAddress, asset.rawAmount, transactionParams);
-            }
-            else {
-                const contract = new ethers_1.ethers.Contract(await asset.getEVMAddress(), this.config.artifacts.tac.compilationArtifacts.IERC721.abi, this.config.TACParams.provider);
-                estimatedGas = await contract
-                    .connect(signer)
-                    .approve.estimateGas(preparedBridge.crossChainLayerAddress, asset.addresses.index, transactionParams);
-            }
+            const estimatedGas = await this.estimateApprovalGas(asset, signer, crossChainLayerAddress, transactionParams);
             if (estimatedGas > blockGasLimit) {
                 throw (0, errors_1.estimatedGasExceedsBlockGasLimitError)('approve', estimatedGas, blockGasLimit);
             }
-            requiredBalance += estimatedGas * maxFeePerGas;
+            requiredApprovalBalance += estimatedGas * maxFeePerGas;
             approvalPlans.push({ asset, gasLimit: estimatedGas });
         }
+        const approvalBalance = await this.config.TACParams.provider.getBalance(signer.address);
+        if (approvalBalance < requiredApprovalBalance) {
+            throw (0, errors_1.insufficientBalanceError)(Consts_1.TAC_SYMBOL);
+        }
+        for (const approval of approvalPlans) {
+            await this.approveAsset(approval.asset, signer, crossChainLayerAddress, {
+                ...transactionParams,
+                gasLimit: approval.gasLimit,
+            });
+        }
         const sendMessageGas = await this.config.TACParams.crossChainLayer
             .connect(signer)
             .sendMessage.estimateGas(Consts_1.CROSS_CHAIN_MESSAGE_VERSION_V1, preparedBridge.outMessagePayload, {
@@ -158,17 +171,11 @@ class TACTransactionManager {
         if (sendMessageGas > blockGasLimit) {
             throw (0, errors_1.estimatedGasExceedsBlockGasLimitError)('sendMessage', sendMessageGas, blockGasLimit);
         }
-        requiredBalance += sendMessageGas * maxFeePerGas;
-        const balance = await this.config.TACParams.provider.getBalance(signer.address);
-        if (balance < requiredBalance) {
+        const requiredSendMessageBalance = preparedBridge.totalValue + sendMessageGas * maxFeePerGas;
+        const sendMessageBalance = await this.config.TACParams.provider.getBalance(signer.address);
+        if (sendMessageBalance < requiredSendMessageBalance) {
             throw (0, errors_1.insufficientBalanceError)(Consts_1.TAC_SYMBOL);
         }
-        for (const approval of approvalPlans) {
-            await this.approveAsset(approval.asset, signer, preparedBridge.crossChainLayerAddress, {
-                ...transactionParams,
-                gasLimit: approval.gasLimit,
-            });
-        }
         const tx = await this.config.TACParams.crossChainLayer
             .connect(signer)
             .sendMessage(Consts_1.CROSS_CHAIN_MESSAGE_VERSION_V1, preparedBridge.outMessagePayload, {
@@ -219,7 +226,10 @@ class TACTransactionManager {
     }
     async bridgeTokensToTON(signer, value, tonTarget, assets = [], tvmExecutorFee, tvmValidExecutors) {
         this.logger.debug('Bridging tokens to TON');
-        const { crossChainLayerAddress, outMessagePayload, totalValue } = await this.prepareBridgeTokensToTON(value, tonTarget, assets, tvmExecutorFee, tvmValidExecutors);
+        Validator_1.Validator.validateTVMAddress(tonTarget);
+        Validator_1.Validator.validateTVMAddresses(tvmValidExecutors);
+        const crossChainLayerAddress = await this.config.TACParams.crossChainLayer.getAddress();
+        const { outMessagePayload, totalValue } = await this.prepareBridgeTokensToTON(value, tonTarget, assets, tvmExecutorFee, tvmValidExecutors);
         this.logger.debug(`Total value: ${totalValue}`);
         for (const asset of assets) {
             await this.approveAsset(asset, signer, crossChainLayerAddress);

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, BridgeTokensToTONOptions, CrossChainPayloadResult, CrossChainTransactionOptions, CrossChainTransactionsOptions, CrosschainTx, EVMAddress, EvmProxyMsg, ExecutionFeeEstimationResult, NFTAddressType, SDKParams, SuggestedTVMExecutorFee, TACCrossChainTransactionResult, TacGasPrice, TACSimulationParams, TACSimulationResult, TransactionLinkerWithOperationId, TVMAddress, UserWalletBalanceExtended } 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, WaitOptions } from '../structs/Struct';
 export declare class TacSdk implements ITacSDK {
     readonly config: IConfiguration;
     readonly contactOpener: ContractOpener;
@@ -12,6 +12,7 @@ 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;
@@ -23,8 +24,10 @@ export declare class TacSdk implements ITacSDK {
     getSimulationInfo(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: AssetLike[], options?: CrossChainTransactionOptions): Promise<ExecutionFeeEstimationResult>;
     getTVMExecutorFeeInfo(assets: AssetLike[], feeSymbol: string, tvmValidExecutors?: string[]): Promise<SuggestedTVMExecutorFee>;
     sendCrossChainTransaction(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: AssetLike[], options?: CrossChainTransactionOptions): Promise<TransactionLinkerWithOperationId>;
-    sendCrossChainTransactionToTON(signer: Wallet, tonTarget: string, assets?: AssetLike[], options?: BridgeTokensToTONOptions): Promise<TACCrossChainTransactionResult>;
+    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>;
@@ -48,4 +51,5 @@ 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,8 +1,11 @@
 "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 Configuration_1 = require("./Configuration");
 const Consts_1 = require("./Consts");
@@ -14,7 +17,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) {
+    constructor(config, simulator, tonTransactionManager, tacTransactionManager, operationTracker, explorerClient, tonIndexer) {
         this.config = config;
         this.contactOpener = config.TONParams.contractOpener;
         this.simulator = simulator;
@@ -22,6 +25,7 @@ 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;
@@ -47,7 +51,8 @@ class TacSdk {
         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);
-        return new TacSdk(config, simulator, tonTransactionManager, tacTransactionManager, operationTracker, explorerClient);
+        const tonIndexer = sdkParams.TONParams?.tonIndexer ?? new adapters_1.ToncenterV3Indexer(artifacts.TONCENTER_V3_INDEXER_ENDPOINT);
+        return new TacSdk(config, simulator, tonTransactionManager, tacTransactionManager, operationTracker, explorerClient, tonIndexer);
     }
     closeConnections() {
         return this.config.closeConnections();
@@ -99,6 +104,32 @@ 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);
@@ -204,5 +235,8 @@ class TacSdk {
     getTonContractOpener() {
         return this.contactOpener;
     }
+    toSequencerTonTransactionHash(transaction) {
+        return `0x${(0, Utils_1.normalizeHashToHex)(transaction.hash)}`;
+    }
 }
 exports.TacSdk = TacSdk;

package/dist/src/sdk/Utils.js

@@ -416,7 +416,7 @@ function decodeBase64Like(input) {
 }
 function getNormalizedExtMessageHash(message) {
     if (message.info.type !== 'external-in') {
-        throw new Error(`Message must be "external-in", got ${message.info.type}`);
+        throw (0, errors_1.externalInMessageRequiredError)(message.info.type);
     }
     const info = {
         ...message.info,
@@ -460,5 +460,5 @@ function recurisivelyCollectCellStats(cell) {
     return { bits, cells };
 }
 function isFinalProfiling(profilingData) {
-    return profilingData.operationType !== Struct_1.OperationType.PENDING && profilingData.operationType !== Struct_1.OperationType.UNKNOWN;
+    return (profilingData.operationType !== Struct_1.OperationType.PENDING && profilingData.operationType !== Struct_1.OperationType.UNKNOWN);
 }

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

@@ -2,7 +2,7 @@ import { Address, Cell } from '@ton/ton';
 import { AbstractProvider, ethers } from 'ethers';
 import { ICrossChainLayer, ISAFactory, ISettings, ITokenUtils } from '../../artifacts/tacTypes';
 import { ContractOpener } from '../interfaces';
-import { CurrencyType, ExecutionStagesByOperationId, ExecutionStagesV2ByOperationId, Network, OperationIdsByShardsKey, OperationType, OperationTypeV2Info, StatusInfosByOperationId, SuggestedTVMExecutorFee, TACSimulationResult, TransactionLinker } from './Struct';
+import { CurrencyType, ExecutionStagesByOperationId, ExecutionStagesV2ByOperationId, Network, OperationIdsByShardsKey, OperationType, OperationTypeV2Info, StatusInfosByOperationId, SuggestedTVMExecutorFee, TACSimulationResult, ToncenterV3IndexedTransaction, TransactionLinker } from './Struct';
 export type ShardMessage = {
     address: string;
     value: bigint;
@@ -22,7 +22,6 @@ export type PreparedCrossChainTransaction = {
     transactionLinker: TransactionLinker;
 };
 export type PreparedBridgeTokensToTON = {
-    crossChainLayerAddress: string;
     outMessagePayload: ethers.BytesLike;
     totalValue: bigint;
 };
@@ -75,7 +74,7 @@ export type OperationIdWithLogIndex = {
     operationId: string;
     logIndex: number;
 };
-export type OperationIdWithLogIndexResponse = ResponseBase<OperationIdWithLogIndex>;
+export type OperationIdWithLogIndexResponse = ResponseBase<OperationIdWithLogIndex[]>;
 export interface SendResult {
     success: boolean;
     boc: string;
@@ -138,6 +137,12 @@ export type TransactionDepth = {
 export type AdjacentTransactionsResponse = {
     transactions: ToncenterTransaction[];
 };
+export type TonAdjacentTransactionsResponse = {
+    transactions: ToncenterV3IndexedTransaction[];
+};
+export type ToncenterV3TransactionsResponse = {
+    transactions: ToncenterV3IndexedTransaction[];
+};
 export type TxFinalizerConfig = {
     urlBuilder: (hash: string) => string;
     authorization?: {