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

package/dist/sdk/TacSdk.js

@@ -1,867 +1,172 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+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 ton_1 = require("@ton/ton");
-const artifacts_1 = require("@tonappchain/artifacts");
-const wrappers_1 = require("@tonappchain/artifacts/dist/src/ton/wrappers");
-const axios_1 = __importDefault(require("axios"));
-const ethers_1 = require("ethers");
-const errors_1 = require("../errors");
-const instances_1 = require("../errors/instances");
-const retryableContractOpener_1 = require("../adapters/retryableContractOpener");
-// import internal structs
-const InternalStruct_1 = require("../structs/InternalStruct");
-// import structs
+const assets_1 = require("../assets");
 const Struct_1 = require("../structs/Struct");
-// jetton imports
-const JettonMaster_1 = require("../wrappers/JettonMaster");
-const JettonWallet_1 = require("../wrappers/JettonWallet");
-// ton settings
-const Settings_1 = require("../wrappers/Settings");
+const Configuration_1 = require("./Configuration");
 const Consts_1 = require("./Consts");
+const Logger_1 = require("./Logger");
 const OperationTracker_1 = require("./OperationTracker");
-const Utils_1 = require("./Utils");
+const Simulator_1 = require("./Simulator");
+const TransactionManager_1 = require("./TransactionManager");
 class TacSdk {
-    constructor(network, delay, artifacts, TONParams, TACParams, liteSequencerEndpoints, debug) {
-        this.network = network;
-        this.delay = delay;
-        this.artifacts = artifacts;
-        this.TONParams = TONParams;
-        this.TACParams = TACParams;
-        this.liteSequencerEndpoints = liteSequencerEndpoints;
-        this.debug = debug;
-        this.operationTracker = new OperationTracker_1.OperationTracker(network, liteSequencerEndpoints, debug);
+    constructor(config, simulator, transactionManager) {
+        this.config = config;
+        this.simulator = simulator;
+        this.transactionManager = transactionManager;
     }
-    static async create(sdkParams) {
+    static async create(sdkParams, logger = new Logger_1.NoopLogger()) {
         const network = sdkParams.network;
         const delay = sdkParams.delay ?? Consts_1.DEFAULT_DELAY;
-        const artifacts = network === Struct_1.Network.TESTNET ? artifacts_1.testnet : artifacts_1.mainnet;
-        const TONParams = await this.prepareTONParams(delay, artifacts, sdkParams.TONParams);
-        const TACParams = await this.prepareTACParams(artifacts, delay, sdkParams.TACParams);
-        const debug = sdkParams.debug ?? false;
-        const liteSequencerEndpoints = sdkParams.customLiteSequencerEndpoints ??
-            (network === Struct_1.Network.TESTNET
-                ? artifacts_1.testnet.PUBLIC_LITE_SEQUENCER_ENDPOINTS
-                : artifacts_1.mainnet.PUBLIC_LITE_SEQUENCER_ENDPOINTS);
-        return new TacSdk(network, delay, artifacts, TONParams, TACParams, liteSequencerEndpoints, debug);
-    }
-    static async prepareTONParams(delay, artifacts, TONParams) {
-        const contractOpener = TONParams?.contractOpener ?? (await (0, retryableContractOpener_1.createDefaultRetryableOpener)(artifacts));
-        const settingsAddress = TONParams?.settingsAddress ?? artifacts.TON_SETTINGS_ADDRESS;
-        const settings = contractOpener.open(new Settings_1.Settings(ton_1.Address.parse(settingsAddress)));
-        const jettonProxyAddress = await settings.getAddressSetting('JettonProxyAddress');
-        await (0, Utils_1.sleep)(delay * 1000);
-        const crossChainLayerAddress = await settings.getAddressSetting('CrossChainLayerAddress');
-        await (0, Utils_1.sleep)(delay * 1000);
-        const jettonMinterCode = await settings.getCellSetting('JettonMinterCode');
-        await (0, Utils_1.sleep)(delay * 1000);
-        const jettonWalletCode = await settings.getCellSetting('JettonWalletCode');
-        await (0, Utils_1.sleep)(delay * 1000);
-        const nftProxyAddress = await settings.getAddressSetting('NFTProxyAddress');
-        await (0, Utils_1.sleep)(delay * 1000);
-        const nftItemCode = await settings.getCellSetting('NFTItemCode');
-        await (0, Utils_1.sleep)(delay * 1000);
-        const nftCollectionCode = await settings.getCellSetting('NFTCollectionCode');
-        await (0, Utils_1.sleep)(delay * 1000);
-        return {
-            contractOpener,
-            jettonProxyAddress,
-            crossChainLayerAddress,
-            jettonMinterCode,
-            jettonWalletCode,
-            nftProxyAddress,
-            nftItemCode,
-            nftCollectionCode,
-        };
-    }
-    static async prepareTACParams(artifacts, delay, TACParams) {
-        const provider = TACParams?.provider ?? ethers_1.ethers.getDefaultProvider(artifacts.TAC_RPC_ENDPOINT);
-        const settingsAddress = TACParams?.settingsAddress?.toString() ?? artifacts.TAC_SETTINGS_ADDRESS;
-        const settings = artifacts.tac.wrappers.SettingsFactoryTAC.connect(settingsAddress, provider);
-        const crossChainLayerABI = TACParams?.crossChainLayerABI ?? artifacts.tac.compilationArtifacts.CrossChainLayer.abi;
-        const crossChainLayerAddress = await settings.getAddressSetting((0, ethers_1.keccak256)((0, ethers_1.toUtf8Bytes)('CrossChainLayerAddress')));
-        const crossChainLayer = artifacts.tac.wrappers.CrossChainLayerFactoryTAC.connect(crossChainLayerAddress, provider);
-        await (0, Utils_1.sleep)(delay * 1000);
-        const tokenUtilsAddress = await settings.getAddressSetting((0, ethers_1.keccak256)((0, ethers_1.toUtf8Bytes)('TokenUtilsAddress')));
-        const tokenUtils = artifacts.tac.wrappers.TokenUtilsFactoryTAC.connect(tokenUtilsAddress, provider);
-        await (0, Utils_1.sleep)(delay * 1000);
-        const trustedTACExecutors = await settings.getTrustedEVMExecutors();
-        await (0, Utils_1.sleep)(delay * 1000);
-        const trustedTONExecutors = await settings.getTrustedTVMExecutors();
-        const crossChainLayerTokenABI = TACParams?.crossChainLayerTokenABI ?? artifacts.tac.compilationArtifacts.CrossChainLayerToken.abi;
-        const crossChainLayerTokenBytecode = TACParams?.crossChainLayerTokenBytecode ?? artifacts.tac.compilationArtifacts.CrossChainLayerToken.bytecode;
-        const crossChainLayerNFTABI = TACParams?.crossChainLayerNFTABI ?? artifacts.tac.compilationArtifacts.CrossChainLayerNFT.abi;
-        const crossChainLayerNFTBytecode = TACParams?.crossChainLayerNFTBytecode ?? artifacts.tac.compilationArtifacts.CrossChainLayerNFT.bytecode;
-        return {
-            provider,
-            settings,
-            tokenUtils,
-            crossChainLayer,
-            trustedTACExecutors,
-            trustedTONExecutors,
-            abiCoder: new ethers_1.ethers.AbiCoder(),
-            crossChainLayerABI,
-            crossChainLayerTokenABI,
-            crossChainLayerTokenBytecode,
-            crossChainLayerNFTABI,
-            crossChainLayerNFTBytecode,
-        };
+        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);
     }
     closeConnections() {
-        return this.TONParams.contractOpener.closeConnections?.call(this);
+        return this.config.closeConnections();
     }
     get nativeTONAddress() {
-        return 'NONE';
+        return this.config.nativeTONAddress;
     }
     async nativeTACAddress() {
-        return this.TACParams.crossChainLayer.NATIVE_TOKEN_ADDRESS.staticCall();
-    }
-    async getUserJettonWalletAddress(userAddress, tokenAddress) {
-        const jettonMaster = this.TONParams.contractOpener.open(new JettonMaster_1.JettonMaster(ton_1.Address.parse(tokenAddress)));
-        return jettonMaster.getWalletAddress(userAddress);
-    }
-    async getUserJettonBalance(userAddress, tokenAddress) {
-        const jettonMaster = this.TONParams.contractOpener.open(new JettonMaster_1.JettonMaster(ton_1.Address.parse(tokenAddress)));
-        const userJettonWalletAddress = await jettonMaster.getWalletAddress(userAddress);
-        await (0, Utils_1.sleep)(this.delay * 1000);
-        const userJettonWallet = this.TONParams.contractOpener.open(new JettonWallet_1.JettonWallet(ton_1.Address.parse(userJettonWalletAddress)));
-        return userJettonWallet.getJettonBalance();
+        return this.config.nativeTACAddress();
     }
-    async getUserJettonBalanceExtended(userAddress, tokenAddress) {
-        const masterAddress = ton_1.Address.parse(tokenAddress);
-        const masterState = await this.TONParams.contractOpener.getContractState(masterAddress);
-        if (masterState.state !== 'active') {
-            return { exists: false };
-        }
-        await (0, Utils_1.sleep)(this.delay * 1000);
-        const jettonMaster = this.TONParams.contractOpener.open(new JettonMaster_1.JettonMaster(masterAddress));
-        const userJettonWalletAddress = await jettonMaster.getWalletAddress(userAddress);
-        await (0, Utils_1.sleep)(this.delay * 1000);
-        const userJettonWallet = this.TONParams.contractOpener.open(new JettonWallet_1.JettonWallet(ton_1.Address.parse(userJettonWalletAddress)));
-        const rawAmount = await userJettonWallet.getJettonBalance();
-        const decimalsRaw = (await jettonMaster.getJettonData()).content.metadata.decimals;
-        const decimals = decimalsRaw ? Number(decimalsRaw) : 9;
-        return {
-            rawAmount,
-            decimals,
-            amount: (0, Utils_1.calculateAmount)(rawAmount, decimals),
-            exists: true,
-        };
-    }
-    getJettonTransferPayload(jettonData, responseAddress, evmData, crossChainTonAmount, forwardFeeAmount, feeData) {
-        const queryId = (0, Utils_1.generateRandomNumberByTimestamp)().randomNumber;
-        return JettonWallet_1.JettonWallet.transferMessage(jettonData.rawAmount, this.TONParams.jettonProxyAddress, responseAddress, Consts_1.JETTON_TRANSFER_FORWARD_TON_AMOUNT + forwardFeeAmount + crossChainTonAmount, crossChainTonAmount, feeData, evmData, queryId);
-    }
-    getJettonBurnPayload(jettonData, evmData, crossChainTonAmount, feeData) {
-        const queryId = (0, Utils_1.generateRandomNumberByTimestamp)().randomNumber;
-        return JettonWallet_1.JettonWallet.burnMessage(jettonData.rawAmount, jettonData.notificationReceiverAddress, crossChainTonAmount, feeData, evmData, queryId);
-    }
-    getNFTBurnPayload(burnData) {
-        const queryId = (0, Utils_1.generateRandomNumberByTimestamp)().randomNumber;
-        return wrappers_1.NFTItem.burnMessage(queryId, (0, ton_1.address)(burnData.notificationReceiverAddress), burnData.crossChainTonAmount ?? 0, burnData.evmData, burnData.feeData);
-    }
-    getNFTTransferPayload(transferData, forwardFeeAmount) {
-        const queryId = (0, Utils_1.generateRandomNumberByTimestamp)().randomNumber;
-        const crossChainTonAmount = transferData.crossChainTonAmount ?? 0n;
-        const forwardPayload = (0, ton_1.beginCell)()
-            .storeCoins(crossChainTonAmount)
-            .storeMaybeRef(transferData.feeData)
-            .storeMaybeRef(transferData.evmData)
-            .endCell();
-        return wrappers_1.NFTItem.transferMessage(queryId, (0, ton_1.address)(transferData.to ?? this.TONParams.nftProxyAddress), (0, ton_1.address)(transferData.responseAddress), Number((0, ton_1.fromNano)(Consts_1.NFT_TRANSFER_FORWARD_TON_AMOUNT + forwardFeeAmount + crossChainTonAmount)), forwardPayload);
-    }
-    getTonTransferPayload(responseAddress, evmData, crossChainTonAmount, feeParams) {
-        const queryId = (0, Utils_1.generateRandomNumberByTimestamp)().randomNumber;
-        const feeData = (0, Utils_1.generateFeeData)(feeParams);
-        return (0, ton_1.beginCell)()
-            .storeUint(this.artifacts.ton.wrappers.CrossChainLayerOpCodes.anyone_tvmMsgToEVM, 32)
-            .storeUint(queryId, 64)
-            .storeUint(this.artifacts.ton.wrappers.OperationType.tonTransfer, 32)
-            .storeCoins(crossChainTonAmount)
-            .storeMaybeRef(feeData)
-            .storeAddress(ton_1.Address.parse(responseAddress))
-            .storeMaybeRef(evmData)
-            .endCell();
-    }
-    debugLog(message) {
-        if (this.debug) {
-            console.log(`[TacSdk Debug] ${message}`);
-        }
+    get getTrustedTACExecutors() {
+        return this.config.getTrustedTACExecutors;
     }
-    async getJettonOpType(asset) {
-        this.debugLog(`Getting jetton op type for ${(0, Utils_1.formatObjectForLogging)(asset)}`);
-        const { code: givenMinterCodeBOC } = await this.TONParams.contractOpener.getContractState((0, ton_1.address)(asset.address));
-        if (!givenMinterCodeBOC) {
-            throw errors_1.emptyContractError;
-        }
-        const givenMinterCode = ton_1.Cell.fromBoc(givenMinterCodeBOC)[0];
-        await (0, Utils_1.sleep)(this.delay * 1000);
-        if (!this.TONParams.jettonMinterCode.equals(givenMinterCode)) {
-            this.debugLog(`Jetton ${(0, Utils_1.formatObjectForLogging)(asset)} requires JETTON_TRANSFER operation`);
-            return InternalStruct_1.AssetOpType.JETTON_TRANSFER;
-        }
-        const givenMinter = this.TONParams.contractOpener.open(new JettonMaster_1.JettonMaster((0, ton_1.address)(asset.address)));
-        const evmAddress = await givenMinter.getEVMAddress();
-        await (0, Utils_1.sleep)(this.delay * 1000);
-        this.debugLog(`Jetton ${(0, Utils_1.formatObjectForLogging)(asset)} has evm address ${evmAddress}`);
-        const expectedMinterAddress = await (0, Utils_1.calculateContractAddress)(this.TONParams.jettonMinterCode, (0, ton_1.beginCell)()
-            .storeCoins(0)
-            .storeAddress((0, ton_1.address)(this.TONParams.crossChainLayerAddress))
-            .storeAddress(null)
-            .storeRef((0, ton_1.beginCell)().endCell())
-            .storeRef(this.TONParams.jettonWalletCode)
-            .storeStringTail(evmAddress)
-            .endCell());
-        if (!expectedMinterAddress.equals(givenMinter.address)) {
-            this.debugLog(`Jetton ${(0, Utils_1.formatObjectForLogging)(asset)} requires JETTON_TRANSFER operation`);
-            return InternalStruct_1.AssetOpType.JETTON_TRANSFER;
-        }
-        this.debugLog(`Jetton ${(0, Utils_1.formatObjectForLogging)(asset)} requires JETTON_BURN operation`);
-        return InternalStruct_1.AssetOpType.JETTON_BURN;
+    get getTrustedTONExecutors() {
+        return this.config.getTrustedTONExecutors;
     }
-    async getNFTOpType(asset) {
-        this.debugLog(`Getting NFT op type for ${(0, Utils_1.formatObjectForLogging)(asset)}`);
-        const { code: itemCodeBOC } = await this.TONParams.contractOpener.getContractState((0, ton_1.address)(asset.address));
-        if (!itemCodeBOC) {
-            throw errors_1.emptyContractError;
-        }
-        const givenNFTItemCode = ton_1.Cell.fromBoc(itemCodeBOC)[0];
-        await (0, Utils_1.sleep)(this.delay * 1000);
-        if (!this.TONParams.nftItemCode.equals(givenNFTItemCode)) {
-            this.debugLog(`NFT ${(0, Utils_1.formatObjectForLogging)(asset)} requires NFT_TRANSFER operation`);
-            return InternalStruct_1.AssetOpType.NFT_TRANSFER;
-        }
-        this.debugLog(`NFT ${(0, Utils_1.formatObjectForLogging)(asset)} requires NFT_BURN operation`);
-        return InternalStruct_1.AssetOpType.NFT_BURN;
+    async getTransactionSimulationInfo(evmProxyMsg, sender, assets) {
+        return this.simulator.getTransactionSimulationInfo(evmProxyMsg, sender, assets);
     }
-    async getNFTItemAddressTON(collectionAddress, itemIndex) {
-        (0, Utils_1.validateTVMAddress)(collectionAddress);
-        const nftCollection = this.TONParams.contractOpener.open(wrappers_1.NFTCollection.createFromAddress((0, ton_1.address)(collectionAddress)));
-        return (await nftCollection.getNFTAddressByIndex(itemIndex)).toString();
+    async getTVMExecutorFeeInfo(assets, feeSymbol, tvmValidExecutors) {
+        return this.simulator.getTVMExecutorFeeInfo(assets, feeSymbol, tvmValidExecutors);
     }
-    async getNFTItemData(itemAddress) {
-        (0, Utils_1.validateTVMAddress)(itemAddress);
-        const nftItem = this.TONParams.contractOpener.open(wrappers_1.NFTItem.createFromAddress((0, ton_1.address)(itemAddress)));
-        return await nftItem.getNFTData();
+    async sendCrossChainTransaction(evmProxyMsg, sender, assets, options, waitOptions) {
+        return this.transactionManager.sendCrossChainTransaction(evmProxyMsg, sender, assets, options, waitOptions);
     }
-    async aggregateTokens(assets) {
-        this.debugLog(`Aggregating tokens`);
-        const uniqueAssetsMap = new Map();
-        let crossChainTonAmount = 0n;
-        for await (const asset of assets ?? []) {
-            if (asset.rawAmount <= 0)
-                continue;
-            if (asset.type !== Struct_1.AssetType.FT)
-                continue;
-            if (asset.address) {
-                (0, Utils_1.validateTVMAddress)(asset.address);
-                uniqueAssetsMap.set(asset.address, (uniqueAssetsMap.get(asset.address) || 0n) + BigInt(asset.rawAmount));
-            }
-            else {
-                crossChainTonAmount += BigInt(asset.rawAmount);
-            }
-        }
-        const jettons = Array.from(uniqueAssetsMap.entries()).map(([address, rawAmount]) => ({
-            address,
-            rawAmount,
-            type: Struct_1.AssetType.FT,
-        }));
-        this.debugLog(`Aggregated ${jettons.length} jettons`);
-        this.debugLog(`Crosschain ton amount: ${crossChainTonAmount}`);
-        uniqueAssetsMap.clear();
-        for await (const asset of assets ?? []) {
-            if (asset.type !== Struct_1.AssetType.NFT)
-                continue;
-            (0, Utils_1.validateTVMAddress)(asset.address);
-            uniqueAssetsMap.set(asset.address, 1n);
-        }
-        const nfts = Array.from(uniqueAssetsMap.entries()).map(([address, rawAmount]) => ({
-            address,
-            rawAmount,
-            type: Struct_1.AssetType.NFT,
-        }));
-        this.debugLog(`Aggregated ${nfts.length} nfts`);
-        return {
-            jettons,
-            nfts,
-            crossChainTonAmount,
-        };
+    async sendCrossChainTransactions(sender, txs, waitOptions) {
+        return this.transactionManager.sendCrossChainTransactions(sender, txs, waitOptions);
     }
-    async generateJettonPayload(jetton, caller, evmData, crossChainTonAmount, forwardFeeTonAmount, feeParams) {
-        this.debugLog(`Generating jetton payload for ${(0, Utils_1.formatObjectForLogging)(jetton)}`);
-        const opType = await this.getJettonOpType(jetton);
-        await (0, Utils_1.sleep)(this.delay * 1000);
-        this.debugLog(`Generation fee data with params: ${(0, Utils_1.formatObjectForLogging)(feeParams)}`);
-        const feeData = (0, Utils_1.generateFeeData)(feeParams);
-        let payload;
-        switch (opType) {
-            case InternalStruct_1.AssetOpType.JETTON_BURN:
-                payload = this.getJettonBurnPayload({
-                    notificationReceiverAddress: this.TONParams.crossChainLayerAddress,
-                    ...jetton,
-                }, evmData, crossChainTonAmount, feeData);
-                break;
-            case InternalStruct_1.AssetOpType.JETTON_TRANSFER:
-                payload = this.getJettonTransferPayload(jetton, caller, evmData, crossChainTonAmount, forwardFeeTonAmount, feeData);
-                break;
-        }
-        this.debugLog('Generating jetton payload success');
-        return payload;
+    async bridgeTokensToTON(signer, value, tonTarget, assets, tvmExecutorFee, tvmValidExecutors) {
+        return this.transactionManager.bridgeTokensToTON(signer, value, tonTarget, assets, tvmExecutorFee, tvmValidExecutors);
     }
-    async generateNFTPayload(nft, caller, evmData, crossChainTonAmount, forwardFeeTonAmount, feeParams) {
-        this.debugLog(`Generating NFT payload for ${(0, Utils_1.formatObjectForLogging)(nft)}`);
-        const opType = await this.getNFTOpType(nft);
-        await (0, Utils_1.sleep)(this.delay * 1000);
-        this.debugLog(`Generation fee data with params: ${(0, Utils_1.formatObjectForLogging)(feeParams)}`);
-        const feeData = (0, Utils_1.generateFeeData)(feeParams);
-        let payload;
-        switch (opType) {
-            case InternalStruct_1.AssetOpType.NFT_BURN:
-                payload = this.getNFTBurnPayload({
-                    notificationReceiverAddress: this.TONParams.crossChainLayerAddress,
-                    ...nft,
-                    evmData,
-                    crossChainTonAmount,
-                    feeData,
-                });
-                break;
-            case InternalStruct_1.AssetOpType.NFT_TRANSFER:
-                payload = this.getNFTTransferPayload({
-                    to: this.TONParams.nftProxyAddress,
-                    responseAddress: caller,
-                    evmData,
-                    crossChainTonAmount,
-                    feeData,
-                    ...nft,
-                }, forwardFeeTonAmount);
-                break;
-        }
-        this.debugLog('Generating NFT payload success');
-        return payload;
+    async isContractDeployedOnTVM(address) {
+        return this.config.isContractDeployedOnTVM(address);
     }
-    async generateCrossChainMessages(caller, evmData, aggregatedData, feeParams) {
-        this.debugLog(`Generating cross-chain messages`);
-        let crossChainTonAmount = aggregatedData.crossChainTonAmount;
-        let feeTonAmount = feeParams.protocolFee + feeParams.evmExecutorFee + feeParams.tvmExecutorFee;
-        this.debugLog(`Crosschain ton amount: ${crossChainTonAmount}`);
-        this.debugLog(`Fee ton amount: ${feeTonAmount}`);
-        if (aggregatedData.jettons.length == 0 && aggregatedData.nfts.length == 0) {
-            return [
-                {
-                    address: this.TONParams.crossChainLayerAddress,
-                    value: crossChainTonAmount + feeTonAmount + Consts_1.TRANSACTION_TON_AMOUNT,
-                    payload: this.getTonTransferPayload(caller, evmData, crossChainTonAmount, feeParams),
-                },
-            ];
-        }
-        const messages = [];
-        let currentFeeParams = feeParams;
-        for (const jetton of aggregatedData.jettons) {
-            const payload = await this.generateJettonPayload(jetton, caller, evmData, crossChainTonAmount, feeTonAmount, currentFeeParams);
-            await (0, Utils_1.sleep)(this.delay * 1000);
-            const jettonWalletAddress = await this.getUserJettonWalletAddress(caller, jetton.address);
-            await (0, Utils_1.sleep)(this.delay * 1000);
-            messages.push({
-                address: jettonWalletAddress,
-                value: crossChainTonAmount + feeTonAmount + Consts_1.TRANSACTION_TON_AMOUNT,
-                payload,
-            });
-            crossChainTonAmount = 0n;
-            feeTonAmount = 0n;
-            currentFeeParams = undefined;
-        }
-        for (const nft of aggregatedData.nfts) {
-            const payload = await this.generateNFTPayload(nft, caller, evmData, crossChainTonAmount, feeTonAmount, currentFeeParams);
-            await (0, Utils_1.sleep)(this.delay * 1000);
-            messages.push({
-                address: nft.address,
-                value: crossChainTonAmount + feeTonAmount + Consts_1.TRANSACTION_TON_AMOUNT,
-                payload,
-            });
-            crossChainTonAmount = 0n;
-            feeTonAmount = 0n;
-            currentFeeParams = undefined;
-        }
-        this.debugLog('Generating cross-chain messages success');
-        return messages;
+    async simulateTACMessage(req) {
+        return this.simulator.simulateTACMessage(req);
     }
-    async getRawAmount(asset, precalculatedAddress) {
-        this.debugLog(`Getting raw amount for ${(0, Utils_1.formatObjectForLogging)(precalculatedAddress ?? 'TON')}`);
-        if ('rawAmount' in asset) {
-            this.debugLog(`Provided raw amount: ${asset.rawAmount}`);
-            return asset.rawAmount;
-        }
-        if (!precalculatedAddress) {
-            // User specified TON Coin
-            const rawAmount = (0, ton_1.toNano)(asset.amount);
-            this.debugLog(`TON raw amount: ${rawAmount}`);
-            return rawAmount;
-        }
-        if (typeof asset.decimals === 'number') {
-            // User manually set decimals
-            const rawAmount = (0, Utils_1.calculateRawAmount)(asset.amount, asset.decimals);
-            this.debugLog(`Raw amount calculated from decimals: ${rawAmount}`);
-            return rawAmount;
-        }
-        // Get decimals from chain
-        (0, Utils_1.validateTVMAddress)(precalculatedAddress);
-        this.debugLog('Getting decimals from chain');
-        const contract = this.TONParams.contractOpener.open(new JettonMaster_1.JettonMaster((0, ton_1.address)(precalculatedAddress)));
-        const { content } = await contract.getJettonData();
-        await (0, Utils_1.sleep)(this.delay * 1000);
-        if (!content.metadata.decimals) {
-            // if decimals not specified use default value 9
-            this.debugLog('Decimals not specified, using default value 9');
-            return (0, ton_1.toNano)(asset.amount);
-        }
-        const rawAmount = (0, Utils_1.calculateRawAmount)(asset.amount, Number(content.metadata.decimals));
-        this.debugLog(`Raw amount calculated from decimals(${content.metadata.decimals}): ${rawAmount}`);
-        return rawAmount;
+    async simulateTransactions(sender, txs) {
+        return this.simulator.simulateTransactions(sender, txs);
     }
-    async convertAssetsToRawFormat(assets) {
-        this.debugLog(`Converting assets to raw format`);
-        return await Promise.all((assets ?? []).map(async (asset) => {
-            this.debugLog(`Converting asset to raw format: ${(0, Utils_1.formatObjectForLogging)(asset)}`);
-            if (asset.type === Struct_1.AssetType.FT) {
-                const address = (0, ethers_1.isAddress)(asset.address)
-                    ? await this.getTVMTokenAddress(asset.address)
-                    : asset.address;
-                this.debugLog(`Token address on TON: ${address}`);
-                return {
-                    address,
-                    rawAmount: await this.getRawAmount(asset, address),
-                    type: asset.type,
-                };
-            }
-            if (asset.type === Struct_1.AssetType.NFT) {
-                if ('collectionAddress' in asset) {
-                    const address = (0, ethers_1.isAddress)(asset.collectionAddress)
-                        ? await this.getTVMNFTAddress(asset.collectionAddress, asset.itemIndex)
-                        : await this.getNFTItemAddressTON(asset.collectionAddress, asset.itemIndex);
-                    this.debugLog(`NFT address on TON: ${address}`);
-                    await (0, Utils_1.sleep)(this.delay * 1000);
-                    return {
-                        address,
-                        rawAmount: 1n,
-                        type: asset.type,
-                    };
-                }
-                (0, Utils_1.validateTVMAddress)(asset.address);
-                return {
-                    address: asset.address,
-                    rawAmount: 1n,
-                    type: asset.type,
-                };
-            }
-            throw instances_1.invalidAssetType;
-        }));
+    async getAsset(args) {
+        return await assets_1.AssetFactory.from(this.config, args);
     }
-    async getFeeInfo(evmProxyMsg, transactionLinker, rawAssets, forceSend = false, isRoundTrip = true, evmValidExecutors = this.TACParams.trustedTACExecutors, tvmValidExecutors = this.TACParams.trustedTONExecutors) {
-        this.debugLog('Getting fee info');
-        const crossChainLayer = this.TONParams.contractOpener.open(this.artifacts.ton.wrappers.CrossChainLayer.createFromAddress(ton_1.Address.parse(this.TONParams.crossChainLayerAddress)));
-        const fullStateCCL = await crossChainLayer.getFullData();
-        await (0, Utils_1.sleep)(this.delay * 1000);
-        this.debugLog(`Full state CCL: ${(0, Utils_1.formatObjectForLogging)(fullStateCCL)}`);
-        const tacSimulationBody = {
-            tacCallParams: {
-                arguments: evmProxyMsg.encodedParameters ?? '0x',
-                methodName: (0, Utils_1.formatSolidityMethodName)(evmProxyMsg.methodName),
-                target: evmProxyMsg.evmTargetAddress,
-            },
-            evmValidExecutors: evmValidExecutors,
-            tvmValidExecutors: tvmValidExecutors,
-            extraData: '0x',
-            shardsKey: transactionLinker.shardsKey,
-            tonAssets: rawAssets.map((asset) => ({
-                amount: asset.rawAmount.toString(),
-                tokenAddress: asset.address || '',
-                assetType: asset.type,
-            })),
-            tonCaller: transactionLinker.caller,
-        };
-        isRoundTrip = isRoundTrip ?? rawAssets.length != 0;
-        this.debugLog(`Is round trip: ${isRoundTrip}`);
-        const tacSimulationResult = await this.simulateTACMessage(tacSimulationBody);
-        this.debugLog(`TAC simulation ${tacSimulationResult.simulationStatus ? 'success' : 'failed'}`);
-        if (!tacSimulationResult.simulationStatus) {
-            if (forceSend) {
-                this.debugLog('Force send is true, returning fee params');
-                return {
-                    feeParams: {
-                        isRoundTrip,
-                        gasLimit: 0n,
-                        protocolFee: BigInt((0, ton_1.toNano)(fullStateCCL.tacProtocolFee)) +
-                            BigInt(isRoundTrip) * BigInt((0, ton_1.toNano)(fullStateCCL.tonProtocolFee)),
-                        evmExecutorFee: BigInt(tacSimulationResult.suggestedTacExecutionFee),
-                        tvmExecutorFee: BigInt(tacSimulationResult.suggestedTonExecutionFee) * BigInt(isRoundTrip),
-                    },
-                    simulation: tacSimulationResult,
-                };
-            }
-            throw tacSimulationResult;
-        }
-        const protocolFee = BigInt((0, ton_1.toNano)(fullStateCCL.tacProtocolFee)) +
-            BigInt(isRoundTrip) * BigInt((0, ton_1.toNano)(fullStateCCL.tonProtocolFee));
-        const feeParams = {
-            isRoundTrip: isRoundTrip,
-            gasLimit: tacSimulationResult.estimatedGas,
-            protocolFee: protocolFee,
-            evmExecutorFee: BigInt(tacSimulationResult.suggestedTacExecutionFee),
-            tvmExecutorFee: BigInt(tacSimulationResult.suggestedTonExecutionFee) * BigInt(isRoundTrip),
-        };
-        this.debugLog(`Collected fee params: ${(0, Utils_1.formatObjectForLogging)(feeParams)}`);
-        return { feeParams: feeParams, simulation: tacSimulationResult };
+    // 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 getTransactionSimulationInfo(evmProxyMsg, sender, assets) {
-        this.debugLog('Getting transaction simulation info');
-        const rawAssets = await this.convertAssetsToRawFormat(assets);
-        const aggregatedData = await this.aggregateTokens(rawAssets);
-        const transactionLinkerShardCount = aggregatedData.jettons.length == 0 ? 1 : aggregatedData.jettons.length;
-        this.debugLog(`Transaction linker shard count: ${transactionLinkerShardCount}`);
-        const transactionLinker = (0, Utils_1.generateTransactionLinker)(sender.getSenderAddress(), transactionLinkerShardCount);
-        this.debugLog(`Transaction linker: ${(0, Utils_1.formatObjectForLogging)(transactionLinker)}`);
-        return await this.getFeeInfo(evmProxyMsg, transactionLinker, rawAssets);
+    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 getTVMExecutorFeeInfo(assets, feeSymbol) {
-        this.debugLog('Getting TVM executor fee info');
-        const rawAssets = await this.convertAssetsToRawFormat(assets);
-        const requestBody = {
-            tonAssets: rawAssets.map((asset) => ({
-                amount: asset.rawAmount.toString(),
-                tokenAddress: asset.address || '',
-                assetType: asset.type,
-            })),
-            feeSymbol: feeSymbol,
-        };
-        let lastError;
-        for (const endpoint of this.liteSequencerEndpoints) {
-            try {
-                const response = await axios_1.default.post(`${endpoint}/ton/calculator/ton-executor-fee`, requestBody);
-                return response.data.response;
-            }
-            catch (error) {
-                this.debugLog(`Error while calculating tvm executor fee ${endpoint}: ${error}`);
-                lastError = error;
-            }
-        }
-        this.debugLog('Error while calculating tvm executor fee on all endpoints');
-        throw (0, errors_1.simulationError)(lastError);
+    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 prepareCrossChainTransaction(evmProxyMsg, caller, assets, options) {
-        this.debugLog('Preparing cross-chain transaction');
-        const { forceSend = false, isRoundTrip = undefined, protocolFee = undefined, evmExecutorFee = undefined, tvmExecutorFee = undefined, } = options || {};
-        let { evmValidExecutors = [], tvmValidExecutors = [] } = options || {};
-        const rawAssets = await this.convertAssetsToRawFormat(assets);
-        const aggregatedData = await this.aggregateTokens(rawAssets);
-        const tokensLength = aggregatedData.jettons.length + aggregatedData.nfts.length;
-        this.debugLog(`Tokens length: ${tokensLength}`);
-        const transactionLinkerShardCount = tokensLength == 0 ? 1 : tokensLength;
-        this.debugLog(`Transaction linker shard count: ${transactionLinkerShardCount}`);
-        const transactionLinker = (0, Utils_1.generateTransactionLinker)(caller, transactionLinkerShardCount);
-        this.debugLog(`Generated transaction linker: ${(0, Utils_1.formatObjectForLogging)(transactionLinker)}`);
-        if (evmValidExecutors.length == 0) {
-            evmValidExecutors = this.TACParams.trustedTACExecutors;
-        }
-        if (tvmValidExecutors.length == 0) {
-            tvmValidExecutors = this.TACParams.trustedTONExecutors;
-        }
-        const { feeParams } = await this.getFeeInfo(evmProxyMsg, transactionLinker, rawAssets, forceSend, isRoundTrip, evmValidExecutors, tvmValidExecutors);
-        if (evmProxyMsg.gasLimit == undefined) {
-            evmProxyMsg.gasLimit = feeParams.gasLimit;
-        }
-        if (evmExecutorFee != undefined) {
-            feeParams.evmExecutorFee = evmExecutorFee;
-        }
-        if (feeParams.isRoundTrip && tvmExecutorFee != undefined) {
-            feeParams.tvmExecutorFee = tvmExecutorFee;
-        }
-        if (protocolFee != undefined) {
-            feeParams.protocolFee = protocolFee;
-        }
-        this.debugLog(`Resulting fee params: ${(0, Utils_1.formatObjectForLogging)(feeParams)}`);
-        const validExecutors = {
-            tac: evmValidExecutors,
-            ton: tvmValidExecutors,
-        };
-        this.debugLog(`Valid executors: ${(0, Utils_1.formatObjectForLogging)(validExecutors)}`);
-        const evmData = (0, Utils_1.buildEvmDataCell)(transactionLinker, evmProxyMsg, validExecutors);
-        const messages = await this.generateCrossChainMessages(caller, evmData, aggregatedData, feeParams);
-        await (0, Utils_1.sleep)(this.delay * 1000);
-        const transaction = {
-            validUntil: +new Date() + 15 * 60 * 1000,
-            messages,
-            network: this.network,
-        };
-        this.debugLog('Transaction prepared');
-        return { transaction, transactionLinker };
+    async getJettonData(itemAddress) {
+        return assets_1.FT.getJettonData(this.config.TONParams.contractOpener, itemAddress);
     }
-    async sendCrossChainTransaction(evmProxyMsg, sender, assets, options, waitOptions) {
-        const caller = sender.getSenderAddress();
-        this.debugLog(`Caller: ${caller}`);
-        const { transaction, transactionLinker } = await this.prepareCrossChainTransaction(evmProxyMsg, caller, assets, options);
-        this.debugLog(`*****Sending transaction: ${(0, Utils_1.formatObjectForLogging)(transaction)}`);
-        const sendTransactionResult = await sender.sendShardTransaction(transaction, this.delay, this.network, this.TONParams.contractOpener);
-        return waitOptions
-            ? {
-                sendTransactionResult,
-                operationId: await this.operationTracker.getOperationId(transactionLinker, {
-                    ...waitOptions,
-                    successCheck: (operationId) => !!operationId,
-                    log: this.debugLog.bind(this),
-                }),
-                ...transactionLinker,
-            }
-            : { sendTransactionResult, ...transactionLinker };
+    async getFT(address) {
+        return await assets_1.FT.fromAddress(this.config, address);
     }
-    async sendCrossChainTransactions(sender, txs, waitOptions) {
-        const transactions = [];
-        const transactionLinkers = [];
-        const caller = sender.getSenderAddress();
-        this.debugLog(`Caller: ${caller}`);
-        this.debugLog('Preparing multiple cross-chain transactions');
-        for (const { options, assets, evmProxyMsg } of txs) {
-            const { transaction, transactionLinker } = await this.prepareCrossChainTransaction(evmProxyMsg, caller, assets, options);
-            transactions.push(transaction);
-            transactionLinkers.push(transactionLinker);
-        }
-        this.debugLog(`*****Sending transactions: ${(0, Utils_1.formatObjectForLogging)(transactions)}`);
-        await sender.sendShardTransactions(transactions, this.delay, this.network, this.TONParams.contractOpener);
-        if (waitOptions) {
-            this.debugLog(`Waiting for operation IDs`);
-            try {
-                const operationIds = await this.operationTracker.getOperationIdsByShardsKeys(transactionLinkers.map((linker) => linker.shardsKey), caller, {
-                    ...waitOptions,
-                    log: this.debugLog.bind(this),
-                    successCheck: (operationIds) => {
-                        return (Object.keys(operationIds).length == transactionLinkers.length &&
-                            Object.values(operationIds).every((ids) => ids.operationIds.length > 0));
-                    },
-                });
-                this.debugLog(`Operation IDs: ${(0, Utils_1.formatObjectForLogging)(operationIds)}`);
-                return transactionLinkers.map((linker) => ({
-                    ...linker,
-                    operationId: operationIds[linker.shardsKey].operationIds.at(0),
-                }));
-            }
-            catch (error) {
-                this.debugLog(`Error while waiting for operation IDs: ${error}`);
-            }
-        }
-        return transactionLinkers;
+    // NFT methods
+    async getNFTItemData(itemAddress) {
+        return assets_1.NFT.getItemData(this.config.TONParams.contractOpener, itemAddress);
     }
-    // TODO move to sdk.TAC, sdk.TON
-    async bridgeTokensToTON(signer, value, tonTarget, assets, tvmExecutorFee) {
-        this.debugLog('Bridging tokens to TON');
-        if (assets == undefined) {
-            assets = [];
+    async getNFT(args) {
+        if ('addressType' in args && args.addressType === Struct_1.NFTAddressType.ITEM) {
+            return assets_1.NFT.fromItem(this.config, args.address);
         }
-        const tonAssets = [];
-        for (const asset of assets) {
-            if (asset.type == Struct_1.AssetType.FT) {
-                const tvmAddress = await this.getTVMTokenAddress(asset.address);
-                tonAssets.push({
-                    address: tvmAddress,
-                    rawAmount: asset.rawAmount,
-                    type: Struct_1.AssetType.FT,
-                });
-            }
-            else {
-                const nftItemAddress = await this.getTVMNFTAddress(asset.collectionAddress, asset.itemIndex);
-                tonAssets.push({
-                    address: nftItemAddress,
-                    amount: 1,
-                    type: Struct_1.AssetType.NFT,
-                });
-            }
-        }
-        this.debugLog(`TON assets: ${(0, Utils_1.formatObjectForLogging)(tonAssets)}`);
-        if (value > 0) {
-            this.debugLog('Adding native TAC to TON assets');
-            const tvmAddress = await this.getTVMTokenAddress(await this.nativeTACAddress());
-            tonAssets.push({
-                address: tvmAddress,
-                rawAmount: value,
-                type: Struct_1.AssetType.FT,
+        else {
+            const collectionArgs = args;
+            return assets_1.NFT.fromCollection(this.config, {
+                collection: collectionArgs.address,
+                index: collectionArgs.index,
             });
         }
-        const suggestedTONExecutorFee = await this.getTVMExecutorFeeInfo(tonAssets, Consts_1.TAC_SYMBOL);
-        this.debugLog(`Suggested TON executor fee: ${(0, Utils_1.formatObjectForLogging)(suggestedTONExecutorFee)}`);
-        const crossChainLayerAddress = await this.TACParams.crossChainLayer.getAddress();
-        for (const asset of assets) {
-            if (asset.type == Struct_1.AssetType.FT) {
-                this.debugLog(`Approving token ${asset.address} for ${crossChainLayerAddress}`);
-                const tokenContract = this.artifacts.tac.wrappers.ERC20FactoryTAC.connect(asset.address, this.TACParams.provider);
-                const tx = await tokenContract.connect(signer).approve(crossChainLayerAddress, asset.rawAmount);
-                await tx.wait();
-                this.debugLog(`Approved ${asset.address} for ${crossChainLayerAddress}`);
-            }
-            if (asset.type == Struct_1.AssetType.NFT) {
-                this.debugLog(`Approving collection ${asset.collectionAddress} for ${crossChainLayerAddress}`);
-                const tokenContract = this.artifacts.tac.wrappers.ERC721FactoryTAC.connect(asset.collectionAddress, this.TACParams.provider);
-                const tx = await tokenContract.connect(signer).approve(crossChainLayerAddress, asset.itemIndex);
-                await tx.wait();
-                this.debugLog(`Approved ${asset.collectionAddress} for ${crossChainLayerAddress}`);
-            }
-        }
-        const shardsKey = BigInt(Math.round(Math.random() * 1e18));
-        this.debugLog(`Shards key: ${shardsKey}`);
-        const protocolFee = await this.TACParams.crossChainLayer.getProtocolFee();
-        this.debugLog(`Protocol fee: ${protocolFee}`);
-        const outMessage = {
-            shardsKey: shardsKey,
-            tvmTarget: tonTarget,
-            tvmPayload: '',
-            tvmProtocolFee: protocolFee,
-            tvmExecutorFee: tvmExecutorFee ?? BigInt(suggestedTONExecutorFee.inTAC),
-            tvmValidExecutors: this.TACParams.trustedTONExecutors,
-            toBridge: assets
-                .filter((asset) => asset.type === Struct_1.AssetType.FT)
-                .map((asset) => ({
-                evmAddress: asset.address,
-                amount: asset.rawAmount,
-            })),
-            toBridgeNFT: assets
-                .filter((asset) => asset.type === Struct_1.AssetType.NFT)
-                .map((asset) => ({
-                evmAddress: asset.collectionAddress,
-                amount: 1n,
-                tokenId: asset.itemIndex,
-            })),
-        };
-        const encodedOutMessage = this.artifacts.tac.utils.encodeOutMessageV1(outMessage);
-        const outMsgVersion = 1n;
-        const totalValue = value + BigInt(outMessage.tvmProtocolFee) + BigInt(outMessage.tvmExecutorFee);
-        this.debugLog(`Total value: ${totalValue}`);
-        const tx = await this.TACParams.crossChainLayer
-            .connect(signer)
-            .sendMessage(outMsgVersion, encodedOutMessage, { value: totalValue });
-        await tx.wait();
-        this.debugLog(`Transaction hash: ${tx.hash}`);
-        return tx.hash;
-    }
-    get getTrustedTACExecutors() {
-        return this.TACParams.trustedTACExecutors;
-    }
-    get getTrustedTONExecutors() {
-        return this.TACParams.trustedTONExecutors;
     }
+    // Address conversion methods
     async getEVMTokenAddress(tvmTokenAddress) {
-        this.debugLog(`Getting EVM token address for ${tvmTokenAddress}`);
-        if (tvmTokenAddress !== this.nativeTONAddress) {
-            (0, Utils_1.validateTVMAddress)(tvmTokenAddress);
-            tvmTokenAddress = ton_1.Address.parse(tvmTokenAddress).toString({ bounceable: true });
-            const { code: givenMinterCodeBOC } = await this.TONParams.contractOpener.getContractState((0, ton_1.address)(tvmTokenAddress));
-            await (0, Utils_1.sleep)(this.delay * 1000);
-            if (givenMinterCodeBOC && this.TONParams.jettonMinterCode.equals(ton_1.Cell.fromBoc(givenMinterCodeBOC)[0])) {
-                this.debugLog(`Computing EVM token address using jetton minter`);
-                const givenMinter = this.TONParams.contractOpener.open(new JettonMaster_1.JettonMaster((0, ton_1.address)(tvmTokenAddress)));
-                const evmAddress = await givenMinter.getEVMAddress();
-                await (0, Utils_1.sleep)(this.delay * 1000);
-                return evmAddress;
-            }
+        if (tvmTokenAddress === this.nativeTONAddress || tvmTokenAddress === '') {
+            return assets_1.TON.create(this.config).getEVMAddress();
         }
-        this.debugLog(`Computing EVM token address using token utils`);
-        return this.TACParams.tokenUtils.computeAddress(tvmTokenAddress);
+        return assets_1.FT.getEVMAddress(this.config, tvmTokenAddress);
     }
     async getTVMTokenAddress(evmTokenAddress) {
-        this.debugLog(`Getting TVM token address for ${evmTokenAddress}`);
-        (0, Utils_1.validateEVMAddress)(evmTokenAddress);
-        const exists = await this.TACParams.tokenUtils['exists(address)'](evmTokenAddress);
-        if (exists) {
-            this.debugLog(`Getting TVM token address using cross chain layer ERC20 factory`);
-            const erc721Token = this.artifacts.tac.wrappers.CrossChainLayerERC20FactoryTAC.connect(evmTokenAddress, this.TACParams.provider);
-            const info = await erc721Token.getInfo();
-            return info.tvmAddress;
-        }
-        this.debugLog(`Getting TVM token address using jetton minter`);
-        const jettonMaster = JettonMaster_1.JettonMaster.createFromConfig({
-            evmTokenAddress,
-            crossChainLayerAddress: (0, ton_1.address)(this.TONParams.crossChainLayerAddress),
-            code: this.TONParams.jettonMinterCode,
-            walletCode: this.TONParams.jettonWalletCode,
-        });
-        return jettonMaster.address.toString();
+        return assets_1.FT.getTVMAddress(this.config, evmTokenAddress);
     }
     async getTVMNFTAddress(evmNFTAddress, tokenId) {
-        this.debugLog(`Getting TVM NFT ${tokenId ? `item ${tokenId}` : 'collection'} address for ${evmNFTAddress}`);
-        (0, Utils_1.validateEVMAddress)(evmNFTAddress);
-        let nftCollection;
-        const exists = await this.TACParams.tokenUtils['exists(address)'](evmNFTAddress);
-        if (exists) {
-            this.debugLog(`Getting TVM NFT address using cross chain layer ERC721 factory`);
-            const erc721Token = this.artifacts.tac.wrappers.CrossChainLayerERC721FactoryTAC.connect(evmNFTAddress, this.TACParams.provider);
-            const info = await erc721Token.getInfo();
-            nftCollection = this.TONParams.contractOpener.open(wrappers_1.NFTCollection.createFromAddress((0, ton_1.address)(info.tvmAddress)));
-            return tokenId == undefined
-                ? nftCollection.address.toString()
-                : (await nftCollection.getNFTAddressByIndex(tokenId)).toString();
-        }
-        else {
-            this.debugLog(`Getting TVM NFT address using TON NFT collection contract`);
-            nftCollection = this.TONParams.contractOpener.open(wrappers_1.NFTCollection.createFromConfig({
-                adminAddress: (0, ton_1.address)(this.TONParams.crossChainLayerAddress),
-                newAdminAddress: null,
-                collectionContent: (0, ton_1.beginCell)().endCell(),
-                commonContent: (0, ton_1.beginCell)().endCell(),
-                nftItemCode: this.TONParams.nftItemCode,
-                originalAddress: evmNFTAddress,
-            }, this.TONParams.nftCollectionCode));
-            return tokenId == undefined
-                ? nftCollection.address.toString()
-                : wrappers_1.NFTItem.createFromConfig({
-                    collectionAddress: nftCollection.address,
-                    cclAddress: (0, ton_1.address)(this.TONParams.crossChainLayerAddress),
-                    // @ts-expect-error // bigint can be used, wrapper is not typed properly
-                    index: tokenId,
-                }, this.TONParams.nftItemCode).address.toString();
-        }
+        return assets_1.NFT.getTVMAddress(this.config, evmNFTAddress, tokenId === undefined ? undefined : BigInt(tokenId));
     }
     async getEVMNFTAddress(tvmNFTAddress, addressType) {
-        this.debugLog(`Getting EVM NFT address for ${tvmNFTAddress}`);
-        (0, Utils_1.validateTVMAddress)(tvmNFTAddress);
-        tvmNFTAddress = ton_1.Address.parse(tvmNFTAddress).toString({ bounceable: true });
-        if (addressType == Struct_1.NFTAddressType.ITEM) {
-            this.debugLog(`Retrieving collection address for item ${tvmNFTAddress}`);
-            tvmNFTAddress = (await this.getNFTItemData(tvmNFTAddress)).collectionAddress.toString();
-            this.debugLog(`Collection address: ${tvmNFTAddress}`);
-            addressType = Struct_1.NFTAddressType.COLLECTION;
-            await (0, Utils_1.sleep)(this.delay * 1000);
-        }
-        const { code: givenNFTCollection } = await this.TONParams.contractOpener.getContractState((0, ton_1.address)(tvmNFTAddress));
-        await (0, Utils_1.sleep)(this.delay * 1000);
-        if (givenNFTCollection && this.TONParams.nftCollectionCode.equals(ton_1.Cell.fromBoc(givenNFTCollection)[0])) {
-            this.debugLog(`Getting EVM NFT address using TON NFT collection contract`);
-            const nftCollection = this.TONParams.contractOpener.open(wrappers_1.NFTCollection.createFromAddress((0, ton_1.address)(tvmNFTAddress)));
-            const evmAddress = await nftCollection.getOriginalAddress();
-            await (0, Utils_1.sleep)(this.delay * 1000);
-            return evmAddress.toString();
+        if (addressType === Struct_1.NFTAddressType.ITEM) {
+            const nft = await assets_1.NFT.fromItem(this.config, tvmNFTAddress);
+            return nft.getEVMAddress();
         }
-        this.debugLog(`Computing EVM NFT address using token utils`);
-        return this.TACParams.tokenUtils.computeAddressERC721(tvmNFTAddress);
-    }
-    async isContractDeployedOnTVM(address) {
-        return (await this.TONParams.contractOpener.getContractState(ton_1.Address.parse(address))).state === 'active';
-    }
-    async simulateTACMessage(req) {
-        this.debugLog('Simulating TAC message');
-        let lastError;
-        for (const endpoint of this.liteSequencerEndpoints) {
-            try {
-                const response = await axios_1.default.post(new URL('tac/simulator/simulate-message', endpoint).toString(), req, {
-                    transformResponse: [Utils_1.toCamelCaseTransformer],
-                });
-                this.debugLog('TAC message simulation success');
-                return response.data.response;
-            }
-            catch (error) {
-                this.debugLog(`Error while simulating with ${endpoint}: ${error}`);
-                lastError = error;
-            }
+        else {
+            const nftCollection = await assets_1.NFT.fromCollection(this.config, { collection: tvmNFTAddress, index: 0n });
+            return nftCollection.getEVMAddress();
         }
-        throw (0, errors_1.simulationError)(lastError);
     }
 }
 exports.TacSdk = TacSdk;