@tonappchain/sdk 0.7.0-rc14 → 0.7.0-rc15

package/dist/sdk/TacSdk.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TacSdk = void 0;
+const agnostic_sdk_1 = require("@tonappchain/agnostic-sdk");
 const assets_1 = require("../assets");
 const Struct_1 = require("../structs/Struct");
 const Configuration_1 = require("./Configuration");
@@ -41,12 +42,16 @@ const Consts_1 = require("./Consts");
 const Logger_1 = require("./Logger");
 const OperationTracker_1 = require("./OperationTracker");
 const Simulator_1 = require("./Simulator");
-const TransactionManager_1 = require("./TransactionManager");
+const TACTransactionManager_1 = require("./TACTransactionManager");
+const TONTransactionManager_1 = require("./TONTransactionManager");
+const Utils_1 = require("./Utils");
 class TacSdk {
-    constructor(config, simulator, transactionManager) {
+    constructor(config, simulator, tonTransactionManager, tacTransactionManager, operationTracker) {
         this.config = config;
         this.simulator = simulator;
-        this.transactionManager = transactionManager;
+        this.tonTransactionManager = tonTransactionManager;
+        this.tacTransactionManager = tacTransactionManager;
+        this.operationTracker = operationTracker;
     }
     static async create(sdkParams, logger = new Logger_1.NoopLogger()) {
         const network = sdkParams.network;
@@ -54,10 +59,11 @@ class TacSdk {
         const { testnet, mainnet } = await Promise.resolve().then(() => __importStar(require('@tonappchain/artifacts')));
         const artifacts = network === Struct_1.Network.TESTNET ? testnet : mainnet;
         const config = await Configuration_1.Configuration.create(network, artifacts, sdkParams.TONParams, sdkParams.TACParams, sdkParams.customLiteSequencerEndpoints, delay);
-        const simulator = new Simulator_1.Simulator(config, logger);
         const operationTracker = new OperationTracker_1.OperationTracker(network, config.liteSequencerEndpoints);
-        const transactionManager = new TransactionManager_1.TransactionManager(config, simulator, operationTracker, logger);
-        return new TacSdk(config, simulator, transactionManager);
+        const simulator = new Simulator_1.Simulator(config, operationTracker, logger);
+        const tonTransactionManager = new TONTransactionManager_1.TONTransactionManager(config, simulator, operationTracker, logger);
+        const tacTransactionManager = new TACTransactionManager_1.TACTransactionManager(config, operationTracker, logger);
+        return new TacSdk(config, simulator, tonTransactionManager, tacTransactionManager, operationTracker);
     }
     closeConnections() {
         return this.config.closeConnections();
@@ -65,6 +71,13 @@ class TacSdk {
     get nativeTONAddress() {
         return this.config.nativeTONAddress;
     }
+    getAgnosticProxySDK(agnosticProxyAddress, smartAccountFactoryAddress) {
+        return new agnostic_sdk_1.AgnosticProxySDK(smartAccountFactoryAddress ?? this.config.artifacts.TAC_SMART_ACCOUNT_FACTORY_ADDRESS, this.config.TACParams.provider, agnosticProxyAddress ?? this.config.artifacts.AGNOSTIC_PROXY_ADDRESS);
+    }
+    async getSmartAccountAddressForTvmWallet(tvmWallet, applicationAddress) {
+        const bouncedAddress = (0, Utils_1.getBouncedAddress)(tvmWallet);
+        return await this.config.TACParams.smartAccountFactory.getSmartAccountForApplication(bouncedAddress, applicationAddress);
+    }
     async nativeTACAddress() {
         return this.config.nativeTACAddress();
     }
@@ -74,29 +87,45 @@ class TacSdk {
     get getTrustedTONExecutors() {
         return this.config.getTrustedTONExecutors;
     }
-    async getTransactionSimulationInfo(evmProxyMsg, sender, assets) {
-        return this.simulator.getTransactionSimulationInfo(evmProxyMsg, sender, assets);
+    async getSimulationInfo(evmProxyMsg, sender, assets, options) {
+        const normalizedAssets = await (0, Utils_1.normalizeAssets)(this.config, assets);
+        const tx = { evmProxyMsg, assets: normalizedAssets, options };
+        return this.simulator.getSimulationInfo(sender, tx);
     }
     async getTVMExecutorFeeInfo(assets, feeSymbol, tvmValidExecutors) {
-        return this.simulator.getTVMExecutorFeeInfo(assets, feeSymbol, tvmValidExecutors);
+        const normalized = await (0, Utils_1.normalizeAssets)(this.config, assets);
+        const params = {
+            tonAssets: (0, Utils_1.mapAssetsToTonAssets)(normalized),
+            feeSymbol: feeSymbol,
+            tvmValidExecutors: tvmValidExecutors ?? [],
+        };
+        return this.operationTracker.getTVMExecutorFee(params);
     }
-    async sendCrossChainTransaction(evmProxyMsg, sender, assets, options, waitOptions) {
-        return this.transactionManager.sendCrossChainTransaction(evmProxyMsg, sender, assets, options, waitOptions);
+    async sendCrossChainTransaction(evmProxyMsg, sender, assets = [], options, waitOptions) {
+        const normalizedAssets = await (0, Utils_1.normalizeAssets)(this.config, assets);
+        const tx = { evmProxyMsg, assets: normalizedAssets, options };
+        return this.tonTransactionManager.sendCrossChainTransaction(evmProxyMsg, sender, tx, waitOptions);
     }
     async sendCrossChainTransactions(sender, txs, waitOptions) {
-        return this.transactionManager.sendCrossChainTransactions(sender, txs, waitOptions);
+        const normalizedTxs = await Promise.all(txs.map(async (tx) => ({
+            evmProxyMsg: tx.evmProxyMsg,
+            options: tx.options,
+            assets: await (0, Utils_1.normalizeAssets)(this.config, tx.assets),
+        })));
+        return this.tonTransactionManager.sendCrossChainTransactions(sender, normalizedTxs, waitOptions);
     }
     async bridgeTokensToTON(signer, value, tonTarget, assets, tvmExecutorFee, tvmValidExecutors) {
-        return this.transactionManager.bridgeTokensToTON(signer, value, tonTarget, assets, tvmExecutorFee, tvmValidExecutors);
+        const normalizedAssets = await (0, Utils_1.normalizeAssets)(this.config, assets);
+        return this.tacTransactionManager.bridgeTokensToTON(signer, value, tonTarget, normalizedAssets, tvmExecutorFee, tvmValidExecutors);
     }
     async isContractDeployedOnTVM(address) {
         return this.config.isContractDeployedOnTVM(address);
     }
     async simulateTACMessage(req) {
-        return this.simulator.simulateTACMessage(req);
+        return this.operationTracker.simulateTACMessage(req);
     }
     async simulateTransactions(sender, txs) {
-        return this.simulator.simulateTransactions(sender, txs);
+        return this.simulator.getSimulationsInfo(sender, txs);
     }
     async getAsset(args) {
         return await assets_1.AssetFactory.from(this.config, args);
@@ -147,10 +176,11 @@ class TacSdk {
     }
     // Address conversion methods
     async getEVMTokenAddress(tvmTokenAddress) {
-        if (tvmTokenAddress === this.nativeTONAddress || tvmTokenAddress === '') {
-            return assets_1.TON.create(this.config).getEVMAddress();
-        }
-        return assets_1.FT.getEVMAddress(this.config, tvmTokenAddress);
+        const asset = await assets_1.AssetFactory.from(this.config, {
+            address: tvmTokenAddress,
+            tokenType: Struct_1.AssetType.FT,
+        });
+        return asset.getEVMAddress();
     }
     async getTVMTokenAddress(evmTokenAddress) {
         return assets_1.FT.getTVMAddress(this.config, evmTokenAddress);
@@ -168,5 +198,8 @@ class TacSdk {
             return nftCollection.getEVMAddress();
         }
     }
+    getOperationTracker() {
+        return this.operationTracker;
+    }
 }
 exports.TacSdk = TacSdk;

package/dist/sdk/TxFinalizer.d.ts

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

package/dist/sdk/TxFinalizer.js

@@ -1,10 +1,7 @@
 "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 AxiosHttpClient_1 = require("./AxiosHttpClient");
 const Logger_1 = require("./Logger");
 const Utils_1 = require("./Utils");
 const IGNORE_OPCODE = [
@@ -12,9 +9,10 @@ const IGNORE_OPCODE = [
     '0x7362d09c', // Jetton Notify
 ];
 class TonTxFinalizer {
-    constructor(apiConfig, logger = new Logger_1.NoopLogger()) {
+    constructor(apiConfig, logger = new Logger_1.NoopLogger(), httpClient = new AxiosHttpClient_1.AxiosHttpClient()) {
         this.apiConfig = apiConfig;
         this.logger = logger;
+        this.httpClient = httpClient;
     }
     logHashFormats(hash) {
         let hex, base64;
@@ -34,10 +32,9 @@ class TonTxFinalizer {
     // 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, {
+                const response = await this.httpClient.get(url, {
                     headers: {
                         [this.apiConfig.authorization.header]: this.apiConfig.authorization.value,
                     },
@@ -57,6 +54,7 @@ class TonTxFinalizer {
                     console.warn(`Failed to fetch adjacent transactions for ${hash}:`, logMessage);
                 }
             }
+            await (0, Utils_1.sleep)(delay);
         }
         return [];
     }
@@ -91,7 +89,9 @@ class TonTxFinalizer {
                             `action.result_code = ${action.resultCode}`);
                     }
                     if (currentDepth + 1 < maxDepth) {
-                        queue.push({ hash: tx.hash, depth: currentDepth + 1 });
+                        if (tx.outMsgs.length > 0) {
+                            queue.push({ hash: tx.hash, depth: currentDepth + 1 });
+                        }
                     }
                 }
                 else {

package/dist/sdk/Utils.d.ts

@@ -1,9 +1,9 @@
 import { Address, Cell } from '@ton/ton';
 import { AbiCoder } from 'ethers';
-import { FT, NFT, TON } from '../assets';
-import { Asset } from '../interfaces';
+import type { FT, NFT, TON } from '../assets';
+import { Asset, IConfiguration } from '../interfaces';
 import { RandomNumberByTimestamp } from '../structs/InternalStruct';
-import { EvmProxyMsg, FeeParams, TransactionLinker, ValidExecutors, WaitOptions } from '../structs/Struct';
+import { AssetLike, EvmProxyMsg, FeeParams, TONAsset, TransactionLinker, ValidExecutors, WaitOptions } from '../structs/Struct';
 export declare const sleep: (ms: number) => Promise<unknown>;
 export declare function generateRandomNumber(interval: number): number;
 export declare function generateRandomNumberByTimestamp(): RandomNumberByTimestamp;
@@ -17,11 +17,15 @@ export declare const calculateRawAmount: (amount: number, decimals: number) => b
 export declare const calculateAmount: (rawAmount: bigint, decimals: number) => number;
 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 waitUntilSuccess<T, TContext = unknown, A extends unknown[] = unknown[]>(options: WaitOptions<T, TContext> | undefined, operation: (...args: A) => Promise<T>, operationDescription?: string, ...args: A): Promise<T>;
 export declare function formatObjectForLogging(obj: unknown): string;
+export declare function getBouncedAddress(tvmAddress: string): string;
 export declare function aggregateTokens(assets?: Asset[]): Promise<{
     jettons: FT[];
     nfts: NFT[];
     ton?: TON;
 }>;
 export declare function sha256toBigInt(ContractName: string): bigint;
+export declare function mapAssetsToTonAssets(assets: Asset[]): TONAsset[];
+export declare function normalizeAsset(config: IConfiguration, input: AssetLike): Promise<Asset>;
+export declare function normalizeAssets(config: IConfiguration, assets?: AssetLike[]): Promise<Asset[]>;

package/dist/sdk/Utils.js

@@ -10,11 +10,16 @@ exports.generateTransactionLinker = generateTransactionLinker;
 exports.calculateEVMTokenAddress = calculateEVMTokenAddress;
 exports.waitUntilSuccess = waitUntilSuccess;
 exports.formatObjectForLogging = formatObjectForLogging;
+exports.getBouncedAddress = getBouncedAddress;
 exports.aggregateTokens = aggregateTokens;
 exports.sha256toBigInt = sha256toBigInt;
+exports.mapAssetsToTonAssets = mapAssetsToTonAssets;
+exports.normalizeAsset = normalizeAsset;
+exports.normalizeAssets = normalizeAssets;
 const ton_1 = require("@ton/ton");
 const ethers_1 = require("ethers");
 const ton_crypto_1 = require("ton-crypto");
+const assets_1 = require("../assets");
 const errors_1 = require("../errors");
 const Struct_1 = require("../structs/Struct");
 const Consts_1 = require("./Consts");
@@ -133,12 +138,14 @@ const generateFeeData = (feeParams) => {
     }
 };
 exports.generateFeeData = generateFeeData;
-async function waitUntilSuccess(options = {}, operation, ...args) {
+async function waitUntilSuccess(options = {}, operation, operationDescription, ...args) {
     const timeout = options.timeout ?? 300000;
     const maxAttempts = options.maxAttempts ?? 30;
     const delay = options.delay ?? 10000;
     const successCheck = options.successCheck;
-    options.logger?.debug(`Starting wait for success with timeout=${timeout}ms, maxAttempts=${maxAttempts}, delay=${delay}ms`);
+    const context = options.context;
+    const contextPrefix = operationDescription ? `[${operationDescription}] ` : '';
+    options.logger?.debug(`${contextPrefix}Starting wait for success with timeout=${timeout}ms, maxAttempts=${maxAttempts}, delay=${delay}ms`);
     const startTime = Date.now();
     let attempt = 1;
     while (true) {
@@ -146,27 +153,36 @@ async function waitUntilSuccess(options = {}, operation, ...args) {
         const elapsedTime = currentTime - startTime;
         try {
             const result = await operation(...args);
-            if (!result) {
+            if (result === undefined || result === null) {
                 throw new Error(`Empty result`);
             }
-            options.logger?.debug(`Result: ${formatObjectForLogging(result)}`);
-            if (successCheck && !successCheck(result)) {
+            options.logger?.debug(`${contextPrefix}Result: ${formatObjectForLogging(result)}`);
+            if (successCheck && !successCheck(result, context)) {
                 throw new Error(`Result is not successful`);
             }
-            options.logger?.debug(`Attempt ${attempt} successful`);
+            options.logger?.debug(`${contextPrefix}Attempt ${attempt} successful`);
+            // Execute custom onSuccess callback if provided
+            if (options.onSuccess) {
+                try {
+                    await options.onSuccess(result, context);
+                }
+                catch (callbackError) {
+                    options.logger?.warn(`${contextPrefix}onSuccess callback error: ${callbackError}`);
+                }
+            }
             return result;
         }
         catch (error) {
             if (elapsedTime >= timeout) {
-                options.logger?.debug(`Timeout after ${elapsedTime}ms`);
+                options.logger?.debug(`${contextPrefix}Timeout after ${elapsedTime}ms`);
                 throw error;
             }
             if (attempt >= maxAttempts) {
-                options.logger?.debug(`Max attempts (${maxAttempts}) reached`);
+                options.logger?.debug(`${contextPrefix}Max attempts (${maxAttempts}) reached`);
                 throw error;
             }
-            options.logger?.debug(`Error on attempt ${attempt}: ${error}`);
-            options.logger?.debug(`Waiting ${delay}ms before next attempt`);
+            options.logger?.debug(`${contextPrefix}Error on attempt ${attempt}: ${error}`);
+            options.logger?.debug(`${contextPrefix}Waiting ${delay}ms before next attempt`);
             await (0, exports.sleep)(delay);
             attempt++;
         }
@@ -175,6 +191,11 @@ async function waitUntilSuccess(options = {}, operation, ...args) {
 function formatObjectForLogging(obj) {
     return JSON.stringify(obj, (key, value) => (typeof value === 'bigint' ? value.toString() : value));
 }
+function getBouncedAddress(tvmAddress) {
+    return ton_1.Address.parse(tvmAddress).toString({
+        bounceable: true,
+    });
+}
 async function aggregateTokens(assets) {
     const uniqueAssetsMap = new Map();
     let ton;
@@ -182,7 +203,7 @@ async function aggregateTokens(assets) {
         if (asset.type !== Struct_1.AssetType.FT)
             continue;
         if (!asset.address) {
-            ton = ton ? await ton.addAmount({ rawAmount: asset.rawAmount }) : asset.clone;
+            ton = ton ? ton.addRawAmount(asset.rawAmount) : asset.clone;
             continue;
         }
         let jetton = uniqueAssetsMap.get(asset.address);
@@ -190,7 +211,7 @@ async function aggregateTokens(assets) {
             jetton = asset.clone;
         }
         else {
-            jetton = await jetton.addAmount({ rawAmount: asset.rawAmount });
+            jetton = jetton.addRawAmount(asset.rawAmount);
         }
         uniqueAssetsMap.set(asset.address, jetton);
     }
@@ -212,3 +233,50 @@ function sha256toBigInt(ContractName) {
     const hash = (0, ton_crypto_1.sha256_sync)(ContractName);
     return BigInt('0x' + hash.toString('hex'));
 }
+function mapAssetsToTonAssets(assets) {
+    return assets.map((asset) => ({
+        amount: asset.rawAmount.toString(),
+        tokenAddress: asset.address || '',
+        assetType: asset.type,
+    }));
+}
+async function normalizeAsset(config, input) {
+    if (typeof input.generatePayload === 'function') {
+        return input;
+    }
+    const address = 'address' in input && input.address ? input.address : '';
+    if ('itemIndex' in input) {
+        const args = {
+            address,
+            tokenType: Struct_1.AssetType.NFT,
+            addressType: Struct_1.NFTAddressType.COLLECTION,
+            index: BigInt(input.itemIndex),
+        };
+        return await assets_1.AssetFactory.from(config, args);
+    }
+    if ('rawAmount' in input || 'amount' in input) {
+        const ftArgs = {
+            address,
+            tokenType: Struct_1.AssetType.FT,
+        };
+        const asset = await assets_1.AssetFactory.from(config, ftArgs);
+        return 'rawAmount' in input
+            ? asset.withRawAmount(input.rawAmount)
+            : asset.withAmount(input.amount);
+    }
+    const itemArgs = {
+        address,
+        tokenType: Struct_1.AssetType.NFT,
+        addressType: Struct_1.NFTAddressType.ITEM,
+    };
+    return await assets_1.AssetFactory.from(config, itemArgs);
+}
+async function normalizeAssets(config, assets) {
+    if (!assets || assets.length === 0)
+        return [];
+    const normalized = [];
+    for (const a of assets) {
+        normalized.push(await normalizeAsset(config, a));
+    }
+    return normalized;
+}

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tonappchain/sdk",
-  "version": "0.7.0-rc14",
+  "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>;
-}