@tonappchain/sdk 0.7.0-rc9 → 0.7.1

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

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

package/dist/src/sdk/TONTransactionManager.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TONTransactionManager = void 0;
+const assets_1 = require("../assets");
+const errors_1 = require("../errors");
+const instances_1 = require("../errors/instances");
+const Consts_1 = require("./Consts");
+const Logger_1 = require("./Logger");
+const Utils_1 = require("./Utils");
+const Validator_1 = require("./Validator");
+class TONTransactionManager {
+    constructor(config, simulator, operationTracker, logger = new Logger_1.NoopLogger()) {
+        this.config = config;
+        this.simulator = simulator;
+        this.operationTracker = operationTracker;
+        this.logger = logger;
+    }
+    async buildFeeParams(options, evmProxyMsg, sender, tx) {
+        const { withoutSimulation, protocolFee, evmExecutorFee, tvmExecutorFee, isRoundTrip } = options;
+        if (withoutSimulation) {
+            if (protocolFee === undefined || evmExecutorFee === undefined) {
+                throw errors_1.missingFeeParamsError;
+            }
+            if (isRoundTrip && tvmExecutorFee === undefined) {
+                throw errors_1.missingTvmExecutorFeeError;
+            }
+            if (!evmProxyMsg.gasLimit) {
+                throw errors_1.missingGasLimitError;
+            }
+            return {
+                protocolFee,
+                evmExecutorFee,
+                tvmExecutorFee: tvmExecutorFee || 0n,
+                gasLimit: evmProxyMsg.gasLimit,
+                isRoundTrip: isRoundTrip || false,
+            };
+        }
+        const simulationResult = await this.simulator.getSimulationInfo(sender, tx);
+        if (!evmProxyMsg.gasLimit)
+            evmProxyMsg.gasLimit = simulationResult.feeParams.gasLimit;
+        return {
+            protocolFee: protocolFee ?? simulationResult.feeParams.protocolFee,
+            evmExecutorFee: evmExecutorFee ?? simulationResult.feeParams.evmExecutorFee,
+            tvmExecutorFee: simulationResult.feeParams.isRoundTrip && tvmExecutorFee !== undefined
+                ? tvmExecutorFee
+                : simulationResult.feeParams.tvmExecutorFee,
+            gasLimit: evmProxyMsg.gasLimit ?? simulationResult.feeParams.gasLimit,
+            isRoundTrip: isRoundTrip ?? simulationResult.feeParams.isRoundTrip,
+        };
+    }
+    async prepareCrossChainTransaction(evmProxyMsg, sender, assets, options, skipAssetsBalanceValidation = false) {
+        this.logger.debug('Preparing cross-chain transaction');
+        const caller = sender.getSenderAddress();
+        const { allowSimulationError = false, isRoundTrip = undefined, calculateRollbackFee = true, validateAssetsBalance = true, } = options || {};
+        const { evmValidExecutors = [], tvmValidExecutors = [] } = options || {};
+        Validator_1.Validator.validateEVMAddress(evmProxyMsg.evmTargetAddress);
+        const aggregatedData = (0, Utils_1.aggregateTokens)(assets);
+        Validator_1.Validator.validateEVMAddresses(evmValidExecutors);
+        Validator_1.Validator.validateTVMAddresses(tvmValidExecutors);
+        const shouldValidateAssets = validateAssetsBalance && !skipAssetsBalanceValidation;
+        if (shouldValidateAssets) {
+            await Promise.all([
+                ...aggregatedData.jettons.map((jetton) => jetton.checkCanBeTransferredBy(caller)),
+                ...aggregatedData.nfts.map((nft) => nft.checkCanBeTransferredBy(caller)),
+                aggregatedData.ton?.checkCanBeTransferredBy(caller),
+            ].filter(Boolean));
+        }
+        const tokensLength = aggregatedData.jettons.length + aggregatedData.nfts.length;
+        const transactionLinker = (0, Utils_1.generateTransactionLinker)(caller, tokensLength || 1);
+        this.logger.debug(`Generated transaction linker: ${(0, Utils_1.formatObjectForLogging)(transactionLinker)}`);
+        const tacExecutors = evmValidExecutors.length ? evmValidExecutors : this.config.getTrustedTACExecutors;
+        const tonExecutors = tvmValidExecutors.length ? tvmValidExecutors : this.config.getTrustedTONExecutors;
+        const tx = {
+            evmProxyMsg,
+            assets: assets ?? [],
+            options: {
+                allowSimulationError,
+                isRoundTrip,
+                evmValidExecutors: tacExecutors,
+                tvmValidExecutors: tonExecutors,
+                calculateRollbackFee,
+            },
+        };
+        const feeParams = await this.buildFeeParams(options || {}, evmProxyMsg, sender, tx);
+        this.logger.debug(`Resulting fee params: ${(0, Utils_1.formatObjectForLogging)(feeParams)}`);
+        const validExecutors = {
+            tac: tacExecutors,
+            ton: tonExecutors,
+        };
+        const evmData = (0, Utils_1.buildEvmDataCell)(transactionLinker, evmProxyMsg, validExecutors);
+        const messages = await this.generateCrossChainMessages(caller, evmData, aggregatedData, feeParams);
+        return {
+            transaction: {
+                validUntil: Date.now() + Consts_1.FIFTEEN_MINUTES,
+                messages,
+                network: this.config.network,
+            },
+            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;
+        const totalAssets = [...jettons, ...nfts];
+        let crossChainTonAmount = ton.rawAmount;
+        let feeTonAmount = feeParams.protocolFee + feeParams.evmExecutorFee + feeParams.tvmExecutorFee;
+        this.logger.debug(`Crosschain ton amount: ${crossChainTonAmount}, Fee ton amount: ${feeTonAmount}`);
+        if (!totalAssets.length) {
+            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 asset of totalAssets) {
+            const payload = await asset.generatePayload({
+                excessReceiver: caller,
+                evmData,
+                crossChainTonAmount,
+                forwardFeeTonAmount: feeTonAmount,
+                feeParams: currentFeeParams,
+            });
+            const address = asset instanceof assets_1.FT ? await asset.getUserWalletAddress(caller) : asset.address;
+            messages.push({
+                address,
+                value: crossChainTonAmount + feeTonAmount + Consts_1.TRANSACTION_TON_AMOUNT,
+                payload,
+            });
+            crossChainTonAmount = 0n;
+            feeTonAmount = 0n;
+            currentFeeParams = undefined;
+        }
+        this.logger.debug('Cross-chain messages generated successfully');
+        return messages;
+    }
+    async sendCrossChainTransaction(evmProxyMsg, sender, tx) {
+        const { transaction, transactionLinker } = await this.prepareCrossChainTransaction(evmProxyMsg, sender, tx.assets, tx.options);
+        await assets_1.TON.checkBalance(sender, this.config, [transaction]);
+        this.logger.debug(`Sending transaction: ${(0, Utils_1.formatObjectForLogging)(transactionLinker)}`);
+        const sendTransactionResult = await sender.sendShardTransaction(transaction, this.config.network, this.config.TONParams.contractOpener);
+        if (!sendTransactionResult.success || sendTransactionResult.error) {
+            throw (0, instances_1.sendCrossChainTransactionFailedError)(sendTransactionResult.error?.message ?? 'Transaction failed to send');
+        }
+        const shouldWaitForOperationId = tx.options?.waitOperationId ?? true;
+        if (!shouldWaitForOperationId) {
+            return { sendTransactionResult, ...transactionLinker };
+        }
+        const waitOptions = tx.options?.waitOptions ?? {};
+        waitOptions.successCheck = waitOptions.successCheck ?? ((id) => !!id);
+        waitOptions.logger = waitOptions.logger ?? this.logger;
+        const operationId = await this.operationTracker
+            .getOperationId(transactionLinker, waitOptions)
+            .catch((error) => {
+            this.logger.error(`Error while waiting for operation ID: ${error}`);
+            return undefined;
+        });
+        return { sendTransactionResult, operationId, ...transactionLinker };
+    }
+    async sendCrossChainTransactions(sender, txs, options) {
+        const caller = sender.getSenderAddress();
+        this.logger.debug(`Preparing ${txs.length} cross-chain transactions for ${caller}`);
+        const { transactions, transactionLinkers } = await this.prepareBatchTransactions(txs, sender);
+        await assets_1.TON.checkBalance(sender, this.config, transactions);
+        this.logger.debug(`Sending transactions: ${(0, Utils_1.formatObjectForLogging)(transactionLinkers)}`);
+        const results = await sender.sendShardTransactions(transactions, this.config.network, this.config.TONParams.contractOpener);
+        for (const result of results) {
+            if (!result.success || result.error) {
+                throw (0, instances_1.sendCrossChainTransactionFailedError)(result.error?.message ?? 'Transaction failed to send');
+            }
+        }
+        const shouldWaitForOperationIds = options?.waitOperationIds ?? true;
+        return shouldWaitForOperationIds
+            ? await this.waitForOperationIds(transactionLinkers, caller, options?.waitOptions ?? {})
+            : transactionLinkers;
+    }
+    async prepareBatchTransactions(txs, sender) {
+        const caller = sender.getSenderAddress();
+        const txsRequiringValidation = txs.filter((tx) => tx.options?.validateAssetsBalance ?? true);
+        if (txsRequiringValidation.length) {
+            // Aggregate only assets from txs that require validation and validate once per unique asset
+            const assetsToValidate = txsRequiringValidation.flatMap((tx) => tx.assets ?? []);
+            const aggregatedData = (0, Utils_1.aggregateTokens)(assetsToValidate);
+            await Promise.all([
+                ...aggregatedData.jettons.map((jetton) => jetton.checkCanBeTransferredBy(caller)),
+                ...aggregatedData.nfts.map((nft) => nft.checkCanBeTransferredBy(caller)),
+                aggregatedData.ton?.checkCanBeTransferredBy(caller),
+            ].filter(Boolean));
+        }
+        const results = await Promise.all(txs.map(({ evmProxyMsg, assets, options }) => this.prepareCrossChainTransaction(evmProxyMsg, sender, assets, options, true)));
+        return {
+            transactions: results.map((r) => r.transaction),
+            transactionLinkers: results.map((r) => r.transactionLinker),
+        };
+    }
+    async waitForOperationIds(transactionLinkers, caller, waitOptions) {
+        this.logger.debug(`Waiting for operation IDs`);
+        try {
+            waitOptions.successCheck =
+                waitOptions.successCheck ??
+                    ((operationIds) => Object.keys(operationIds).length == transactionLinkers.length &&
+                        Object.values(operationIds).every((ids) => ids.operationIds.length > 0));
+            waitOptions.logger = waitOptions.logger ?? this.logger;
+            const operationIds = await this.operationTracker.getOperationIdsByShardsKeys(transactionLinkers.map((linker) => linker.shardsKey), caller, waitOptions);
+            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;
+        }
+    }
+}
+exports.TONTransactionManager = TONTransactionManager;

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, BatchCrossChainTxWithAssetLike, CrossChainTransactionOptions, CrossChainTransactionsOptions, CrosschainTx, EVMAddress, EvmProxyMsg, ExecutionFeeEstimationResult, NFTAddressType, SDKParams, SuggestedTVMExecutorFee, TACSimulationParams, TACSimulationResult, TransactionLinkerWithOperationId, TVMAddress, UserWalletBalanceExtended } 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): Promise<TransactionLinkerWithOperationId>;
+    sendCrossChainTransactions(sender: SenderAbstraction, txs: BatchCrossChainTxWithAssetLike[], options?: CrossChainTransactionsOptions): 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) {
+        const normalizedAssets = await (0, Utils_1.normalizeAssets)(this.config, assets);
+        const tx = { evmProxyMsg, assets: normalizedAssets, options };
+        return this.tonTransactionManager.sendCrossChainTransaction(evmProxyMsg, sender, tx);
+    }
+    async sendCrossChainTransactions(sender, txs, options) {
+        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, options);
+    }
+    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,
                     },
@@ -49,6 +46,9 @@ class TonTxFinalizer {
                 const errorMessage = error.message;
                 // Rate limit error (429) - retry
                 if (errorMessage.includes('429')) {
+                    if (i > 0) {
+                        await (0, Utils_1.sleep)(delay);
+                    }
                     continue;
                 }
                 // Log all errors except 404 Not Found
@@ -56,6 +56,9 @@ class TonTxFinalizer {
                     const logMessage = error instanceof Error ? error.message : error;
                     console.warn(`Failed to fetch adjacent transactions for ${hash}:`, logMessage);
                 }
+                if (i > 0) {
+                    await (0, Utils_1.sleep)(delay);
+                }
             }
         }
         return [];
@@ -91,7 +94,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 aggregateTokens(assets?: Asset[]): Promise<{
+export declare function getBouncedAddress(tvmAddress: string): string;
+export declare function aggregateTokens(assets?: Asset[]): {
     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;