@tonappchain/sdk 0.7.2 → 0.7.3-rc1

package/dist/src/sdk/LiteSequencerClient.js

@@ -55,6 +55,22 @@ class LiteSequencerClient {
             throw (0, errors_1.operationFetchError)(`request ${requestLabel} failed to complete request`, error);
         }
     }
+    async getOperationTypeV2(operationId) {
+        const path = 'v2/operation-type';
+        const requestLabel = this.getRequestLabel('GET', path);
+        try {
+            const response = await this.httpClient.get(new URL(path, this.endpoint).toString(), {
+                params: {
+                    operationId,
+                },
+                transformResponse: [Utils_1.toCamelCaseTransformer],
+            });
+            return response.data.response;
+        }
+        catch (error) {
+            throw (0, errors_1.operationFetchError)(`request ${requestLabel} failed to complete request`, error);
+        }
+    }
     async getOperationId(transactionLinker) {
         const path = 'ton/operation-id';
         const requestLabel = this.getRequestLabel('POST', path);
@@ -117,6 +133,27 @@ class LiteSequencerClient {
             throw (0, errors_1.profilingFetchError)(`request ${requestLabel} failed to complete request`, error);
         }
     }
+    async getStageProfilingsV2(operationIds, chunkSize = this.maxChunkSize) {
+        const path = 'v2/stage-profiling';
+        const requestLabel = this.getRequestLabel('POST', path);
+        if (!operationIds || operationIds.length === 0) {
+            throw (0, errors_1.emptyArrayError)('operationIds');
+        }
+        try {
+            const response = await this.processChunkedRequest(operationIds, async (chunk) => {
+                const response = await this.httpClient.post(new URL(path, this.endpoint).toString(), {
+                    operationIds: chunk,
+                }, {
+                    transformResponse: [Utils_1.toCamelCaseTransformer],
+                });
+                return response.data;
+            }, chunkSize);
+            return response.response;
+        }
+        catch (error) {
+            throw (0, errors_1.profilingFetchError)(`request ${requestLabel} failed to complete request`, error);
+        }
+    }
     async getOperationStatuses(operationIds, chunkSize = this.maxChunkSize) {
         const path = 'status';
         const requestLabel = this.getRequestLabel('POST', path);

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

@@ -1,5 +1,5 @@
 import { ILiteSequencerClient, ILiteSequencerClientFactory, ILogger, IOperationTracker } from '../interfaces';
-import { ConvertCurrencyParams, ConvertedCurrencyResult, ExecutionStages, ExecutionStagesByOperationId, GetTVMExecutorFeeParams, Network, OperationIdsByShardsKey, OperationType, SimplifiedStatuses, StatusInfo, StatusInfosByOperationId, SuggestedTVMExecutorFee, TACSimulationParams, TACSimulationResult, TransactionLinker, WaitOptions } from '../structs/Struct';
+import { ConvertCurrencyParams, ConvertedCurrencyResult, ExecutionStages, ExecutionStagesByOperationId, ExecutionStagesV2, ExecutionStagesV2ByOperationId, GetTVMExecutorFeeParams, Network, OperationIdsByShardsKey, OperationType, OperationTypeV2Info, SimplifiedStatuses, StatusInfo, StatusInfosByOperationId, SuggestedTVMExecutorFee, TACSimulationParams, TACSimulationResult, TransactionLinker, WaitOptions } from '../structs/Struct';
 export declare class DefaultLiteSequencerClientFactory implements ILiteSequencerClientFactory {
     createClients(endpoints: string[]): ILiteSequencerClient[];
 }
@@ -9,10 +9,13 @@ export declare class OperationTracker implements IOperationTracker {
     constructor(network: Network, customLiteSequencerEndpoints?: string[], logger?: ILogger, clientFactory?: ILiteSequencerClientFactory);
     getOperationIdByTransactionHash(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>;
     getOperationIdsByShardsKeys(shardsKeys: string[], caller: string, waitOptions?: WaitOptions<OperationIdsByShardsKey> | null, chunkSize?: number): Promise<OperationIdsByShardsKey>;
     getStageProfiling(operationId: string, waitOptions?: WaitOptions<ExecutionStages> | null): Promise<ExecutionStages>;
     getStageProfilings(operationIds: string[], waitOptions?: WaitOptions<ExecutionStagesByOperationId> | null, chunkSize?: number): Promise<ExecutionStagesByOperationId>;
+    getStageProfilingV2(operationId: string, waitOptions?: WaitOptions<ExecutionStagesV2> | null): Promise<ExecutionStagesV2>;
+    getStageProfilingsV2(operationIds: string[], waitOptions?: WaitOptions<ExecutionStagesV2ByOperationId> | null, chunkSize?: number): Promise<ExecutionStagesV2ByOperationId>;
     getOperationStatuses(operationIds: string[], waitOptions?: WaitOptions<StatusInfosByOperationId> | null, chunkSize?: number): Promise<StatusInfosByOperationId>;
     getOperationStatus(operationId: string, waitOptions?: WaitOptions<StatusInfo> | null): Promise<StatusInfo>;
     getSimplifiedOperationStatus(transactionLinker: TransactionLinker): Promise<SimplifiedStatuses>;

package/dist/src/sdk/OperationTracker.js

@@ -70,6 +70,24 @@ class OperationTracker {
             ? await requestFn()
             : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, `OperationTracker: Getting operation type for ${(0, Utils_1.formatObjectForLogging)(operationId)}`);
     }
+    async getOperationTypeV2(operationId, waitOptions) {
+        const requestFn = async () => {
+            let lastError;
+            for (const client of this.clients) {
+                try {
+                    const type = await client.getOperationTypeV2(operationId);
+                    return type;
+                }
+                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 type v2 for ${(0, Utils_1.formatObjectForLogging)(operationId)}`);
+    }
     async getOperationId(transactionLinker, waitOptions) {
         const requestFn = async () => {
             let lastError;
@@ -146,6 +164,46 @@ class OperationTracker {
             ? await requestFn()
             : await (0, Utils_1.waitUntilSuccess)({ logger: this.logger, ...waitOptions }, requestFn, `OperationTracker: Getting stage profilings for operations: ${operationIds.join(', ')} chunkSize=${chunkSize}`);
     }
+    async getStageProfilingV2(operationId, waitOptions) {
+        const requestFn = async () => {
+            let lastError;
+            for (const client of this.clients) {
+                try {
+                    const map = await client.getStageProfilingsV2([operationId]);
+                    const result = map[operationId];
+                    if (!result) {
+                        throw new Error(`No stageProfiling v2 data for operationId=${operationId}`);
+                    }
+                    return result;
+                }
+                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 stage profiling v2 for operation ${operationId}`);
+    }
+    async getStageProfilingsV2(operationIds, waitOptions, chunkSize = 100) {
+        const requestFn = async () => {
+            let lastError;
+            for (const client of this.clients) {
+                try {
+                    const result = await client.getStageProfilingsV2(operationIds, chunkSize);
+                    return result;
+                }
+                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 stage profilings v2 for operations: ${operationIds.join(', ')} chunkSize=${chunkSize}`);
+    }
     async getOperationStatuses(operationIds, waitOptions, chunkSize = 100) {
         const requestFn = async () => {
             let lastError;

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

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

package/dist/src/sdk/TACTransactionManager.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TACTransactionManager = void 0;
 const ethers_1 = require("ethers");
 const assets_1 = require("../assets");
+const errors_1 = require("../errors");
 const Struct_1 = require("../structs/Struct");
 const Consts_1 = require("./Consts");
 const Logger_1 = require("./Logger");
@@ -14,28 +15,10 @@ class TACTransactionManager {
         this.operationTracker = operationTracker;
         this.logger = logger;
     }
-    async approveAsset(asset, signer, spenderAddress) {
-        const evmAddress = await asset.getEVMAddress();
-        if (asset.type === Struct_1.AssetType.FT) {
-            this.logger.debug(`Approving FT ${evmAddress} for ${spenderAddress}`);
-            const erc20Abi = this.config.artifacts.tac.compilationArtifacts.IERC20WithDecimals.abi;
-            const contract = new ethers_1.ethers.Contract(evmAddress, erc20Abi, this.config.TACParams.provider);
-            const tx = await contract.connect(signer).approve(spenderAddress, asset.rawAmount);
-            await tx.wait();
-        }
-        else if (asset.type === Struct_1.AssetType.NFT) {
-            this.logger.debug(`Approving NFT ${evmAddress} for ${spenderAddress}`);
-            const erc721Abi = this.config.artifacts.tac.compilationArtifacts.IERC721.abi;
-            const contract = new ethers_1.ethers.Contract(evmAddress, erc721Abi, this.config.TACParams.provider);
-            const tx = await contract.connect(signer).approve(spenderAddress, asset.addresses.index);
-            await tx.wait();
-        }
-        this.logger.debug(`Approved ${evmAddress} for ${spenderAddress}`);
-    }
-    async bridgeTokensToTON(signer, value, tonTarget, assets = [], tvmExecutorFee, tvmValidExecutors) {
-        this.logger.debug('Bridging tokens to TON');
+    async prepareBridgeTokensToTON(value, tonTarget, assets = [], tvmExecutorFee, tvmValidExecutors) {
         Validator_1.Validator.validateTVMAddress(tonTarget);
-        // Add native TAC asset if value > 0
+        Validator_1.Validator.validateTVMAddresses(tvmValidExecutors);
+        const validExecutors = tvmValidExecutors?.length ? tvmValidExecutors : this.config.getTrustedTONExecutors;
         const tonAssets = [...assets];
         if (value > 0n) {
             tonAssets.push((await assets_1.AssetFactory.from(this.config, {
@@ -43,26 +26,20 @@ class TACTransactionManager {
                 tokenType: Struct_1.AssetType.FT,
             })).withRawAmount(value));
         }
-        // Calculate executor fee if not provided
         if (!tvmExecutorFee) {
             const feeParams = {
                 tonAssets: (0, Utils_1.mapAssetsToTonAssets)(tonAssets),
                 feeSymbol: Consts_1.TAC_SYMBOL,
-                tvmValidExecutors: tvmValidExecutors ?? [],
+                tvmValidExecutors: validExecutors,
             };
-            const suggestedFee = await this.operationTracker.getTVMExecutorFee(feeParams);
+            const suggestedFee = await this.operationTracker.getTVMExecutorFee(feeParams, null);
             this.logger.debug(`Suggested TON executor fee: ${(0, Utils_1.formatObjectForLogging)(suggestedFee)}`);
             tvmExecutorFee = BigInt(suggestedFee.inTAC);
         }
-        // Approve all assets
         const crossChainLayerAddress = await this.config.TACParams.crossChainLayer.getAddress();
-        for (const asset of assets) {
-            await this.approveAsset(asset, signer, crossChainLayerAddress);
-        }
         const protocolFee = await this.config.TACParams.crossChainLayer.getProtocolFee();
-        const shardsKey = BigInt(Math.round(Math.random() * 1e18));
+        const shardsKey = BigInt(Math.round(Math.random() * Consts_1.SHARDS_KEY_RANDOM_RANGE));
         this.logger.debug(`Shards key: ${shardsKey}, Protocol fee: ${protocolFee}`);
-        // Prepare bridge data
         const [toBridge, toBridgeNFT] = await Promise.all([
             Promise.all(assets
                 .filter((a) => a.type === Struct_1.AssetType.FT)
@@ -74,7 +51,7 @@ class TACTransactionManager {
                 .filter((a) => a.type === Struct_1.AssetType.NFT)
                 .map(async (a) => ({
                 evmAddress: await a.getEVMAddress(),
-                amount: 1n,
+                amount: Consts_1.NFT_BRIDGE_AMOUNT,
                 tokenId: a.addresses.index,
             }))),
         ]);
@@ -84,15 +61,174 @@ class TACTransactionManager {
             tvmPayload: '',
             tvmProtocolFee: protocolFee,
             tvmExecutorFee,
-            tvmValidExecutors: this.config.getTrustedTONExecutors,
+            tvmValidExecutors: validExecutors,
             toBridge,
             toBridgeNFT,
         };
-        const totalValue = value + BigInt(outMessage.tvmProtocolFee) + BigInt(outMessage.tvmExecutorFee);
+        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();
+        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);
+            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);
+            await tx.wait();
+        }
+        this.logger.debug(`Approved ${evmAddress} for ${spenderAddress}`);
+    }
+    async sendCrossChainTransactionToTON(signer, tonTarget, assets = [], options) {
+        const signerAddress = signer.address;
+        const nativeTACAsset = await assets_1.AssetFactory.from(this.config, {
+            address: await this.config.nativeTACAddress(),
+            tokenType: Struct_1.AssetType.FT,
+        });
+        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) {
+                value += asset.rawAmount;
+                continue;
+            }
+            bridgeAssets.push(asset);
+        }
+        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) => {
+            throw (0, errors_1.blockGasLimitFetchError)('provider failed to return latest block', error);
+        });
+        const blockGasLimit = latestBlock?.gasLimit;
+        if (blockGasLimit === null || blockGasLimit === undefined) {
+            throw (0, errors_1.blockGasLimitFetchError)('provider did not return latest block gas limit');
+        }
+        const transactionParams = {
+            maxFeePerGas,
+            maxPriorityFeePerGas: feeData.maxPriorityFeePerGas ?? Consts_1.DEFAULT_EIP1559_PRIORITY_FEE,
+        };
+        const shouldValidateAssetsBalance = options?.validateAssetsBalance ?? true;
+        if (shouldValidateAssetsBalance) {
+            await Promise.all(bridgeAssets.map((asset) => asset.checkCanBeTransferredBy(signerAddress, Struct_1.BlockchainType.TAC)));
+        }
+        let requiredBalance = preparedBridge.totalValue;
+        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);
+            }
+            if (estimatedGas > blockGasLimit) {
+                throw (0, errors_1.estimatedGasExceedsBlockGasLimitError)('approve', estimatedGas, blockGasLimit);
+            }
+            requiredBalance += estimatedGas * maxFeePerGas;
+            approvalPlans.push({ asset, gasLimit: estimatedGas });
+        }
+        const sendMessageGas = await this.config.TACParams.crossChainLayer
+            .connect(signer)
+            .sendMessage.estimateGas(Consts_1.CROSS_CHAIN_MESSAGE_VERSION_V1, preparedBridge.outMessagePayload, {
+            ...transactionParams,
+            value: preparedBridge.totalValue,
+        });
+        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) {
+            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, {
+            ...transactionParams,
+            gasLimit: sendMessageGas,
+            value: preparedBridge.totalValue,
+        });
+        await tx.wait();
+        this.logger.debug(`Transaction hash: ${tx.hash}`);
+        const shouldWaitForOperationId = options?.waitOperationId ?? true;
+        if (!shouldWaitForOperationId) {
+            return { txHash: tx.hash };
+        }
+        const waitOptions = options?.waitOptions ?? {};
+        waitOptions.successCheck = waitOptions.successCheck ?? ((id) => !!id);
+        waitOptions.logger = waitOptions.logger ?? this.logger;
+        const operationId = await this.operationTracker
+            .getOperationIdByTransactionHash(tx.hash, waitOptions)
+            .catch((error) => {
+            this.logger.error(`Error while waiting for operation ID by transaction hash: ${error}`);
+            return undefined;
+        });
+        const shouldWaitForFinalization = options?.waitFinalization ?? true;
+        if (!shouldWaitForFinalization) {
+            return { txHash: tx.hash, operationId };
+        }
+        if (!operationId) {
+            throw errors_1.operationIdRequiredForFinalizationError;
+        }
+        const finalizationWaitOptions = options?.finalizationWaitOptions ?? {};
+        finalizationWaitOptions.successCheck = finalizationWaitOptions.successCheck ?? Utils_1.isFinalProfiling;
+        finalizationWaitOptions.logger = finalizationWaitOptions.logger ?? this.logger;
+        finalizationWaitOptions.onSuccess =
+            finalizationWaitOptions.onSuccess ??
+                (async (profilingData) => {
+                    if (!profilingData.executedInTON.exists) {
+                        return;
+                    }
+                    if (!profilingData.executedInTON.stageData?.success) {
+                        throw errors_1.executedInTONStageFailedError;
+                    }
+                    for (const transaction of profilingData.executedInTON.stageData?.transactions ?? []) {
+                        await this.config.TONParams.contractOpener.trackTransactionTree(this.config.TONParams.crossChainLayerAddress, transaction.hash);
+                    }
+                });
+        await this.operationTracker.getStageProfiling(operationId, finalizationWaitOptions);
+        return { txHash: tx.hash, operationId };
+    }
+    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);
         this.logger.debug(`Total value: ${totalValue}`);
+        for (const asset of assets) {
+            await this.approveAsset(asset, signer, crossChainLayerAddress);
+        }
         const tx = await this.config.TACParams.crossChainLayer
             .connect(signer)
-            .sendMessage(1n, this.config.artifacts.tac.utils.encodeOutMessageV1(outMessage), { value: totalValue });
+            .sendMessage(Consts_1.CROSS_CHAIN_MESSAGE_VERSION_V1, outMessagePayload, {
+            value: totalValue,
+        });
         await tx.wait();
         this.logger.debug(`Transaction hash: ${tx.hash}`);
         return tx.hash;

package/dist/src/sdk/TONTransactionManager.js

@@ -68,8 +68,7 @@ class TONTransactionManager {
     async prepareCrossChainTransaction(evmProxyMsg, sender, assets, options, skipAssetsBalanceValidation = false) {
         this.logger.debug('Preparing cross-chain transaction');
         const caller = sender.getSenderAddress();
-        const { allowSimulationError = false, isRoundTrip = undefined, calculateRollbackFee = true, validateAssetsBalance = true, evmDataBuilder = Utils_1.buildEvmDataCell, } = options || {};
-        const { evmValidExecutors = [], tvmValidExecutors = [] } = options || {};
+        const { allowSimulationError = false, isRoundTrip = undefined, calculateRollbackFee = true, validateAssetsBalance = true, evmValidExecutors = [], tvmValidExecutors = [], evmDataBuilder = Utils_1.buildEvmDataCell, } = options || {};
         Validator_1.Validator.validateEVMAddress(evmProxyMsg.evmTargetAddress);
         const aggregatedData = (0, Utils_1.aggregateTokens)(assets);
         Validator_1.Validator.validateEVMAddresses(evmValidExecutors);
@@ -182,16 +181,14 @@ class TONTransactionManager {
         if (!shouldWaitForOperationId) {
             return { sendTransactionResult, ...transactionLinker };
         }
-        const waitOptions = tx.options?.waitOptions ?? {};
         const ensureTxExecuted = tx.options?.ensureTxExecuted ?? true;
         if (ensureTxExecuted && sendTransactionResult.boc) {
             const hash = (0, Utils_1.getNormalizedExtMessageHash)((0, ton_1.loadMessage)(ton_1.Cell.fromBase64(sendTransactionResult.boc).beginParse()));
             this.logger.info(`Tracking transaction tree for hash: ${hash}`);
-            await this.config.TONParams.contractOpener.trackTransactionTree(sender.getSenderAddress(), hash, {
-                maxDepth: Consts_1.DEFAULT_FIND_TX_MAX_DEPTH,
-            });
+            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
@@ -200,6 +197,31 @@ class TONTransactionManager {
             this.logger.error(`Error while waiting for operation ID: ${error}`);
             return undefined;
         });
+        const shouldWaitForFinalization = tx.options?.waitFinalization ?? true;
+        if (!shouldWaitForFinalization) {
+            return { sendTransactionResult, ...transactionLinker };
+        }
+        if (!operationId) {
+            throw errors_1.operationIdRequiredForFinalizationError;
+        }
+        const finalizationWaitOptions = tx.options?.finalizationWaitOptions ?? {};
+        finalizationWaitOptions.successCheck = finalizationWaitOptions.successCheck ?? Utils_1.isFinalProfiling;
+        finalizationWaitOptions.logger = finalizationWaitOptions.logger ?? this.logger;
+        finalizationWaitOptions.onSuccess =
+            finalizationWaitOptions.onSuccess ??
+                (async (profilingData) => {
+                    const stage = profilingData.executedInTON;
+                    if (!stage.exists) {
+                        return;
+                    }
+                    if (!stage.stageData?.success) {
+                        throw errors_1.executedInTONStageFailedError;
+                    }
+                    for (const transaction of stage.stageData?.transactions ?? []) {
+                        await this.config.TONParams.contractOpener.trackTransactionTree(this.config.TONParams.crossChainLayerAddress, transaction.hash);
+                    }
+                });
+        await this.operationTracker.getStageProfiling(operationId, finalizationWaitOptions);
         return { sendTransactionResult, operationId, ...transactionLinker };
     }
     async sendCrossChainTransactions(sender, txs, options) {

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

@@ -1,9 +1,9 @@
 import { Wallet } from 'ethers';
 import { JettonMinterData, NFTItemData } from '../../artifacts/tonTypes';
-import { FT, NFT } from '../assets';
+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, CrosschainTx, EVMAddress, EvmProxyMsg, ExecutionFeeEstimationResult, NFTAddressType, SDKParams, SuggestedTVMExecutorFee, TacGasPrice, TACSimulationParams, TACSimulationResult, TransactionLinkerWithOperationId, TVMAddress, UserWalletBalanceExtended } from '../structs/Struct';
+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';
 export declare class TacSdk implements ITacSDK {
     readonly config: IConfiguration;
     readonly contactOpener: ContractOpener;
@@ -23,12 +23,13 @@ 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>;
     sendCrossChainTransactions(sender: SenderAbstraction, txs: BatchCrossChainTxWithAssetLike[], options?: CrossChainTransactionsOptions): Promise<TransactionLinkerWithOperationId[]>;
     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>;
     simulateTransactions(sender: SenderAbstraction, txs: CrosschainTx[]): Promise<ExecutionFeeEstimationResult[]>;
-    getAsset(args: AssetFromFTArg): Promise<FT>;
+    getAsset(args: AssetFromFTArg): Promise<FT | TAC | TON>;
     getAsset(args: AssetFromNFTCollectionArg): Promise<NFT>;
     getAsset(args: AssetFromNFTItemArg): Promise<NFT>;
     getUserJettonWalletAddress(userAddress: string, tokenAddress: string): Promise<string>;

package/dist/src/sdk/TacSdk.js

@@ -87,6 +87,10 @@ class TacSdk {
         const tx = { evmProxyMsg, assets: normalizedAssets, options };
         return this.tonTransactionManager.sendCrossChainTransaction(evmProxyMsg, sender, tx);
     }
+    async sendCrossChainTransactionToTON(signer, tonTarget, assets, options) {
+        const normalizedAssets = await (0, Utils_1.normalizeAssets)(this.config, assets);
+        return this.tacTransactionManager.sendCrossChainTransactionToTON(signer, tonTarget, normalizedAssets, options);
+    }
     async sendCrossChainTransactions(sender, txs, options) {
         const normalizedTxs = await Promise.all(txs.map(async (tx) => ({
             evmProxyMsg: tx.evmProxyMsg,

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

@@ -3,7 +3,7 @@ import { AbiCoder } from 'ethers';
 import type { FT, NFT, TON } from '../assets';
 import { Asset, IConfiguration } from '../interfaces';
 import { RandomNumberByTimestamp } from '../structs/InternalStruct';
-import { AssetLike, EvmProxyMsg, FeeParams, TONAsset, TransactionLinker, ValidExecutors, WaitOptions } from '../structs/Struct';
+import { AssetLike, EvmProxyMsg, ExecutionStages, FeeParams, TONAsset, 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;
@@ -56,3 +56,4 @@ export declare function recurisivelyCollectCellStats(cell: Cell): {
     bits: number;
     cells: number;
 };
+export declare function isFinalProfiling(profilingData: ExecutionStages): boolean;

package/dist/src/sdk/Utils.js

@@ -25,6 +25,7 @@ exports.normalizeHashToHex = normalizeHashToHex;
 exports.getNormalizedExtMessageHash = getNormalizedExtMessageHash;
 exports.retry = retry;
 exports.recurisivelyCollectCellStats = recurisivelyCollectCellStats;
+exports.isFinalProfiling = isFinalProfiling;
 const ton_1 = require("@ton/ton");
 const ethers_1 = require("ethers");
 const ton_crypto_1 = require("ton-crypto");
@@ -458,3 +459,6 @@ function recurisivelyCollectCellStats(cell) {
     }
     return { bits, cells };
 }
+function isFinalProfiling(profilingData) {
+    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, Network, OperationIdsByShardsKey, OperationType, StatusInfosByOperationId, SuggestedTVMExecutorFee, TACSimulationResult } from './Struct';
+import { CurrencyType, ExecutionStagesByOperationId, ExecutionStagesV2ByOperationId, Network, OperationIdsByShardsKey, OperationType, OperationTypeV2Info, StatusInfosByOperationId, SuggestedTVMExecutorFee, TACSimulationResult, TransactionLinker } from './Struct';
 export type ShardMessage = {
     address: string;
     value: bigint;
@@ -17,6 +17,15 @@ export type ShardTransaction = {
     messages: ShardMessage[];
     network: Network;
 };
+export type PreparedCrossChainTransaction = {
+    transaction: ShardTransaction;
+    transactionLinker: TransactionLinker;
+};
+export type PreparedBridgeTokensToTON = {
+    crossChainLayerAddress: string;
+    outMessagePayload: ethers.BytesLike;
+    totalValue: bigint;
+};
 export declare enum AssetOpType {
     JETTON_BURN = "JETTON_BURN",
     JETTON_TRANSFER = "JETTON_TRANSFER",
@@ -54,9 +63,11 @@ export type ResponseBase<T> = {
 };
 export type StringResponse = ResponseBase<string>;
 export type OperationTypeResponse = ResponseBase<OperationType>;
+export type OperationTypeV2Response = ResponseBase<OperationTypeV2Info>;
 export type StatusesResponse = ResponseBase<StatusInfosByOperationId>;
 export type OperationIdsByShardsKeyResponse = ResponseBase<OperationIdsByShardsKey>;
 export type StageProfilingResponse = ResponseBase<ExecutionStagesByOperationId>;
+export type StageProfilingV2Response = ResponseBase<ExecutionStagesV2ByOperationId>;
 export type TACSimulationResponse = ResponseBase<TACSimulationResult>;
 export type SuggestedTVMExecutorFeeResponse = ResponseBase<SuggestedTVMExecutorFee>;
 export type ConvertCurrencyResponse = ResponseBase<ConvertedCurrencyRawResult>;
@@ -72,6 +83,29 @@ export interface SendResult {
     error?: Error;
     lastMessageIndex?: number;
 }
+export type SendGroupTransferResult = string | {
+    result: string;
+};
+export type SendBatchTransferResult = string | void | {
+    result: string | void;
+};
+export type RetryableOperationResult<T> = {
+    success: boolean;
+    data?: T;
+    lastError?: Error;
+};
+export type MetadataPersistenceType = 'none' | 'onchain' | 'offchain_private_domain' | 'offchain_ipfs' | 'semichain_private_domain' | 'semichain_ipfs';
+export type OffchainMetadataResult<TMetadata = unknown> = {
+    metadata: TMetadata | null;
+    isIpfs: boolean;
+    contentUri: string;
+};
+export type ReadMetadataResult<TMetadata = unknown> = {
+    persistenceType: MetadataPersistenceType;
+    metadata: TMetadata | null;
+    contentUri?: string;
+    isJettonDeployerFaultyOnChainData?: boolean;
+};
 export type ToncenterTransaction = {
     description: {
         aborted: boolean;