@tonappchain/sdk 0.6.6-mainnet-alpha → 0.7.0-rc10

package/dist/sdk/TransactionManager.d.ts

@@ -0,0 +1,22 @@
+import { Cell } from '@ton/ton';
+import { Wallet } from 'ethers';
+import type { ISender } from '../sender';
+import { IConfiguration, ILogger, IOperationTracker, ISimulator, ITransactionManager } from '../interfaces';
+import { IAsset, 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: ISender, assets?: IAsset[], options?: CrossChainTransactionOptions, waitOptions?: WaitOptions<string>): Promise<TransactionLinkerWithOperationId>;
+    sendCrossChainTransactions(sender: ISender, txs: CrosschainTx[], waitOptions?: WaitOptions<OperationIdsByShardsKey>): Promise<TransactionLinkerWithOperationId[]>;
+    private prepareCrossChainTransactions;
+    private waitForOperationIds;
+    bridgeTokensToTON(signer: Wallet, value: bigint, tonTarget: string, assets?: IAsset[], tvmExecutorFee?: bigint, tvmValidExecutors?: string[]): Promise<string>;
+}

package/dist/sdk/TransactionManager.js

@@ -0,0 +1,272 @@
+"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;

package/dist/sdk/TxFinalizer.d.ts

@@ -0,0 +1,10 @@
+import { TxFinalizerConfig } from '../structs/InternalStruct';
+import { ILogger } from '../interfaces';
+export declare class TonTxFinalizer {
+    private logger;
+    private apiConfig;
+    constructor(apiConfig: TxFinalizerConfig, logger?: ILogger);
+    private logHashFormats;
+    private fetchAdjacentTransactions;
+    trackTransactionTree(hash: string, maxDepth?: number): Promise<void>;
+}

package/dist/sdk/TxFinalizer.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TonTxFinalizer = void 0;
+const axios_1 = __importDefault(require("axios"));
+const Logger_1 = require("./Logger");
+const Utils_1 = require("./Utils");
+const IGNORE_OPCODE = [
+    '0xd53276db', // Excess
+    '0x7362d09c', // Jetton Notify
+];
+class TonTxFinalizer {
+    constructor(apiConfig, logger = new Logger_1.NoopLogger()) {
+        this.apiConfig = apiConfig;
+        this.logger = logger;
+    }
+    logHashFormats(hash) {
+        let hex, base64;
+        if (hash.startsWith('0x')) {
+            hex = hash;
+            const cleanHex = hex.slice(2);
+            const buffer = Buffer.from(cleanHex, 'hex');
+            base64 = buffer.toString('base64');
+        }
+        else {
+            base64 = hash;
+            const buffer = Buffer.from(base64, 'base64');
+            hex = '0x' + buffer.toString('hex');
+        }
+        return { hex: hex, base64: base64 };
+    }
+    // Fetches adjacent transactions from toncenter
+    async fetchAdjacentTransactions(hash, retries = 5, delay = 1000) {
+        for (let i = retries; i >= 0; i--) {
+            await (0, Utils_1.sleep)(delay);
+            try {
+                const url = this.apiConfig.urlBuilder(hash);
+                const response = await axios_1.default.get(url, {
+                    headers: {
+                        [this.apiConfig.authorization.header]: this.apiConfig.authorization.value,
+                    },
+                    transformResponse: [Utils_1.toCamelCaseTransformer],
+                });
+                return response.data.transactions || [];
+            }
+            catch (error) {
+                const errorMessage = error.message;
+                // Rate limit error (429) - retry
+                if (errorMessage.includes('429')) {
+                    continue;
+                }
+                // Log all errors except 404 Not Found
+                if (!errorMessage.includes('404')) {
+                    const logMessage = error instanceof Error ? error.message : error;
+                    console.warn(`Failed to fetch adjacent transactions for ${hash}:`, logMessage);
+                }
+            }
+        }
+        return [];
+    }
+    // Checks if all transactions in the tree are successful
+    async trackTransactionTree(hash, maxDepth = 10) {
+        const visitedHashes = new Set();
+        const queue = [{ hash, depth: 0 }];
+        while (queue.length > 0) {
+            const { hash: currentHash, depth: currentDepth } = queue.shift();
+            if (visitedHashes.has(currentHash)) {
+                continue;
+            }
+            visitedHashes.add(currentHash);
+            this.logger.debug(`Checking hash (depth ${currentDepth}):\nhex: ${this.logHashFormats(currentHash).hex}\nbase64: ${this.logHashFormats(currentHash).base64}`);
+            const transactions = await this.fetchAdjacentTransactions(currentHash);
+            if (transactions.length === 0)
+                continue;
+            for (const tx of transactions) {
+                if (!IGNORE_OPCODE.includes(tx.inMsg.opcode) && tx.inMsg.opcode !== null) {
+                    const { aborted, computePh: compute_ph, action } = tx.description;
+                    if (aborted ||
+                        !compute_ph.success ||
+                        !action.success ||
+                        compute_ph.exitCode !== 0 ||
+                        action.resultCode !== 0) {
+                        throw new Error(`Transaction failed:\n` +
+                            `hash = ${currentHash}, ` +
+                            `aborted = ${aborted}, ` +
+                            `compute_ph.success = ${compute_ph.success}, ` +
+                            `compute_ph.exit_code = ${compute_ph.exitCode}, ` +
+                            `action.success = ${action.success}, ` +
+                            `action.result_code = ${action.resultCode}`);
+                    }
+                    if (currentDepth + 1 < maxDepth) {
+                        queue.push({ hash: tx.hash, depth: currentDepth + 1 });
+                    }
+                }
+                else {
+                    this.logger.debug(`Skipping hash (depth ${currentDepth}):\nhex: ${this.logHashFormats(tx.hash).hex}\nbase64: ${this.logHashFormats(tx.hash).base64}`);
+                }
+            }
+        }
+    }
+}
+exports.TonTxFinalizer = TonTxFinalizer;

package/dist/sdk/Utils.d.ts

@@ -1,6 +1,8 @@
 import { Address, Cell } from '@ton/ton';
 import { AbiCoder } from 'ethers';
+import { FT, NFT, TON } from '../assets';
 import { RandomNumberByTimestamp } from '../structs/InternalStruct';
+import { IAsset } from '../interfaces';
 import { EvmProxyMsg, FeeParams, TransactionLinker, ValidExecutors, WaitOptions } from '../structs/Struct';
 export declare const sleep: (ms: number) => Promise<unknown>;
 export declare function generateRandomNumber(interval: number): number;
@@ -9,8 +11,6 @@ export declare function calculateContractAddress(code: Cell, data: Cell): Promis
 export declare function buildEvmDataCell(transactionLinker: TransactionLinker, evmProxyMsg: EvmProxyMsg, validExecutors: ValidExecutors): Cell;
 export declare function formatSolidityMethodName(methodName?: string): string;
 export declare function generateTransactionLinker(caller: string, shardCount: number): TransactionLinker;
-export declare function validateTVMAddress(address: string): void;
-export declare function validateEVMAddress(address: string): void;
 export declare function calculateEVMTokenAddress(abiCoder: AbiCoder, tokenUtilsAddress: string, crossChainLayerTokenBytecode: string, crossChainLayerAddress: string, tvmAddress: string): string;
 export declare const convertKeysToCamelCase: <T>(data: T) => T;
 export declare const calculateRawAmount: (amount: number, decimals: number) => bigint;
@@ -19,3 +19,8 @@ export declare const toCamelCaseTransformer: (data: string) => any;
 export declare const generateFeeData: (feeParams?: FeeParams) => Cell | undefined;
 export declare function waitUntilSuccess<T, A extends unknown[]>(options: WaitOptions<T> | undefined, operation: (...args: A) => Promise<T>, ...args: A): Promise<T>;
 export declare function formatObjectForLogging(obj: unknown): string;
+export declare function aggregateTokens(assets?: IAsset[]): Promise<{
+    jettons: FT[];
+    nfts: NFT[];
+    ton?: TON;
+}>;

package/dist/sdk/Utils.js

@@ -7,14 +7,14 @@ exports.calculateContractAddress = calculateContractAddress;
 exports.buildEvmDataCell = buildEvmDataCell;
 exports.formatSolidityMethodName = formatSolidityMethodName;
 exports.generateTransactionLinker = generateTransactionLinker;
-exports.validateTVMAddress = validateTVMAddress;
-exports.validateEVMAddress = validateEVMAddress;
 exports.calculateEVMTokenAddress = calculateEVMTokenAddress;
 exports.waitUntilSuccess = waitUntilSuccess;
 exports.formatObjectForLogging = formatObjectForLogging;
+exports.aggregateTokens = aggregateTokens;
 const ton_1 = require("@ton/ton");
 const ethers_1 = require("ethers");
 const errors_1 = require("../errors");
+const Struct_1 = require("../structs/Struct");
 const Consts_1 = require("./Consts");
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 exports.sleep = sleep;
@@ -67,19 +67,6 @@ function generateTransactionLinker(caller, shardCount) {
         timestamp: random.timestamp,
     };
 }
-function validateTVMAddress(address) {
-    try {
-        ton_1.Address.parse(address); // will throw on error address
-    }
-    catch {
-        throw (0, errors_1.tvmAddressError)(address);
-    }
-}
-function validateEVMAddress(address) {
-    if (!(0, ethers_1.isAddress)(address)) {
-        throw (0, errors_1.evmAddressError)(address);
-    }
-}
 function calculateEVMTokenAddress(abiCoder, tokenUtilsAddress, crossChainLayerTokenBytecode, crossChainLayerAddress, tvmAddress) {
     const salt = ethers_1.ethers.keccak256(ethers_1.ethers.solidityPacked(['string'], [tvmAddress]));
     const initCode = ethers_1.ethers.solidityPacked(['bytes', 'bytes'], [crossChainLayerTokenBytecode, abiCoder.encode(['address'], [crossChainLayerAddress])]);
@@ -149,8 +136,7 @@ async function waitUntilSuccess(options = {}, operation, ...args) {
     const maxAttempts = options.maxAttempts ?? 30;
     const delay = options.delay ?? 10000;
     const successCheck = options.successCheck;
-    const log = options.log ?? (() => { });
-    log(`Starting wait for success with timeout=${timeout}ms, maxAttempts=${maxAttempts}, delay=${delay}ms`);
+    options.logger?.debug(`Starting wait for success with timeout=${timeout}ms, maxAttempts=${maxAttempts}, delay=${delay}ms`);
     const startTime = Date.now();
     let attempt = 1;
     while (true) {
@@ -161,29 +147,62 @@ async function waitUntilSuccess(options = {}, operation, ...args) {
             if (!result) {
                 throw new Error(`Empty result`);
             }
-            log(`Result: ${formatObjectForLogging(result)}`);
+            options.logger?.debug(`Result: ${formatObjectForLogging(result)}`);
             if (successCheck && !successCheck(result)) {
                 throw new Error(`Result is not successful`);
             }
-            log(`Attempt ${attempt} successful`);
+            options.logger?.debug(`Attempt ${attempt} successful`);
             return result;
         }
         catch (error) {
             if (elapsedTime >= timeout) {
-                log(`Timeout after ${elapsedTime}ms`);
+                options.logger?.debug(`Timeout after ${elapsedTime}ms`);
                 throw error;
             }
             if (attempt >= maxAttempts) {
-                log(`Max attempts (${maxAttempts}) reached`);
+                options.logger?.debug(`Max attempts (${maxAttempts}) reached`);
                 throw error;
             }
-            log(`Error on attempt ${attempt}: ${error}`);
-            log(`Waiting ${delay}ms before next attempt`);
+            options.logger?.debug(`Error on attempt ${attempt}: ${error}`);
+            options.logger?.debug(`Waiting ${delay}ms before next attempt`);
             await (0, exports.sleep)(delay);
             attempt++;
         }
     }
 }
 function formatObjectForLogging(obj) {
-    return JSON.stringify(obj, (key, value) => typeof value === 'bigint' ? value.toString() : value);
+    return JSON.stringify(obj, (key, value) => (typeof value === 'bigint' ? value.toString() : value));
+}
+async function aggregateTokens(assets) {
+    const uniqueAssetsMap = new Map();
+    let ton;
+    for await (const asset of assets ?? []) {
+        if (asset.type !== Struct_1.AssetType.FT)
+            continue;
+        if (!asset.address) {
+            ton = ton ? await ton.addAmount({ rawAmount: asset.rawAmount }) : asset.clone;
+            continue;
+        }
+        let jetton = uniqueAssetsMap.get(asset.address);
+        if (!jetton) {
+            jetton = asset.clone;
+        }
+        else {
+            jetton = await jetton.addAmount({ rawAmount: asset.rawAmount });
+        }
+        uniqueAssetsMap.set(asset.address, jetton);
+    }
+    const jettons = Array.from(uniqueAssetsMap.values());
+    uniqueAssetsMap.clear();
+    for await (const asset of assets ?? []) {
+        if (asset.type !== Struct_1.AssetType.NFT)
+            continue;
+        uniqueAssetsMap.set(asset.address, asset.clone);
+    }
+    const nfts = Array.from(uniqueAssetsMap.values());
+    return {
+        jettons,
+        nfts,
+        ton,
+    };
 }

package/dist/sdk/Validator.d.ts

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

package/dist/sdk/Validator.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validator = void 0;
+const ton_1 = require("@ton/ton");
+const ethers_1 = require("ethers");
+const errors_1 = require("../errors");
+class Validator {
+    static validateTACSimulationRequest(req) {
+        this.validateEVMAddress(req.tacCallParams.target);
+        req.evmValidExecutors?.forEach(this.validateEVMAddress);
+        req.tvmValidExecutors?.forEach(this.validateTVMAddress);
+        req.tonAssets.forEach((asset) => {
+            // if empty then it's native TON
+            if (asset.tokenAddress !== '') {
+                this.validateTVMAddress(asset.tokenAddress);
+            }
+        });
+        this.validateTVMAddress(req.tonCaller);
+    }
+    static validateEVMProxyMsg(evmProxyMsg) {
+        this.validateEVMAddress(evmProxyMsg.evmTargetAddress);
+    }
+    static validateTVMAddresses(addresses) {
+        addresses?.forEach(this.validateTVMAddress);
+    }
+    static validateEVMAddresses(addresses) {
+        addresses?.forEach(this.validateEVMAddress);
+    }
+    static validateTVMAddress(address) {
+        try {
+            ton_1.Address.parse(address); // will throw on error address
+        }
+        catch {
+            throw (0, errors_1.tvmAddressError)(address);
+        }
+    }
+    static validateEVMAddress(address) {
+        if (!address.startsWith('0x') || !(0, ethers_1.isAddress)(address)) {
+            throw (0, errors_1.evmAddressError)(address);
+        }
+    }
+}
+exports.Validator = Validator;

package/dist/sender/BatchSender.d.ts

@@ -1,15 +1,17 @@
-import type { ContractOpener } from '../structs/Struct';
 import type { SendResult, ShardTransaction } from '../structs/InternalStruct';
+import type { IAsset, IContractOpener, ISender } from '../interfaces';
 import { Network } from '../structs/Struct';
-import { SenderAbstraction } from './SenderAbstraction';
 import { HighloadWalletV3 } from '../wrappers/HighloadWalletV3';
-export declare class BatchSender implements SenderAbstraction {
+export declare class BatchSender implements ISender {
     private wallet;
     private secretKey;
+    private lastCreatedAt;
     constructor(wallet: HighloadWalletV3, secretKey: Buffer);
-    sendShardTransactions(shardTransactions: ShardTransaction[], delay: number, _chain: Network, contractOpener: ContractOpener): Promise<SendResult[]>;
+    getBalanceOf(asset: IAsset): Promise<bigint>;
+    getBalance(contractOpener: IContractOpener): Promise<bigint>;
+    sendShardTransactions(shardTransactions: ShardTransaction[], _chain: Network, contractOpener: IContractOpener): Promise<SendResult[]>;
     private prepareGroups;
     private sendGroup;
     getSenderAddress(): string;
-    sendShardTransaction(shardTransaction: ShardTransaction, delay: number, _chain: Network, contractOpener: ContractOpener): Promise<SendResult>;
+    sendShardTransaction(shardTransaction: ShardTransaction, _chain: Network, contractOpener: IContractOpener): Promise<SendResult>;
 }