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

package/dist/src/sdk/TONTransactionManager.js

@@ -1,209 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TONTransactionManager = void 0;
-const assets_1 = require("../assets");
-const errors_1 = require("../errors");
-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 = await (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, waitOptions) {
-        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 (!waitOptions) {
-            return { sendTransactionResult, ...transactionLinker };
-        }
-        const operationId = await this.operationTracker.getOperationId(transactionLinker, {
-            ...waitOptions,
-            successCheck: (id) => !!id,
-            logger: this.logger,
-        })
-            .catch((error) => {
-            this.logger.error(`Error while waiting for operation ID: ${error}`);
-            return undefined;
-        });
-        return { sendTransactionResult, operationId, ...transactionLinker };
-    }
-    async sendCrossChainTransactions(sender, txs, waitOptions) {
-        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)}`);
-        await sender.sendShardTransactions(transactions, this.config.network, this.config.TONParams.contractOpener);
-        return waitOptions
-            ? await this.waitForOperationIds(transactionLinkers, caller, 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 = await (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 {
-            const operationIds = await this.operationTracker.getOperationIdsByShardsKeys(transactionLinkers.map((linker) => linker.shardsKey), caller, {
-                ...waitOptions,
-                logger: this.logger,
-                successCheck: (operationIds) => Object.keys(operationIds).length == transactionLinkers.length &&
-                    Object.values(operationIds).every((ids) => ids.operationIds.length > 0),
-            });
-            this.logger.debug(`Operation IDs: ${(0, Utils_1.formatObjectForLogging)(operationIds)}`);
-            return transactionLinkers.map((linker) => ({
-                ...linker,
-                operationId: operationIds[linker.shardsKey].operationIds.at(0),
-            }));
-        }
-        catch (error) {
-            this.logger.error(`Error while waiting for operation IDs: ${error}`);
-            return transactionLinkers;
-        }
-    }
-}
-exports.TONTransactionManager = TONTransactionManager;

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

@@ -1,44 +0,0 @@
-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

@@ -1,214 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TacSdk = void 0;
-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;
-        const { dev, testnet, mainnet } = await Promise.resolve().then(() => __importStar(require('../../artifacts')));
-        let artifacts;
-        switch (network) {
-            case Struct_1.Network.MAINNET:
-                artifacts = mainnet;
-                break;
-            case Struct_1.Network.TESTNET:
-                artifacts = testnet;
-                break;
-            case Struct_1.Network.DEV:
-                artifacts = 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;