@tonappchain/sdk 0.7.2 → 0.7.3-rc2

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);
@@ -55,6 +76,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 +154,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[];
 }
@@ -8,11 +8,15 @@ 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>;
     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

@@ -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;
@@ -70,6 +88,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 +182,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,14 @@
 import { Wallet } from 'ethers';
 import { Asset, IConfiguration, ILogger, IOperationTracker, ITACTransactionManager } from '../interfaces';
+import { CrossChainTransactionToTONOptions, 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;
+    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

@@ -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,19 @@ 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 +50,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 +60,185 @@ class TACTransactionManager {
             tvmPayload: '',
             tvmProtocolFee: protocolFee,
             tvmExecutorFee,
-            tvmValidExecutors: this.config.getTrustedTONExecutors,
+            tvmValidExecutors: validExecutors,
             toBridge,
             toBridgeNFT,
         };
-        const totalValue = value + BigInt(outMessage.tvmProtocolFee) + BigInt(outMessage.tvmExecutorFee);
+        return {
+            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 = 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 = 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, {
+            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 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) => {
+            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 requiredApprovalBalance = 0n;
+        const approvalPlans = [];
+        for (const asset of bridgeAssets) {
+            const estimatedGas = await this.estimateApprovalGas(asset, signer, crossChainLayerAddress, transactionParams);
+            if (estimatedGas > blockGasLimit) {
+                throw (0, errors_1.estimatedGasExceedsBlockGasLimitError)('approve', estimatedGas, blockGasLimit);
+            }
+            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, {
+            ...transactionParams,
+            value: preparedBridge.totalValue,
+        });
+        if (sendMessageGas > blockGasLimit) {
+            throw (0, errors_1.estimatedGasExceedsBlockGasLimitError)('sendMessage', sendMessageGas, blockGasLimit);
+        }
+        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);
+        }
+        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');
+        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);
+        }
         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, 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,12 +24,15 @@ 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?: 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>;
     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>;
@@ -47,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;
 }