@tonappchain/sdk 0.7.0-rc24-test-9 → 0.7.0-rc24-test-10

package/dist/src/sdk/TacSdk.d.ts

@@ -0,0 +1,44 @@
+import { Wallet } from 'ethers';
+import { JettonMinterData, NFTItemData } from '../../artifacts/tonTypes';
+import { FT, NFT } from '../assets';
+import { IConfiguration, ILogger, IOperationTracker, ITacSDK } from '../interfaces';
+import type { SenderAbstraction } from '../sender';
+import { AssetFromFTArg, AssetFromNFTCollectionArg, AssetFromNFTItemArg, AssetLike, CrossChainTransactionOptions, CrosschainTx, CrosschainTxWithAssetLike, EVMAddress, EvmProxyMsg, ExecutionFeeEstimationResult, NFTAddressType, OperationIdsByShardsKey, SDKParams, SuggestedTVMExecutorFee, TACSimulationParams, TACSimulationResult, TransactionLinkerWithOperationId, TVMAddress, UserWalletBalanceExtended, WaitOptions } from '../structs/Struct';
+export declare class TacSdk implements ITacSDK {
+    readonly config: IConfiguration;
+    readonly operationTracker: IOperationTracker;
+    private readonly simulator;
+    private readonly tonTransactionManager;
+    private readonly tacTransactionManager;
+    private constructor();
+    static create(sdkParams: SDKParams, logger?: ILogger): Promise<TacSdk>;
+    closeConnections(): unknown;
+    get nativeTONAddress(): string;
+    getSmartAccountAddressForTvmWallet(tvmWallet: string, applicationAddress: string): Promise<string>;
+    nativeTACAddress(): Promise<string>;
+    get getTrustedTACExecutors(): string[];
+    get getTrustedTONExecutors(): string[];
+    getSimulationInfo(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: AssetLike[], options?: CrossChainTransactionOptions): Promise<ExecutionFeeEstimationResult>;
+    getTVMExecutorFeeInfo(assets: AssetLike[], feeSymbol: string, tvmValidExecutors?: string[]): Promise<SuggestedTVMExecutorFee>;
+    sendCrossChainTransaction(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: AssetLike[], options?: CrossChainTransactionOptions, waitOptions?: WaitOptions<string>): Promise<TransactionLinkerWithOperationId>;
+    sendCrossChainTransactions(sender: SenderAbstraction, txs: CrosschainTxWithAssetLike[], waitOptions?: WaitOptions<OperationIdsByShardsKey>): Promise<TransactionLinkerWithOperationId[]>;
+    bridgeTokensToTON(signer: Wallet, value: bigint, tonTarget: string, assets?: AssetLike[], tvmExecutorFee?: bigint, tvmValidExecutors?: string[]): Promise<string>;
+    isContractDeployedOnTVM(address: string): Promise<boolean>;
+    simulateTACMessage(req: TACSimulationParams): Promise<TACSimulationResult>;
+    simulateTransactions(sender: SenderAbstraction, txs: CrosschainTx[]): Promise<ExecutionFeeEstimationResult[]>;
+    getAsset(args: AssetFromFTArg): Promise<FT>;
+    getAsset(args: AssetFromNFTCollectionArg): Promise<NFT>;
+    getAsset(args: AssetFromNFTItemArg): Promise<NFT>;
+    getUserJettonWalletAddress(userAddress: string, tokenAddress: string): Promise<string>;
+    getUserJettonBalance(userAddress: string, tokenAddress: string): Promise<bigint>;
+    getUserJettonBalanceExtended(userAddress: string, tokenAddress: string): Promise<UserWalletBalanceExtended>;
+    getJettonData(itemAddress: TVMAddress): Promise<JettonMinterData>;
+    getFT(address: TVMAddress | EVMAddress): Promise<FT>;
+    getNFTItemData(itemAddress: TVMAddress): Promise<NFTItemData>;
+    getNFT(args: AssetFromNFTCollectionArg | AssetFromNFTItemArg): Promise<NFT>;
+    getEVMTokenAddress(tvmTokenAddress: string): Promise<string>;
+    getTVMTokenAddress(evmTokenAddress: string): Promise<string>;
+    getTVMNFTAddress(evmNFTAddress: string, tokenId?: number | bigint): Promise<string>;
+    getEVMNFTAddress(tvmNFTAddress: string, addressType: NFTAddressType): Promise<string>;
+    getOperationTracker(): IOperationTracker;
+}

package/dist/src/sdk/TacSdk.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TacSdk = void 0;
+const artifacts_1 = require("../../artifacts");
+const assets_1 = require("../assets");
+const Struct_1 = require("../structs/Struct");
+const Configuration_1 = require("./Configuration");
+const Consts_1 = require("./Consts");
+const Logger_1 = require("./Logger");
+const OperationTracker_1 = require("./OperationTracker");
+const Simulator_1 = require("./Simulator");
+const TACTransactionManager_1 = require("./TACTransactionManager");
+const TONTransactionManager_1 = require("./TONTransactionManager");
+const Utils_1 = require("./Utils");
+class TacSdk {
+    constructor(config, simulator, tonTransactionManager, tacTransactionManager, operationTracker) {
+        this.config = config;
+        this.simulator = simulator;
+        this.tonTransactionManager = tonTransactionManager;
+        this.tacTransactionManager = tacTransactionManager;
+        this.operationTracker = operationTracker;
+    }
+    static async create(sdkParams, logger = new Logger_1.NoopLogger()) {
+        const network = sdkParams.network;
+        const delay = sdkParams.delay ?? Consts_1.DEFAULT_DELAY;
+        let artifacts;
+        switch (network) {
+            case Struct_1.Network.MAINNET:
+                artifacts = artifacts_1.mainnet;
+                break;
+            case Struct_1.Network.TESTNET:
+                artifacts = artifacts_1.testnet;
+                break;
+            case Struct_1.Network.DEV:
+                artifacts = artifacts_1.dev;
+                break;
+            default:
+                throw new Error(`Unsupported network: ${network}`);
+        }
+        const config = await Configuration_1.Configuration.create(network, artifacts, sdkParams.TONParams, sdkParams.TACParams, sdkParams.customLiteSequencerEndpoints, delay);
+        const operationTracker = new OperationTracker_1.OperationTracker(network, config.liteSequencerEndpoints);
+        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();
+    }
+    get nativeTONAddress() {
+        return this.config.nativeTONAddress;
+    }
+    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();
+    }
+    get getTrustedTACExecutors() {
+        return this.config.getTrustedTACExecutors;
+    }
+    get getTrustedTONExecutors() {
+        return this.config.getTrustedTONExecutors;
+    }
+    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) {
+        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) {
+        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) {
+        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) {
+        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.operationTracker.simulateTACMessage(req);
+    }
+    async simulateTransactions(sender, txs) {
+        return this.simulator.getSimulationsInfo(sender, txs);
+    }
+    async getAsset(args) {
+        return await assets_1.AssetFactory.from(this.config, args);
+    }
+    // Jetton methods
+    async getUserJettonWalletAddress(userAddress, tokenAddress) {
+        const ft = await assets_1.AssetFactory.from(this.config, {
+            address: tokenAddress,
+            tokenType: Struct_1.AssetType.FT,
+        });
+        return ft.getUserWalletAddress(userAddress);
+    }
+    async getUserJettonBalance(userAddress, tokenAddress) {
+        const ft = await assets_1.AssetFactory.from(this.config, {
+            address: tokenAddress,
+            tokenType: Struct_1.AssetType.FT,
+        });
+        return ft.getUserBalance(userAddress);
+    }
+    async getUserJettonBalanceExtended(userAddress, tokenAddress) {
+        const ft = await assets_1.AssetFactory.from(this.config, {
+            address: tokenAddress,
+            tokenType: Struct_1.AssetType.FT,
+        });
+        return ft.getUserBalanceExtended(userAddress);
+    }
+    async getJettonData(itemAddress) {
+        return assets_1.FT.getJettonData(this.config, itemAddress);
+    }
+    async getFT(address) {
+        return await assets_1.FT.fromAddress(this.config, address);
+    }
+    // NFT methods
+    async getNFTItemData(itemAddress) {
+        return assets_1.NFT.getItemData(this.config, itemAddress);
+    }
+    async getNFT(args) {
+        if ('addressType' in args && args.addressType === Struct_1.NFTAddressType.ITEM) {
+            return assets_1.NFT.fromItem(this.config, args.address);
+        }
+        else {
+            const collectionArgs = args;
+            return assets_1.NFT.fromCollection(this.config, {
+                collection: collectionArgs.address,
+                index: collectionArgs.index,
+            });
+        }
+    }
+    // Address conversion methods
+    async getEVMTokenAddress(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);
+    }
+    async getTVMNFTAddress(evmNFTAddress, tokenId) {
+        return assets_1.NFT.getTVMAddress(this.config, evmNFTAddress, tokenId === undefined ? undefined : BigInt(tokenId));
+    }
+    async getEVMNFTAddress(tvmNFTAddress, addressType) {
+        if (addressType === Struct_1.NFTAddressType.ITEM) {
+            const nft = await assets_1.NFT.fromItem(this.config, tvmNFTAddress);
+            return nft.getEVMAddress();
+        }
+        else {
+            const nftCollection = await assets_1.NFT.fromCollection(this.config, { collection: tvmNFTAddress, index: 0n });
+            return nftCollection.getEVMAddress();
+        }
+    }
+    getOperationTracker() {
+        return this.operationTracker;
+    }
+}
+exports.TacSdk = TacSdk;

package/dist/{sdk → src/sdk}/TxFinalizer.d.ts

@@ -1,9 +1,10 @@
+import { IHttpClient, ILogger } from '../interfaces';
 import { TxFinalizerConfig } from '../structs/InternalStruct';
-import { ILogger } from '../structs/Services';
 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 → src/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 → src/sdk}/Utils.d.ts

@@ -1,10 +1,9 @@
 import { Address, Cell } from '@ton/ton';
 import { AbiCoder } from 'ethers';
-import { FT } from '../assets/FT';
-import { NFT } from '../assets/NFT';
-import { TON } from '../assets/TON';
+import type { FT, NFT, TON } from '../assets';
+import { Asset, IConfiguration } from '../interfaces';
 import { RandomNumberByTimestamp } from '../structs/InternalStruct';
-import { Asset, 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;
@@ -18,10 +17,18 @@ 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[]>;
+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/{sdk → src/sdk}/Utils.js

@@ -10,9 +10,19 @@ 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;
+exports.getAddressString = getAddressString;
+exports.getNumber = getNumber;
+exports.getString = getString;
 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");
@@ -131,12 +141,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) {
@@ -144,27 +156,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++;
         }
@@ -173,14 +194,21 @@ 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;
     for await (const asset of assets ?? []) {
+        if (asset.rawAmount === 0n)
+            continue;
         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);
@@ -188,7 +216,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);
     }
@@ -206,3 +234,66 @@ async function aggregateTokens(assets) {
         ton,
     };
 }
+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);
+    }
+    try {
+        const ftArgs = {
+            address,
+            tokenType: Struct_1.AssetType.FT,
+        };
+        const asset = await assets_1.AssetFactory.from(config, ftArgs);
+        const rawAmount = 'rawAmount' in input ? input.rawAmount : undefined;
+        const amount = 'amount' in input ? input.amount : 0;
+        return rawAmount ? asset.withRawAmount(rawAmount) : asset.withAmount(amount);
+    }
+    catch (e) {
+        console.warn('Failed to normalize FT asset', e);
+    }
+    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;
+}
+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/dist/{sdk → src/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 → src/sdk}/Validator.js

@@ -3,12 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Validator = void 0;
 const ton_1 = require("@ton/ton");
 const ethers_1 = require("ethers");
-const instances_1 = require("../errors/instances");
+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);
+        req.evmValidExecutors?.forEach(this.validateEVMAddress);
+        req.tvmValidExecutors?.forEach(this.validateTVMAddress);
         req.tonAssets.forEach((asset) => {
             // if empty then it's native TON
             if (asset.tokenAddress !== '') {
@@ -31,12 +31,12 @@ class Validator {
             ton_1.Address.parse(address); // will throw on error address
         }
         catch {
-            throw (0, instances_1.tvmAddressError)(address);
+            throw (0, errors_1.tvmAddressError)(address);
         }
     }
     static validateEVMAddress(address) {
         if (!address.startsWith('0x') || !(0, ethers_1.isAddress)(address)) {
-            throw (0, instances_1.evmAddressError)(address);
+            throw (0, errors_1.evmAddressError)(address);
         }
     }
 }

package/dist/{sender → src/sender}/BatchSender.d.ts

@@ -1,8 +1,7 @@
+import type { Asset, ContractOpener, SenderAbstraction } from '../interfaces';
 import type { SendResult, ShardTransaction } from '../structs/InternalStruct';
-import type { Asset, ContractOpener } from '../structs/Struct';
 import { Network } from '../structs/Struct';
 import { HighloadWalletV3 } from '../wrappers/HighloadWalletV3';
-import { SenderAbstraction } from './SenderAbstraction';
 export declare class BatchSender implements SenderAbstraction {
     private wallet;
     private secretKey;

package/dist/{sender → src/sender}/RawSender.d.ts

@@ -1,12 +1,12 @@
+import type { Asset, ContractOpener } from '../interfaces';
+import { SenderAbstraction, WalletInstanse } from '../interfaces';
 import type { SendResult, ShardTransaction } from '../structs/InternalStruct';
-import type { Asset, ContractOpener } from '../structs/Struct';
 import { Network } from '../structs/Struct';
-import { SenderAbstraction, WalletInstance } from './SenderAbstraction';
 export declare class RawSender implements SenderAbstraction {
     private wallet;
     private secretKey;
     private maxBatchSize;
-    constructor(wallet: WalletInstance, secretKey: Buffer, maxBatchSize?: number);
+    constructor(wallet: WalletInstanse, secretKey: Buffer, maxBatchSize?: number);
     getBalanceOf(asset: Asset): Promise<bigint>;
     getBalance(contractOpener: ContractOpener): Promise<bigint>;
     sendShardTransactions(shardTransactions: ShardTransaction[], _chain: Network, contractOpener: ContractOpener): Promise<SendResult[]>;

package/dist/{sender → src/sender}/SenderFactory.d.ts

@@ -1,8 +1,8 @@
 import { WalletContractV2R1, WalletContractV2R2, WalletContractV3R1, WalletContractV3R2, WalletContractV4, WalletContractV5R1 } from '@ton/ton';
 import { TonConnectUI } from '@tonconnect/ui';
+import { SenderAbstraction } from '../interfaces';
 import { Network } from '../structs/Struct';
 import { HighloadWalletV3 } from '../wrappers/HighloadWalletV3';
-import { SenderAbstraction } from './SenderAbstraction';
 export type WalletVersion = 'V2R1' | 'V2R2' | 'V3R1' | 'V3R2' | 'V4' | 'V5R1' | 'HIGHLOAD_V3';
 export declare const wallets: {
     V2R1: typeof WalletContractV2R1;

package/dist/{sender → src/sender}/TonConnectSender.d.ts

@@ -1,7 +1,7 @@
 import { TonConnectUI } from '@tonconnect/ui';
+import { Asset, ContractOpener, SenderAbstraction } from '../interfaces';
 import type { SendResult, ShardTransaction } from '../structs/InternalStruct';
-import { Asset, ContractOpener, Network } from '../structs/Struct';
-import { SenderAbstraction } from './SenderAbstraction';
+import { Network } from '../structs/Struct';
 export declare class TonConnectSender implements SenderAbstraction {
     readonly tonConnect: TonConnectUI;
     constructor(tonConnect: TonConnectUI);

package/dist/{sender → src/sender}/TonConnectSender.js

@@ -4,8 +4,8 @@ exports.TonConnectSender = void 0;
 const ton_1 = require("@ton/ton");
 const protocol_1 = require("@tonconnect/protocol");
 const ui_1 = require("@tonconnect/ui");
+const Utils_1 = require("../sdk/Utils");
 const Struct_1 = require("../structs/Struct");
-const SenderAbstraction_1 = require("./SenderAbstraction");
 const CHUNK_SIZE = 4;
 class TonConnectSender {
     constructor(tonConnect) {
@@ -48,7 +48,7 @@ class TonConnectSender {
                 break; // Stop sending after first error
             }
             if (i + chunkSize < messages.length) {
-                await (0, SenderAbstraction_1.sleep)(1000);
+                await (0, Utils_1.sleep)(1000);
             }
         }
         return responses;

package/dist/{sender → src/sender}/index.d.ts

@@ -1,3 +1,3 @@
+export * from '../interfaces/SenderAbstraction';
 export * from './BatchSender';
-export * from './SenderAbstraction';
 export * from './SenderFactory';

package/dist/{sender → src/sender}/index.js

@@ -14,6 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../interfaces/SenderAbstraction"), exports);
 __exportStar(require("./BatchSender"), exports);
-__exportStar(require("./SenderAbstraction"), exports);
 __exportStar(require("./SenderFactory"), exports);