@tonappchain/sdk 0.7.0-rc13 → 0.7.0-rc15

package/dist/sdk/Validator.d.ts

@@ -1,6 +1,6 @@
-import { EvmProxyMsg, TACSimulationRequest } from '../structs/Struct';
+import { EvmProxyMsg, TACSimulationParams } from '../structs/Struct';
 export declare class Validator {
-    static validateTACSimulationRequest(req: TACSimulationRequest): void;
+    static validateTACSimulationParams(req: TACSimulationParams): void;
     static validateEVMProxyMsg(evmProxyMsg: EvmProxyMsg): void;
     static validateTVMAddresses(addresses?: string[]): void;
     static validateEVMAddresses(addresses?: string[]): void;

package/dist/sdk/Validator.js

@@ -5,7 +5,7 @@ const ton_1 = require("@ton/ton");
 const ethers_1 = require("ethers");
 const errors_1 = require("../errors");
 class Validator {
-    static validateTACSimulationRequest(req) {
+    static validateTACSimulationParams(req) {
         this.validateEVMAddress(req.tacCallParams.target);
         req.evmValidExecutors?.forEach(this.validateEVMAddress);
         req.tvmValidExecutors?.forEach(this.validateTVMAddress);

package/dist/structs/InternalStruct.d.ts

@@ -2,7 +2,7 @@ import { Cell } from '@ton/ton';
 import { mainnet, testnet } from '@tonappchain/artifacts';
 import { AbstractProvider, ethers } from 'ethers';
 import { ContractOpener } from '../interfaces';
-import { CurrencyType, ExecutionStagesByOperationId, Network, OperationIdsByShardsKey, OperationType, StatusInfosByOperationId, SuggestedTONExecutorFee, TACSimulationResult } from './Struct';
+import { CurrencyType, ExecutionStagesByOperationId, Network, OperationIdsByShardsKey, OperationType, StatusInfosByOperationId, SuggestedTVMExecutorFee, TACSimulationResult } from './Struct';
 export type ShardMessage = {
     address: string;
     value: bigint;
@@ -38,6 +38,7 @@ export type InternalTACParams = {
     crossChainLayer: testnet.tac.wrappers.CrossChainLayerTAC | mainnet.tac.wrappers.CrossChainLayerTAC;
     settings: testnet.tac.wrappers.SettingsTAC | mainnet.tac.wrappers.SettingsTAC;
     tokenUtils: testnet.tac.wrappers.TokenUtilsTAC | mainnet.tac.wrappers.TokenUtilsTAC;
+    smartAccountFactory: testnet.tac.wrappers.TacSAFactoryTAC | mainnet.tac.wrappers.TacSAFactoryTAC;
     trustedTACExecutors: string[];
     trustedTONExecutors: string[];
     abiCoder: ethers.AbiCoder;
@@ -51,7 +52,7 @@ export type StatusesResponse = ResponseBase<StatusInfosByOperationId>;
 export type OperationIdsByShardsKeyResponse = ResponseBase<OperationIdsByShardsKey>;
 export type StageProfilingResponse = ResponseBase<ExecutionStagesByOperationId>;
 export type TACSimulationResponse = ResponseBase<TACSimulationResult>;
-export type SuggestedTONExecutorFeeResponse = ResponseBase<SuggestedTONExecutorFee>;
+export type SuggestedTVMExecutorFeeResponse = ResponseBase<SuggestedTVMExecutorFee>;
 export type ConvertCurrencyResponse = ResponseBase<ConvertedCurrencyRawResult>;
 export interface SendResult {
     success: boolean;
@@ -77,6 +78,9 @@ export type ToncenterTransaction = {
         hash: string;
         opcode: string;
     };
+    outMsgs: {
+        hash: string;
+    }[];
 };
 export type TransactionDepth = {
     hash: string;

package/dist/structs/Struct.d.ts

@@ -1,6 +1,8 @@
-import type { Address, Cell } from '@ton/ton';
-import { AbstractProvider, Addressable } from 'ethers';
+import { Address, Cell, OpenedContract } from '@ton/ton';
+import { AbstractProvider, Addressable, Interface, InterfaceAbi } from 'ethers';
+import type { FT, NFT } from '../assets';
 import type { Asset, ContractOpener, ILogger } from '../interfaces';
+import { JettonMaster, JettonMasterData } from '../wrappers/JettonMaster';
 export type ContractState = {
     balance: bigint;
     state: 'active' | 'uninitialized' | 'frozen';
@@ -41,6 +43,14 @@ export type TACParams = {
      * Address of TAC settings contract. Use only for tests.
      */
     settingsAddress?: string | Addressable;
+    /**
+     * Address of multicall contract. Use only for tests.
+     */
+    multicallAddress?: string | Addressable;
+    /**
+     * ABI of multicall contract. Use only for tests.
+     */
+    multicallABI?: Interface | InterfaceAbi;
 };
 export type TONParams = {
     /**
@@ -107,21 +117,23 @@ export type TransactionLinker = {
 export type TransactionLinkerWithOperationId = TransactionLinker & {
     operationId?: string;
 };
-export type TACSimulationRequest = {
-    tacCallParams: {
-        arguments: string;
-        methodName: string;
-        target: string;
-    };
+export type TONAsset = {
+    amount: string;
+    tokenAddress: string;
+    assetType: AssetType;
+};
+export type TACCallParams = {
+    arguments: string;
+    methodName: string;
+    target: string;
+};
+export type TACSimulationParams = {
+    tacCallParams: TACCallParams;
     evmValidExecutors?: string[];
     tvmValidExecutors?: string[];
     extraData?: string;
     shardsKey: string;
-    tonAssets: {
-        amount: string;
-        tokenAddress: string;
-        assetType: string;
-    }[];
+    tonAssets: TONAsset[];
     tonCaller: string;
     calculateRollbackFee?: boolean;
 };
@@ -259,7 +271,7 @@ export type TACSimulationResult = {
         blockNumber: number;
     };
 };
-export type SuggestedTONExecutorFee = {
+export type SuggestedTVMExecutorFee = {
     inTAC: string;
     inTON: string;
 };
@@ -279,6 +291,8 @@ export type CrossChainTransactionOptions = {
     tvmValidExecutors?: string[];
     tvmExecutorFee?: bigint;
     calculateRollbackFee?: boolean;
+    withoutSimulation?: boolean;
+    validateAssetsBalance?: boolean;
 };
 export type ExecutionFeeEstimationResult = {
     feeParams: FeeParams;
@@ -289,6 +303,25 @@ export type CrosschainTx = {
     assets?: Asset[];
     options?: CrossChainTransactionOptions;
 };
+export type AssetLike = Asset | FT | NFT | {
+    rawAmount: bigint;
+} | {
+    amount: number;
+} | {
+    address: TVMAddress | EVMAddress;
+} | {
+    address: TVMAddress | EVMAddress;
+    rawAmount: bigint;
+} | {
+    address: TVMAddress | EVMAddress;
+    amount: number;
+} | {
+    address: TVMAddress | EVMAddress;
+    itemIndex: bigint;
+};
+export type CrosschainTxWithAssetLike = Omit<CrosschainTx, 'assets'> & {
+    assets?: AssetLike[];
+};
 export type NFTItemData = {
     init: boolean;
     index: number;
@@ -301,7 +334,7 @@ export type NFTCollectionData = {
     content: Cell;
     adminAddress: Address;
 };
-export interface WaitOptions<T = unknown> {
+export interface WaitOptions<T = unknown, TContext = unknown> {
     /**
      * Timeout in milliseconds
      * @default 300000 (5 minutes)
@@ -321,11 +354,21 @@ export interface WaitOptions<T = unknown> {
      * Logger
      */
     logger?: ILogger;
+    /**
+     * Optional context object to pass additional parameters to callbacks
+     * This allows passing custom data like OperationTracker instances, configurations, etc.
+     */
+    context?: TContext;
     /**
      * Function to check if the result is successful
      * If not provided, any non-error result is considered successful
      */
-    successCheck?: (result: T) => boolean;
+    successCheck?: (result: T, context?: TContext) => boolean;
+    /**
+     * Custom callback function that executes when request is successful
+     * Receives both the result and optional context with additional parameters
+     */
+    onSuccess?: (result: T, context?: TContext) => Promise<void> | void;
 }
 export declare const defaultWaitOptions: WaitOptions;
 export declare enum Origin {
@@ -366,3 +409,14 @@ export type ConvertedCurrencyResult = {
     tacPrice: USDPriceInfo;
     tonPrice: USDPriceInfo;
 };
+export type GetTVMExecutorFeeParams = {
+    feeSymbol: string;
+    tonAssets: TONAsset[];
+    tvmValidExecutors: string[];
+};
+export type FTOriginAndData = {
+    origin: Origin;
+    jettonMinter: OpenedContract<JettonMaster>;
+    evmAddress?: string;
+    jettonData?: JettonMasterData;
+};

package/dist/wrappers/Settings.d.ts

@@ -1,4 +1,4 @@
-import type { Cell, Contract, ContractProvider } from '@ton/ton';
+import { Cell, Contract, ContractProvider } from '@ton/ton';
 import { Address } from '@ton/ton';
 export declare class Settings implements Contract {
     static create(address: Address): Settings;
@@ -7,4 +7,8 @@ export declare class Settings implements Contract {
     getKeyFromString(ContractName: string): bigint;
     getAddressSetting(provider: ContractProvider, ContractName: string): Promise<string>;
     getCellSetting(provider: ContractProvider, setting: string): Promise<Cell>;
+    getAll(provider: ContractProvider): Promise<Cell>;
 }
+export declare function getAddressString(cell?: Cell): string;
+export declare function getNumber(len: number, cell?: Cell): number;
+export declare function getString(cell?: Cell): string;

package/dist/wrappers/Settings.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Settings = void 0;
+exports.getAddressString = getAddressString;
+exports.getNumber = getNumber;
+exports.getString = getString;
+const ton_1 = require("@ton/ton");
 const ethers_1 = require("ethers");
 const errors_1 = require("../errors");
 class Settings {
@@ -34,5 +38,18 @@ class Settings {
         }
         return cell;
     }
+    async getAll(provider) {
+        const { stack } = await provider.get('get_all', []);
+        return stack.readCellOpt() ?? (0, ton_1.beginCell)().endCell();
+    }
 }
 exports.Settings = Settings;
+function getAddressString(cell) {
+    return cell?.beginParse().loadAddress().toString({ bounceable: true, testOnly: false }) ?? '';
+}
+function getNumber(len, cell) {
+    return cell?.beginParse().loadUint(len) ?? 0;
+}
+function getString(cell) {
+    return cell?.beginParse().loadStringTail() ?? '';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tonappchain/sdk",
-  "version": "0.7.0-rc13",
+  "version": "0.7.0-rc15",
   "repository": "https://github.com/TacBuild/tac-sdk.git",
   "author": "TAC. <developers@tac>",
   "license": "MIT",
@@ -20,7 +20,8 @@
     "@aws-crypto/sha256-js": "^5.2.0",
     "@orbs-network/ton-access": "^2.3.3",
     "@ton/ton": "15.1.0",
-    "@tonappchain/artifacts": "0.0.19-smart-accounts-4",
+    "@tonappchain/agnostic-sdk": "0.0.9",
+    "@tonappchain/artifacts": "0.0.19-smart-accounts-7",
     "@tonappchain/ton-lite-client": "3.0.6",
     "@tonconnect/ui": "^2.0.11",
     "bn.js": "^5.2.1",
@@ -64,4 +65,4 @@
     }
   },
   "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
-}
+}

package/dist/interfaces/ITransactionManager.d.ts

@@ -1,35 +0,0 @@
-import { Wallet } from 'ethers';
-import type { SenderAbstraction } from '../sender';
-import { CrossChainTransactionOptions, CrosschainTx, EvmProxyMsg, OperationIdsByShardsKey, TransactionLinkerWithOperationId, WaitOptions } from '../structs/Struct';
-import { Asset } from './Asset';
-export interface ITransactionManager {
-    /**
-     * Sends a single cross-chain transaction.
-     * @param evmProxyMsg Encoded EVM proxy message to bridge.
-     * @param sender Sender abstraction for TVM message sending.
-     * @param assets Optional assets to attach to the cross-chain message.
-     * @param options Optional cross-chain execution options (fees, executors, extra data).
-     * @param waitOptions Optional policy to wait for operation id resolution.
-     * @returns Transaction linker with operation id for tracking.
-     */
-    sendCrossChainTransaction(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: Asset[], options?: CrossChainTransactionOptions, waitOptions?: WaitOptions<string>): Promise<TransactionLinkerWithOperationId>;
-    /**
-     * Sends multiple cross-chain transactions in a batch.
-     * @param sender Sender abstraction for TVM message sending.
-     * @param txs List of cross-chain transactions to broadcast.
-     * @param waitOptions Optional policy for waiting on operation ids by shard keys.
-     * @returns Array of transaction linkers, one per submitted transaction.
-     */
-    sendCrossChainTransactions(sender: SenderAbstraction, txs: CrosschainTx[], waitOptions?: WaitOptions<OperationIdsByShardsKey>): Promise<TransactionLinkerWithOperationId[]>;
-    /**
-     * Bridges native EVM value and optional assets to TON chain via executor.
-     * @param signer Ethers Wallet used to sign EVM transaction.
-     * @param value Amount of native EVM currency (wei as bigint).
-     * @param tonTarget Recipient TVM address on TON.
-     * @param assets Optional list of TAC assets to include.
-     * @param tvmExecutorFee Optional explicit TON-side executor fee.
-     * @param tvmValidExecutors Optional whitelist of allowed TVM executors.
-     * @returns EVM transaction hash or bridge identifier.
-     */
-    bridgeTokensToTON(signer: Wallet, value: bigint, tonTarget: string, assets?: Asset[], tvmExecutorFee?: bigint, tvmValidExecutors?: string[]): Promise<string>;
-}

package/dist/sdk/TransactionManager.d.ts

@@ -1,22 +0,0 @@
-import { Cell } from '@ton/ton';
-import { Wallet } from 'ethers';
-import { Asset, IConfiguration, ILogger, IOperationTracker, ISimulator, ITransactionManager } from '../interfaces';
-import type { SenderAbstraction } from '../sender';
-import { CrossChainTransactionOptions, CrosschainTx, EvmProxyMsg, OperationIdsByShardsKey, TransactionLinker, TransactionLinkerWithOperationId, ValidExecutors, WaitOptions } from '../structs/Struct';
-export declare class TransactionManager implements ITransactionManager {
-    private readonly config;
-    private readonly simulator;
-    private readonly operationTracker;
-    private readonly logger;
-    private readonly evmDataCellBuilder;
-    constructor(config: IConfiguration, simulator: ISimulator, operationTracker: IOperationTracker, logger?: ILogger, options?: {
-        evmDataCellBuilder?: (transactionLinker: TransactionLinker, evmProxyMsg: EvmProxyMsg, validExecutors: ValidExecutors) => Cell;
-    });
-    private prepareCrossChainTransaction;
-    private generateCrossChainMessages;
-    sendCrossChainTransaction(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: Asset[], options?: CrossChainTransactionOptions, waitOptions?: WaitOptions<string>): Promise<TransactionLinkerWithOperationId>;
-    sendCrossChainTransactions(sender: SenderAbstraction, txs: CrosschainTx[], waitOptions?: WaitOptions<OperationIdsByShardsKey>): Promise<TransactionLinkerWithOperationId[]>;
-    private prepareCrossChainTransactions;
-    private waitForOperationIds;
-    bridgeTokensToTON(signer: Wallet, value: bigint, tonTarget: string, assets?: Asset[], tvmExecutorFee?: bigint, tvmValidExecutors?: string[]): Promise<string>;
-}

package/dist/sdk/TransactionManager.js

@@ -1,272 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionManager = 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 TransactionManager {
-    constructor(config, simulator, operationTracker, logger = new Logger_1.NoopLogger(), options) {
-        this.config = config;
-        this.simulator = simulator;
-        this.operationTracker = operationTracker;
-        this.logger = logger;
-        this.evmDataCellBuilder = options?.evmDataCellBuilder ?? Utils_1.buildEvmDataCell;
-    }
-    async prepareCrossChainTransaction(evmProxyMsg, caller, assets, options) {
-        this.logger.debug('Preparing cross-chain transaction');
-        const { allowSimulationError = false, isRoundTrip = undefined, protocolFee = undefined, evmExecutorFee = undefined, tvmExecutorFee = undefined, calculateRollbackFee = true, } = options || {};
-        let { evmValidExecutors = [], tvmValidExecutors = [] } = options || {};
-        Validator_1.Validator.validateEVMAddress(evmProxyMsg.evmTargetAddress);
-        Validator_1.Validator.validateEVMAddresses(options?.evmValidExecutors);
-        Validator_1.Validator.validateTVMAddresses(options?.tvmValidExecutors);
-        const aggregatedData = await (0, Utils_1.aggregateTokens)(assets);
-        await Promise.all(aggregatedData.jettons.map((jetton) => jetton.checkCanBeTransferredBy(caller)));
-        await Promise.all(aggregatedData.nfts.map((nft) => nft.checkCanBeTransferredBy(caller)));
-        await aggregatedData.ton?.checkCanBeTransferredBy(caller);
-        const tokensLength = aggregatedData.jettons.length + aggregatedData.nfts.length;
-        this.logger.debug(`Tokens length: ${tokensLength}`);
-        const transactionLinkerShardCount = tokensLength == 0 ? 1 : tokensLength;
-        this.logger.debug(`Transaction linker shard count: ${transactionLinkerShardCount}`);
-        const transactionLinker = (0, Utils_1.generateTransactionLinker)(caller, transactionLinkerShardCount);
-        this.logger.debug(`Generated transaction linker: ${(0, Utils_1.formatObjectForLogging)(transactionLinker)}`);
-        if (evmValidExecutors.length == 0) {
-            evmValidExecutors = this.config.getTrustedTACExecutors;
-        }
-        if (tvmValidExecutors.length == 0) {
-            tvmValidExecutors = this.config.getTrustedTONExecutors;
-        }
-        const { feeParams } = await this.simulator.getSimulationInfoForTransaction(evmProxyMsg, transactionLinker, assets ?? [], allowSimulationError, isRoundTrip, evmValidExecutors, tvmValidExecutors, calculateRollbackFee);
-        if (evmProxyMsg.gasLimit == undefined) {
-            evmProxyMsg.gasLimit = feeParams.gasLimit;
-        }
-        if (evmExecutorFee != undefined) {
-            feeParams.evmExecutorFee = evmExecutorFee;
-        }
-        if (feeParams.isRoundTrip && tvmExecutorFee != undefined) {
-            feeParams.tvmExecutorFee = tvmExecutorFee;
-        }
-        if (protocolFee != undefined) {
-            feeParams.protocolFee = protocolFee;
-        }
-        this.logger.debug(`Resulting fee params: ${(0, Utils_1.formatObjectForLogging)(feeParams)}`);
-        const validExecutors = {
-            tac: evmValidExecutors,
-            ton: tvmValidExecutors,
-        };
-        this.logger.debug(`Valid executors: ${(0, Utils_1.formatObjectForLogging)(validExecutors)}`);
-        const evmData = this.evmDataCellBuilder(transactionLinker, evmProxyMsg, validExecutors);
-        const messages = await this.generateCrossChainMessages(caller, evmData, aggregatedData, feeParams);
-        const transaction = {
-            validUntil: +new Date() + 15 * 60 * 1000,
-            messages,
-            network: this.config.network,
-        };
-        this.logger.debug('Transaction prepared');
-        return { transaction, transactionLinker };
-    }
-    async generateCrossChainMessages(caller, evmData, aggregatedData, feeParams) {
-        this.logger.debug(`Generating cross-chain messages`);
-        const { jettons, nfts, ton = assets_1.TON.create(this.config) } = aggregatedData;
-        let crossChainTonAmount = ton.rawAmount;
-        let feeTonAmount = feeParams.protocolFee + feeParams.evmExecutorFee + feeParams.tvmExecutorFee;
-        this.logger.debug(`Crosschain ton amount: ${crossChainTonAmount}`);
-        this.logger.debug(`Fee ton amount: ${feeTonAmount}`);
-        if (jettons.length == 0 && nfts.length == 0) {
-            return [
-                {
-                    address: this.config.TONParams.crossChainLayerAddress,
-                    value: crossChainTonAmount + feeTonAmount + Consts_1.TRANSACTION_TON_AMOUNT,
-                    payload: await ton.generatePayload({
-                        excessReceiver: caller,
-                        evmData,
-                        feeParams,
-                    }),
-                },
-            ];
-        }
-        const messages = [];
-        let currentFeeParams = feeParams;
-        for (const jetton of aggregatedData.jettons) {
-            const payload = await jetton.generatePayload({
-                excessReceiver: caller,
-                evmData,
-                crossChainTonAmount,
-                forwardFeeTonAmount: feeTonAmount,
-                feeParams: currentFeeParams,
-            });
-            const jettonWalletAddress = await jetton.getUserWalletAddress(caller);
-            messages.push({
-                address: jettonWalletAddress,
-                value: crossChainTonAmount + feeTonAmount + Consts_1.TRANSACTION_TON_AMOUNT,
-                payload,
-            });
-            crossChainTonAmount = 0n;
-            feeTonAmount = 0n;
-            currentFeeParams = undefined;
-        }
-        for (const nft of aggregatedData.nfts) {
-            const payload = await nft.generatePayload({
-                excessReceiver: caller,
-                evmData,
-                crossChainTonAmount,
-                forwardFeeTonAmount: feeTonAmount,
-                feeParams: currentFeeParams,
-            });
-            messages.push({
-                address: nft.address,
-                value: crossChainTonAmount + feeTonAmount + Consts_1.TRANSACTION_TON_AMOUNT,
-                payload,
-            });
-            crossChainTonAmount = 0n;
-            feeTonAmount = 0n;
-            currentFeeParams = undefined;
-        }
-        this.logger.debug('Generating cross-chain messages success');
-        return messages;
-    }
-    async sendCrossChainTransaction(evmProxyMsg, sender, assets, options, waitOptions) {
-        const caller = sender.getSenderAddress();
-        this.logger.debug(`Caller: ${caller}`);
-        const { transaction, transactionLinker } = await this.prepareCrossChainTransaction(evmProxyMsg, caller, assets, options);
-        await assets_1.TON.checkBalance(sender, this.config, [transaction]);
-        this.logger.debug(`*****Sending transaction: ${(0, Utils_1.formatObjectForLogging)(transaction)}`);
-        const sendTransactionResult = await sender.sendShardTransaction(transaction, this.config.network, this.config.TONParams.contractOpener);
-        return waitOptions
-            ? {
-                sendTransactionResult,
-                operationId: await this.operationTracker
-                    .getOperationId(transactionLinker, {
-                    ...waitOptions,
-                    successCheck: (operationId) => !!operationId,
-                    logger: this.logger,
-                })
-                    .catch((error) => {
-                    this.logger.error(`Error while waiting for operation ID: ${error}`);
-                    return undefined;
-                }),
-                ...transactionLinker,
-            }
-            : { sendTransactionResult, ...transactionLinker };
-    }
-    async sendCrossChainTransactions(sender, txs, waitOptions) {
-        const caller = sender.getSenderAddress();
-        this.logger.debug(`Caller: ${caller}`);
-        this.logger.debug('Preparing multiple cross-chain transactions');
-        const { transactions, transactionLinkers } = await this.prepareCrossChainTransactions(txs, caller);
-        await assets_1.TON.checkBalance(sender, this.config, transactions);
-        this.logger.debug(`*****Sending transactions: ${(0, Utils_1.formatObjectForLogging)(transactions)}`);
-        await sender.sendShardTransactions(transactions, this.config.network, this.config.TONParams.contractOpener);
-        if (!waitOptions) {
-            return transactionLinkers;
-        }
-        return await this.waitForOperationIds(transactionLinkers, caller, waitOptions);
-    }
-    async prepareCrossChainTransactions(txs, caller) {
-        const transactions = [];
-        const transactionLinkers = [];
-        for (const { options, assets, evmProxyMsg } of txs) {
-            const { transaction, transactionLinker } = await this.prepareCrossChainTransaction(evmProxyMsg, caller, assets, options);
-            transactions.push(transaction);
-            transactionLinkers.push(transactionLinker);
-        }
-        return { transactions, transactionLinkers };
-    }
-    async waitForOperationIds(transactionLinkers, caller, waitOptions) {
-        this.logger.debug(`Waiting for operation IDs`);
-        try {
-            const operationIds = await this.operationTracker.getOperationIdsByShardsKeys(transactionLinkers.map((linker) => linker.shardsKey), caller, {
-                ...waitOptions,
-                logger: this.logger,
-                successCheck: (operationIds) => Object.keys(operationIds).length == transactionLinkers.length &&
-                    Object.values(operationIds).every((ids) => ids.operationIds.length > 0),
-            });
-            this.logger.debug(`Operation IDs: ${(0, Utils_1.formatObjectForLogging)(operationIds)}`);
-            return transactionLinkers.map((linker) => ({
-                ...linker,
-                operationId: operationIds[linker.shardsKey].operationIds.at(0),
-            }));
-        }
-        catch (error) {
-            this.logger.error(`Error while waiting for operation IDs: ${error}`);
-            return transactionLinkers;
-        }
-    }
-    async bridgeTokensToTON(signer, value, tonTarget, assets, tvmExecutorFee, tvmValidExecutors) {
-        this.logger.debug('Bridging tokens to TON');
-        if (assets == undefined) {
-            assets = [];
-        }
-        const tonAssets = [...assets];
-        if (value > 0n) {
-            tonAssets.push(await (await assets_1.AssetFactory.from(this.config, {
-                address: await this.config.nativeTACAddress(),
-                tokenType: Struct_1.AssetType.FT,
-            })).withAmount({ rawAmount: value }));
-        }
-        Validator_1.Validator.validateTVMAddress(tonTarget);
-        if (tvmExecutorFee == undefined) {
-            const suggestedTONExecutorFee = await this.simulator.getTVMExecutorFeeInfo(tonAssets, Consts_1.TAC_SYMBOL, tvmValidExecutors);
-            this.logger.debug(`Suggested TON executor fee: ${(0, Utils_1.formatObjectForLogging)(suggestedTONExecutorFee)}`);
-            tvmExecutorFee = BigInt(suggestedTONExecutorFee.inTAC);
-        }
-        const crossChainLayerAddress = await this.config.TACParams.crossChainLayer.getAddress();
-        for (const asset of assets) {
-            const evmAddress = await asset.getEVMAddress();
-            if (asset.type == Struct_1.AssetType.FT) {
-                this.logger.debug(`Approving token ${evmAddress} for ${crossChainLayerAddress}`);
-                const tokenContract = this.config.artifacts.tac.wrappers.ERC20FactoryTAC.connect(evmAddress, this.config.TACParams.provider);
-                const tx = await tokenContract.connect(signer).approve(crossChainLayerAddress, asset.rawAmount);
-                await tx.wait();
-                this.logger.debug(`Approved ${evmAddress} for ${crossChainLayerAddress}`);
-            }
-            if (asset.type == Struct_1.AssetType.NFT) {
-                this.logger.debug(`Approving collection ${evmAddress} for ${crossChainLayerAddress}`);
-                const tokenContract = this.config.artifacts.tac.wrappers.ERC721FactoryTAC.connect(evmAddress, this.config.TACParams.provider);
-                const tx = await tokenContract
-                    .connect(signer)
-                    .approve(crossChainLayerAddress, asset.addresses.index);
-                await tx.wait();
-                this.logger.debug(`Approved ${asset.address} for ${crossChainLayerAddress}`);
-            }
-        }
-        const shardsKey = BigInt(Math.round(Math.random() * 1e18));
-        this.logger.debug(`Shards key: ${shardsKey}`);
-        const protocolFee = await this.config.TACParams.crossChainLayer.getProtocolFee();
-        this.logger.debug(`Protocol fee: ${protocolFee}`);
-        const outMessage = {
-            shardsKey: shardsKey,
-            tvmTarget: tonTarget,
-            tvmPayload: '',
-            tvmProtocolFee: protocolFee,
-            tvmExecutorFee: tvmExecutorFee,
-            tvmValidExecutors: this.config.getTrustedTONExecutors,
-            toBridge: await Promise.all(assets
-                .filter((asset) => asset.type === Struct_1.AssetType.FT)
-                .map(async (asset) => ({
-                evmAddress: await asset.getEVMAddress(),
-                amount: asset.rawAmount,
-            }))),
-            toBridgeNFT: await Promise.all(assets
-                .filter((asset) => asset.type === Struct_1.AssetType.NFT)
-                .map(async (asset) => ({
-                evmAddress: await asset.getEVMAddress(),
-                amount: 1n,
-                tokenId: asset.addresses.index,
-            }))),
-        };
-        const encodedOutMessage = this.config.artifacts.tac.utils.encodeOutMessageV1(outMessage);
-        const outMsgVersion = 1n;
-        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(outMsgVersion, encodedOutMessage, { value: totalValue });
-        await tx.wait();
-        this.logger.debug(`Transaction hash: ${tx.hash}`);
-        return tx.hash;
-    }
-}
-exports.TransactionManager = TransactionManager;