@tonappchain/sdk 0.7.0-rc13 → 0.7.0-rc15

package/dist/sdk/OperationTracker.js

@@ -7,6 +7,7 @@ const Struct_1 = require("../structs/Struct");
 const LiteSequencerClient_1 = require("./LiteSequencerClient");
 const Logger_1 = require("./Logger");
 const Utils_1 = require("./Utils");
+const Validator_1 = require("./Validator");
 class DefaultLiteSequencerClientFactory {
     createClients(endpoints) {
         return endpoints.map((endpoint) => new LiteSequencerClient_1.LiteSequencerClient(endpoint));
@@ -40,7 +41,7 @@ class OperationTracker {
             this.logger.error('All endpoints failed to get operation id by transactionHash');
             throw (0, errors_1.allEndpointsFailedError)(lastError);
         };
-        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : await requestFn();
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, "OperationTracker: Getting operation ID by transaction hash") : await requestFn();
     }
     async getOperationType(operationId, waitOptions) {
         this.logger.debug(`Getting operation type for ${(0, Utils_1.formatObjectForLogging)(operationId)}`);
@@ -60,7 +61,7 @@ class OperationTracker {
             this.logger.error('All endpoints failed to get operation type');
             throw (0, errors_1.allEndpointsFailedError)(lastError);
         };
-        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : await requestFn();
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, "OperationTracker: Getting operation type") : await requestFn();
     }
     async getOperationId(transactionLinker, waitOptions) {
         this.logger.debug(`Getting operation ID for transaction linker: ${(0, Utils_1.formatObjectForLogging)(transactionLinker)}`);
@@ -80,7 +81,7 @@ class OperationTracker {
             this.logger.error('All endpoints failed to get operation id');
             throw (0, errors_1.allEndpointsFailedError)(lastError);
         };
-        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : await requestFn();
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, "OperationTracker: Getting operation ID by transaction linker") : await requestFn();
     }
     async getOperationIdsByShardsKeys(shardsKeys, caller, waitOptions, chunkSize = 100) {
         this.logger.debug(`Getting operation IDs for shards keys: ${(0, Utils_1.formatObjectForLogging)(shardsKeys)}`);
@@ -101,7 +102,7 @@ class OperationTracker {
             this.logger.error('All endpoints failed to get operation ids by shards keys');
             throw (0, errors_1.allEndpointsFailedError)(lastError);
         };
-        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : await requestFn();
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, "OperationTracker: Getting operation IDs by shards keys") : await requestFn();
     }
     async getStageProfiling(operationId, waitOptions) {
         this.logger.debug(`Getting stage profiling for operation ${operationId}`);
@@ -126,7 +127,7 @@ class OperationTracker {
             this.logger.error('All endpoints failed to get stage profiling');
             throw (0, errors_1.allEndpointsFailedError)(lastError);
         };
-        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : await requestFn();
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, "OperationTracker: Getting stage profiling") : await requestFn();
     }
     async getStageProfilings(operationIds, waitOptions, chunkSize = 100) {
         this.logger.debug(`Getting stage profilings for operations: ${operationIds.join(', ')}`);
@@ -147,7 +148,7 @@ class OperationTracker {
             this.logger.error('All endpoints failed to get stage profilings');
             throw (0, errors_1.allEndpointsFailedError)(lastError);
         };
-        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : await requestFn();
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, "OperationTracker: Getting stage profilings") : await requestFn();
     }
     async getOperationStatuses(operationIds, waitOptions, chunkSize = 100) {
         this.logger.debug(`Getting operation statuses for operations: ${(0, Utils_1.formatObjectForLogging)(operationIds)}`);
@@ -168,7 +169,7 @@ class OperationTracker {
             this.logger.error('All endpoints failed to get operation statuses');
             throw (0, errors_1.allEndpointsFailedError)(lastError);
         };
-        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : await requestFn();
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, "OperationTracker: Getting operation statuses") : await requestFn();
     }
     async getOperationStatus(operationId, waitOptions) {
         this.logger.debug(`Getting operation status for ${(0, Utils_1.formatObjectForLogging)(operationId)}`);
@@ -193,7 +194,7 @@ class OperationTracker {
             this.logger.error('All endpoints failed to get operation status');
             throw (0, errors_1.allEndpointsFailedError)(lastError);
         };
-        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : await requestFn();
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, "OperationTracker: Getting operation status") : await requestFn();
     }
     async getSimplifiedOperationStatus(transactionLinker) {
         this.logger.debug(`Getting simplified operation status for transaction linker: ${(0, Utils_1.formatObjectForLogging)(transactionLinker)}`);
@@ -202,9 +203,7 @@ class OperationTracker {
             this.logger.warn('Operation ID not found');
             return Struct_1.SimplifiedStatuses.OPERATION_ID_NOT_FOUND;
         }
-        this.logger.debug(`Operation ID: ${operationId}`);
         const operationType = await this.getOperationType(operationId);
-        this.logger.debug(`Operation type: ${operationType}`);
         if (operationType == Struct_1.OperationType.PENDING || operationType == Struct_1.OperationType.UNKNOWN) {
             return Struct_1.SimplifiedStatuses.PENDING;
         }
@@ -231,7 +230,48 @@ class OperationTracker {
             this.logger.error('All endpoints failed to convert currency');
             throw (0, errors_1.allEndpointsFailedError)(lastError);
         };
-        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : await requestFn();
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, "OperationTracker: Converting currency") : await requestFn();
+    }
+    async simulateTACMessage(params, waitOptions) {
+        Validator_1.Validator.validateTACSimulationParams(params);
+        this.logger.debug(`Simulating TAC message: ${(0, Utils_1.formatObjectForLogging)(params)}`);
+        const requestFn = async () => {
+            let lastError;
+            for (const client of this.clients) {
+                try {
+                    const result = await client.simulateTACMessage(params);
+                    this.logger.debug(`Simulation result retrieved successfully`);
+                    return result;
+                }
+                catch (error) {
+                    this.logger.warn(`Failed to simulate TAC message using one of the endpoints`);
+                    lastError = error;
+                }
+            }
+            this.logger.error('All endpoints failed to simulate TAC message');
+            throw (0, errors_1.allEndpointsFailedError)(lastError);
+        };
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, "OperationTracker: Simulating TAC message") : await requestFn();
+    }
+    async getTVMExecutorFee(params, waitOptions) {
+        this.logger.debug(`get TVM executor fee: ${(0, Utils_1.formatObjectForLogging)(params)}`);
+        const requestFn = async () => {
+            let lastError;
+            for (const client of this.clients) {
+                try {
+                    const result = await client.getTVMExecutorFee(params);
+                    this.logger.debug(`Suggested TVM executor fee retrieved successfully`);
+                    return result;
+                }
+                catch (error) {
+                    this.logger.warn(`Failed to get TVM executor fee using one of the endpoints`);
+                    lastError = error;
+                }
+            }
+            this.logger.error('All endpoints failed to get TVM executor fee');
+            throw (0, errors_1.allEndpointsFailedError)(lastError);
+        };
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn, "OperationTracker: Getting TVM executor fee") : await requestFn();
     }
 }
 exports.OperationTracker = OperationTracker;

package/dist/sdk/Simulator.d.ts

@@ -1,17 +1,11 @@
-import { Asset, IConfiguration, ILogger, ISimulator } from '../interfaces';
-import { IHttpClient } from '../interfaces';
+import { IConfiguration, ILogger, IOperationTracker, ISimulator } from '../interfaces';
 import type { SenderAbstraction } from '../sender';
-import { CrosschainTx, EvmProxyMsg, ExecutionFeeEstimationResult, SuggestedTONExecutorFee, TACSimulationRequest, TACSimulationResult, TransactionLinker } from '../structs/Struct';
+import { CrosschainTx, ExecutionFeeEstimationResult } from '../structs/Struct';
 export declare class Simulator implements ISimulator {
     private readonly config;
+    private readonly operationTracker;
     private readonly logger;
-    private readonly httpClient;
-    constructor(config: IConfiguration, logger?: ILogger, httpClient?: IHttpClient);
-    simulateTACMessage(req: TACSimulationRequest): Promise<TACSimulationResult>;
-    simulateTransactions(sender: SenderAbstraction, txs: CrosschainTx[]): Promise<TACSimulationResult[]>;
-    private buildTACSimulationRequest;
-    getTVMExecutorFeeInfo(assets: Asset[], feeSymbol: string, tvmValidExecutors?: string[]): Promise<SuggestedTONExecutorFee>;
-    private getFeeInfo;
-    getTransactionSimulationInfo(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: Asset[]): Promise<ExecutionFeeEstimationResult>;
-    getSimulationInfoForTransaction(evmProxyMsg: EvmProxyMsg, transactionLinker: TransactionLinker, assets: Asset[], allowSimulationError?: boolean, isRoundTrip?: boolean, evmValidExecutors?: string[], tvmValidExecutors?: string[], calculateRollbackFee?: boolean): Promise<ExecutionFeeEstimationResult>;
+    constructor(config: IConfiguration, operationTracker: IOperationTracker, logger?: ILogger);
+    getSimulationsInfo(sender: SenderAbstraction, txs: CrosschainTx[]): Promise<ExecutionFeeEstimationResult[]>;
+    getSimulationInfo(sender: SenderAbstraction, tx: CrosschainTx): Promise<ExecutionFeeEstimationResult>;
 }

package/dist/sdk/Simulator.js

@@ -2,162 +2,68 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Simulator = void 0;
 const ton_1 = require("@ton/ton");
-const errors_1 = require("../errors");
-const AxiosHttpClient_1 = require("./AxiosHttpClient");
 const Logger_1 = require("./Logger");
 const Utils_1 = require("./Utils");
 const Validator_1 = require("./Validator");
 class Simulator {
-    constructor(config, logger = new Logger_1.NoopLogger(), httpClient = new AxiosHttpClient_1.AxiosHttpClient()) {
+    constructor(config, operationTracker, logger = new Logger_1.NoopLogger()) {
         this.config = config;
+        this.operationTracker = operationTracker;
         this.logger = logger;
-        this.httpClient = httpClient;
     }
-    async simulateTACMessage(req) {
-        Validator_1.Validator.validateTACSimulationRequest(req);
-        this.logger.debug('Simulating TAC message');
-        let lastError;
-        for (const endpoint of this.config.liteSequencerEndpoints) {
-            try {
-                const response = await this.httpClient.post(new URL('tac/simulator/simulate-message', endpoint).toString(), req, {
-                    transformResponse: [Utils_1.toCamelCaseTransformer],
-                });
-                this.logger.debug('TAC message simulation success');
-                return response.data.response;
-            }
-            catch (error) {
-                this.logger.error(`Error while simulating with ${endpoint}: ${error}`);
-                lastError = error;
-            }
-        }
-        throw (0, errors_1.simulationError)(lastError);
-    }
-    async simulateTransactions(sender, txs) {
+    async getSimulationsInfo(sender, txs) {
         this.logger.debug(`Simulating ${txs.length} TAC messages`);
         const results = [];
         for (const tx of txs) {
-            const req = await this.buildTACSimulationRequest(sender, tx);
-            const result = await this.simulateTACMessage(req);
+            const result = await this.getSimulationInfo(sender, tx);
             results.push(result);
         }
         return results;
     }
-    async buildTACSimulationRequest(sender, tx) {
+    async getSimulationInfo(sender, tx) {
+        this.logger.debug('Getting simulation info');
         const { evmProxyMsg, assets = [], options = {} } = tx;
-        const { evmValidExecutors = this.config.TACParams.trustedTACExecutors, tvmValidExecutors = this.config.TACParams.trustedTONExecutors, calculateRollbackFee = true, } = options;
+        const { evmValidExecutors = this.config.TACParams.trustedTACExecutors, tvmValidExecutors = this.config.TACParams.trustedTONExecutors, calculateRollbackFee = true, allowSimulationError = false, } = options;
+        Validator_1.Validator.validateEVMAddress(evmProxyMsg.evmTargetAddress);
         Validator_1.Validator.validateEVMAddresses(evmValidExecutors);
         Validator_1.Validator.validateTVMAddresses(tvmValidExecutors);
         const aggregatedData = await (0, Utils_1.aggregateTokens)(assets);
-        const transactionLinkerShardCount = aggregatedData.jettons.length == 0 ? 1 : aggregatedData.jettons.length;
-        const transactionLinker = (0, Utils_1.generateTransactionLinker)(sender.getSenderAddress(), transactionLinkerShardCount);
-        return {
+        const shardCount = aggregatedData.jettons.length || 1;
+        const transactionLinker = (0, Utils_1.generateTransactionLinker)(sender.getSenderAddress(), shardCount);
+        const tacSimulationParams = {
             tacCallParams: {
                 arguments: evmProxyMsg.encodedParameters ?? '0x',
                 methodName: (0, Utils_1.formatSolidityMethodName)(evmProxyMsg.methodName),
                 target: evmProxyMsg.evmTargetAddress,
             },
-            evmValidExecutors: evmValidExecutors,
-            tvmValidExecutors: tvmValidExecutors,
+            evmValidExecutors,
+            tvmValidExecutors,
             extraData: '0x',
             shardsKey: transactionLinker.shardsKey,
-            tonAssets: assets.map((asset) => ({
-                amount: asset.rawAmount.toString(),
-                tokenAddress: asset.address || '',
-                assetType: asset.type,
-            })),
+            tonAssets: (0, Utils_1.mapAssetsToTonAssets)(assets),
             tonCaller: transactionLinker.caller,
-            calculateRollbackFee: calculateRollbackFee,
+            calculateRollbackFee,
         };
-    }
-    async getTVMExecutorFeeInfo(assets, feeSymbol, tvmValidExecutors = this.config.TACParams.trustedTONExecutors) {
-        this.logger.debug('Getting TVM executor fee info');
-        const requestBody = {
-            tonAssets: assets.map((asset) => ({
-                amount: asset.rawAmount.toString(),
-                tokenAddress: asset.address || '',
-                assetType: asset.type,
-            })),
-            feeSymbol: feeSymbol,
-            tvmValidExecutors: tvmValidExecutors,
-        };
-        let lastError;
-        for (const endpoint of this.config.liteSequencerEndpoints) {
-            try {
-                const response = await this.httpClient.post(`${endpoint}/ton/calculator/ton-executor-fee`, requestBody);
-                return response.data.response;
-            }
-            catch (error) {
-                this.logger.error(`Error while calculating tvm executor fee ${endpoint}: ${error}`);
-                lastError = error;
-            }
-        }
-        this.logger.error('Error while calculating tvm executor fee on all endpoints');
-        throw (0, errors_1.simulationError)(lastError);
-    }
-    async getFeeInfo(evmProxyMsg, transactionLinker, assets, allowSimulationError = false, isRoundTrip = true, evmValidExecutors = this.config.TACParams.trustedTACExecutors, tvmValidExecutors = this.config.TACParams.trustedTONExecutors, calculateRollbackFee = true) {
-        this.logger.debug('Getting fee info');
-        Validator_1.Validator.validateEVMAddress(evmProxyMsg.evmTargetAddress);
-        Validator_1.Validator.validateEVMAddresses(evmValidExecutors);
-        Validator_1.Validator.validateTVMAddresses(tvmValidExecutors);
+        const simulation = await this.operationTracker.simulateTACMessage(tacSimulationParams);
+        this.logger.debug(`TAC simulation ${simulation.simulationStatus ? 'success' : 'failed'}`);
+        const isRoundTrip = options.isRoundTrip ?? assets.length !== 0;
         const crossChainLayer = this.config.TONParams.contractOpener.open(this.config.artifacts.ton.wrappers.CrossChainLayer.createFromAddress(ton_1.Address.parse(this.config.TONParams.crossChainLayerAddress)));
         const fullStateCCL = await crossChainLayer.getFullData();
-        this.logger.debug(`Full state CCL: ${(0, Utils_1.formatObjectForLogging)(fullStateCCL)}`);
-        const tacSimulationBody = {
-            tacCallParams: {
-                arguments: evmProxyMsg.encodedParameters ?? '0x',
-                methodName: (0, Utils_1.formatSolidityMethodName)(evmProxyMsg.methodName),
-                target: evmProxyMsg.evmTargetAddress,
-            },
-            evmValidExecutors: evmValidExecutors,
-            tvmValidExecutors: tvmValidExecutors,
-            extraData: '0x',
-            shardsKey: transactionLinker.shardsKey,
-            tonAssets: assets.map((asset) => ({
-                amount: asset.rawAmount.toString(),
-                tokenAddress: asset.address || '',
-                assetType: asset.type,
-            })),
-            tonCaller: transactionLinker.caller,
-            calculateRollbackFee: calculateRollbackFee,
-        };
-        isRoundTrip = isRoundTrip ?? assets.length != 0;
-        this.logger.debug(`Is round trip: ${isRoundTrip}`);
-        const tacSimulationResult = await this.simulateTACMessage(tacSimulationBody);
-        this.logger.debug(`TAC simulation ${tacSimulationResult.simulationStatus ? 'success' : 'failed'}`);
-        const protocolFee = BigInt((0, ton_1.toNano)(fullStateCCL.tacProtocolFee)) +
-            BigInt(isRoundTrip) * BigInt((0, ton_1.toNano)(fullStateCCL.tonProtocolFee));
         const feeParams = {
-            isRoundTrip: isRoundTrip,
-            gasLimit: !tacSimulationResult.simulationStatus ? 0n : tacSimulationResult.estimatedGas,
-            protocolFee: protocolFee,
-            evmExecutorFee: BigInt(tacSimulationResult.suggestedTacExecutionFee),
-            tvmExecutorFee: BigInt(tacSimulationResult.suggestedTonExecutionFee) * BigInt(isRoundTrip),
+            isRoundTrip,
+            gasLimit: simulation.simulationStatus ? simulation.estimatedGas : 0n,
+            protocolFee: BigInt((0, ton_1.toNano)(fullStateCCL.tacProtocolFee)) +
+                BigInt(isRoundTrip) * BigInt((0, ton_1.toNano)(fullStateCCL.tonProtocolFee)),
+            evmExecutorFee: BigInt(simulation.suggestedTacExecutionFee),
+            tvmExecutorFee: BigInt(simulation.suggestedTonExecutionFee) * BigInt(isRoundTrip),
         };
-        if (!tacSimulationResult.simulationStatus) {
-            if (allowSimulationError) {
-                this.logger.info('Force send is true, returning fee params');
-                return {
-                    feeParams,
-                    simulation: tacSimulationResult,
-                };
-            }
-            throw tacSimulationResult;
+        if (!simulation.simulationStatus && !allowSimulationError) {
+            throw simulation;
         }
-        this.logger.debug(`Collected fee params: ${(0, Utils_1.formatObjectForLogging)(feeParams)}`);
-        return { feeParams, simulation: tacSimulationResult };
-    }
-    async getTransactionSimulationInfo(evmProxyMsg, sender, assets) {
-        this.logger.debug('Getting transaction simulation info');
-        Validator_1.Validator.validateEVMAddress(evmProxyMsg.evmTargetAddress);
-        const aggregatedData = await (0, Utils_1.aggregateTokens)(assets);
-        const transactionLinkerShardCount = aggregatedData.jettons.length == 0 ? 1 : aggregatedData.jettons.length;
-        this.logger.debug(`Transaction linker shard count: ${transactionLinkerShardCount}`);
-        const transactionLinker = (0, Utils_1.generateTransactionLinker)(sender.getSenderAddress(), transactionLinkerShardCount);
-        this.logger.debug(`Transaction linker: ${(0, Utils_1.formatObjectForLogging)(transactionLinker)}`);
-        return await this.getFeeInfo(evmProxyMsg, transactionLinker, assets ?? []);
-    }
-    async getSimulationInfoForTransaction(evmProxyMsg, transactionLinker, assets, allowSimulationError = false, isRoundTrip, evmValidExecutors, tvmValidExecutors, calculateRollbackFee) {
-        return await this.getFeeInfo(evmProxyMsg, transactionLinker, assets, allowSimulationError, isRoundTrip, evmValidExecutors, tvmValidExecutors, calculateRollbackFee);
+        if (allowSimulationError && !simulation.simulationStatus) {
+            this.logger.info('Simulation failed but allowSimulationError is true, returning partial fee params');
+        }
+        return { feeParams, simulation };
     }
 }
 exports.Simulator = Simulator;

package/dist/sdk/TACTransactionManager.d.ts

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

package/dist/sdk/TACTransactionManager.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TACTransactionManager = void 0;
+const assets_1 = require("../assets");
+const Struct_1 = require("../structs/Struct");
+const Consts_1 = require("./Consts");
+const Logger_1 = require("./Logger");
+const Utils_1 = require("./Utils");
+const Validator_1 = require("./Validator");
+class TACTransactionManager {
+    constructor(config, operationTracker, logger = new Logger_1.NoopLogger()) {
+        this.config = config;
+        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 contract = this.config.artifacts.tac.wrappers.ERC20FactoryTAC.connect(evmAddress, 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 contract = this.config.artifacts.tac.wrappers.ERC721FactoryTAC.connect(evmAddress, 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');
+        Validator_1.Validator.validateTVMAddress(tonTarget);
+        // Add native TAC asset if value > 0
+        if (value > 0n) {
+            const nativeTacAsset = (await assets_1.AssetFactory.from(this.config, {
+                address: await this.config.nativeTACAddress(),
+                tokenType: Struct_1.AssetType.FT,
+            })).withRawAmount(value);
+            assets = [...assets, nativeTacAsset];
+        }
+        // Calculate executor fee if not provided
+        if (!tvmExecutorFee) {
+            const feeParams = {
+                tonAssets: (0, Utils_1.mapAssetsToTonAssets)(assets),
+                feeSymbol: Consts_1.TAC_SYMBOL,
+                tvmValidExecutors: tvmValidExecutors ?? [],
+            };
+            const suggestedFee = await this.operationTracker.getTVMExecutorFee(feeParams);
+            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();
+        await Promise.all(assets.map(asset => this.approveAsset(asset, signer, crossChainLayerAddress)));
+        const protocolFee = await this.config.TACParams.crossChainLayer.getProtocolFee();
+        const shardsKey = BigInt(Math.round(Math.random() * 1e18));
+        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).map(async (a) => ({
+                evmAddress: await a.getEVMAddress(),
+                amount: a.rawAmount,
+            }))),
+            Promise.all(assets.filter(a => a.type === Struct_1.AssetType.NFT).map(async (a) => ({
+                evmAddress: await a.getEVMAddress(),
+                amount: 1n,
+                tokenId: a.addresses.index,
+            }))),
+        ]);
+        const outMessage = {
+            shardsKey,
+            tvmTarget: tonTarget,
+            tvmPayload: '',
+            tvmProtocolFee: protocolFee,
+            tvmExecutorFee,
+            tvmValidExecutors: this.config.getTrustedTONExecutors,
+            toBridge,
+            toBridgeNFT,
+        };
+        const totalValue = value + BigInt(outMessage.tvmProtocolFee) + BigInt(outMessage.tvmExecutorFee);
+        this.logger.debug(`Total value: ${totalValue}`);
+        const tx = await this.config.TACParams.crossChainLayer
+            .connect(signer)
+            .sendMessage(1n, this.config.artifacts.tac.utils.encodeOutMessageV1(outMessage), { value: totalValue });
+        await tx.wait();
+        this.logger.debug(`Transaction hash: ${tx.hash}`);
+        return tx.hash;
+    }
+}
+exports.TACTransactionManager = TACTransactionManager;

package/dist/sdk/TONTransactionManager.d.ts

@@ -0,0 +1,17 @@
+import { IConfiguration, ILogger, IOperationTracker, ISimulator, ITONTransactionManager } from '../interfaces';
+import type { SenderAbstraction } from '../sender';
+import { CrosschainTx, EvmProxyMsg, OperationIdsByShardsKey, TransactionLinkerWithOperationId, WaitOptions } from '../structs/Struct';
+export declare class TONTransactionManager implements ITONTransactionManager {
+    private readonly config;
+    private readonly simulator;
+    private readonly operationTracker;
+    private readonly logger;
+    constructor(config: IConfiguration, simulator: ISimulator, operationTracker: IOperationTracker, logger?: ILogger);
+    private buildFeeParams;
+    private prepareCrossChainTransaction;
+    private generateCrossChainMessages;
+    sendCrossChainTransaction(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, tx: CrosschainTx, waitOptions?: WaitOptions<string>): Promise<TransactionLinkerWithOperationId>;
+    sendCrossChainTransactions(sender: SenderAbstraction, txs: CrosschainTx[], waitOptions?: WaitOptions<OperationIdsByShardsKey>): Promise<TransactionLinkerWithOperationId[]>;
+    private prepareBatchTransactions;
+    private waitForOperationIds;
+}