@tonappchain/sdk 0.6.4 → 0.7.0-rc6

package/dist/sdk/TacSdk.js

@@ -1,749 +1,101 @@
 "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 axios_1 = __importDefault(require("axios"));
-const ton_1 = require("@ton/ton");
-const ethers_1 = require("ethers");
-// import structs
 const Struct_1 = require("../structs/Struct");
-// import internal structs
-const InternalStruct_1 = require("../structs/InternalStruct");
-// 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 Utils_1 = require("./Utils");
-const artifacts_1 = require("@tonappchain/artifacts");
-const errors_1 = require("../errors");
-const wrappers_1 = require("@tonappchain/artifacts/dist/src/ton/wrappers");
-const instances_1 = require("../errors/instances");
+const Logger_1 = require("./Logger");
+const OperationTracker_1 = require("./OperationTracker");
+const Simulator_1 = require("./Simulator");
+const TransactionManager_1 = require("./TransactionManager");
 class TacSdk {
-    constructor(network, delay, artifacts, TONParams, TACParams, liteSequencerEndpoints) {
-        this.network = network;
-        this.delay = delay;
-        this.artifacts = artifacts;
-        this.TONParams = TONParams;
-        this.TACParams = TACParams;
-        this.liteSequencerEndpoints = liteSequencerEndpoints;
+    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(network, delay, artifacts, sdkParams.TONParams);
-        const TACParams = await this.prepareTACParams(artifacts, delay, sdkParams.TACParams);
-        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);
-    }
-    static async prepareTONParams(network, delay, artifacts, TONParams) {
-        const contractOpener = TONParams?.contractOpener ??
-            new ton_1.TonClient({
-                endpoint: network == Struct_1.Network.TESTNET
-                    ? new URL('api/v2/jsonRPC', artifacts_1.testnet.TON_RPC_ENDPOINT_BY_TAC).toString()
-                    : artifacts_1.mainnet.TON_PUBLIC_RPC_ENDPOINT,
-            });
-        const settingsAddress = TONParams?.settingsAddress ?? artifacts.ton.addresses.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.addresses.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();
-    }
-    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();
-    }
-    async getJettonOpType(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)) {
-            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);
-        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)) {
-            return InternalStruct_1.AssetOpType.JETTON_TRANSFER;
-        }
-        return InternalStruct_1.AssetOpType.JETTON_BURN;
-    }
-    async getNFTOpType(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)) {
-            return InternalStruct_1.AssetOpType.NFT_TRANSFER;
-        }
-        return InternalStruct_1.AssetOpType.NFT_BURN;
-    }
-    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 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 aggregateTokens(assets) {
-        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,
-        }));
-        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,
-        }));
-        return {
-            jettons,
-            nfts,
-            crossChainTonAmount,
-        };
-    }
-    async generateJettonPayload(jetton, caller, evmData, crossChainTonAmount, forwardFeeTonAmount, feeParams) {
-        const opType = await this.getJettonOpType(jetton);
-        await (0, Utils_1.sleep)(this.delay * 1000);
-        console.log(`***** Jetton ${jetton.address} requires ${opType} operation`);
-        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;
-        }
-        return payload;
+        return this.config.nativeTACAddress();
     }
-    async generateNFTPayload(nft, caller, evmData, crossChainTonAmount, forwardFeeTonAmount, feeParams) {
-        const opType = await this.getNFTOpType(nft);
-        await (0, Utils_1.sleep)(this.delay * 1000);
-        console.log(`***** NFT ${nft.address} requires ${opType} operation`);
-        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;
-        }
-        return payload;
-    }
-    async generateCrossChainMessages(caller, evmData, aggregatedData, feeParams) {
-        let crossChainTonAmount = aggregatedData.crossChainTonAmount;
-        let feeTonAmount = feeParams.protocolFee + feeParams.evmExecutorFee + feeParams.tvmExecutorFee;
-        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;
-        }
-        return messages;
-    }
-    async getRawAmount(asset, precalculatedAddress) {
-        if ('rawAmount' in asset) {
-            // User specified raw format amount
-            return asset.rawAmount;
-        }
-        if (!precalculatedAddress) {
-            // User specified TON Coin
-            return (0, ton_1.toNano)(asset.amount);
-        }
-        if (typeof asset.decimals === 'number') {
-            // User manually set decimals
-            return (0, Utils_1.calculateRawAmount)(asset.amount, asset.decimals);
-        }
-        // Get decimals from chain
-        (0, Utils_1.validateTVMAddress)(precalculatedAddress);
-        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
-            return (0, ton_1.toNano)(asset.amount);
-        }
-        return (0, Utils_1.calculateRawAmount)(asset.amount, Number(content.metadata.decimals));
-    }
-    async convertAssetsToRawFormat(assets) {
-        return await Promise.all((assets ?? []).map(async (asset) => {
-            if (asset.type === Struct_1.AssetType.FT) {
-                const address = (0, ethers_1.isAddress)(asset.address)
-                    ? await this.getTVMTokenAddress(asset.address)
-                    : asset.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);
-                    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;
-        }));
+    get getTrustedTACExecutors() {
+        return this.config.getTrustedTACExecutors;
     }
-    async getFeeInfo(evmProxyMsg, transactionLinker, rawAssets, evmValidExecutors, forceSend = false, isRoundTrip) {
-        const crossChainLayer = this.TONParams.contractOpener.open(this.artifacts.ton.wrappers.CrossChainLayer.createFromAddress(ton_1.Address.parse(this.TONParams.crossChainLayerAddress)));
-        const fullStateCCL = await crossChainLayer.getFullData();
-        const tacSimulationBody = {
-            tacCallParams: {
-                arguments: evmProxyMsg.encodedParameters ?? '0x',
-                methodName: (0, Utils_1.formatSolidityMethodName)(evmProxyMsg.methodName),
-                target: evmProxyMsg.evmTargetAddress,
-            },
-            evmValidExecutors: evmValidExecutors,
-            extraData: '0x',
-            shardsKey: transactionLinker.shardsKey,
-            tonAssets: rawAssets.map((asset) => ({
-                amount: asset.rawAmount.toString(),
-                tokenAddress: asset.address || '',
-                assetType: asset.type,
-            })),
-            tonCaller: transactionLinker.caller,
-        };
-        const tacSimulationResult = await this.simulateTACMessage(tacSimulationBody);
-        if (!tacSimulationResult.simulationStatus) {
-            if (forceSend) {
-                return {
-                    feeParams: {
-                        isRoundTrip: isRoundTrip ?? false,
-                        gasLimit: 0n,
-                        protocolFee: BigInt((0, ton_1.toNano)(fullStateCCL.tacProtocolFee)) +
-                            BigInt(isRoundTrip ?? false) * BigInt((0, ton_1.toNano)(fullStateCCL.tonProtocolFee)),
-                        evmExecutorFee: 0n,
-                        tvmExecutorFee: 0n,
-                    },
-                    simulation: tacSimulationResult,
-                };
-            }
-            throw tacSimulationResult;
-        }
-        isRoundTrip = isRoundTrip ?? tacSimulationResult.outMessages != null;
-        let tonExecutorFeeInTON = 0n;
-        if (isRoundTrip) {
-            tonExecutorFeeInTON = BigInt(tacSimulationResult.suggestedTonExecutionFee);
-        }
-        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: tonExecutorFeeInTON,
-        };
-        return { feeParams: feeParams, simulation: tacSimulationResult };
+    get getTrustedTONExecutors() {
+        return this.config.getTrustedTONExecutors;
     }
     async getTransactionSimulationInfo(evmProxyMsg, sender, assets) {
-        const rawAssets = await this.convertAssetsToRawFormat(assets);
-        const aggregatedData = await this.aggregateTokens(rawAssets);
-        const transactionLinkerShardCount = aggregatedData.jettons.length == 0 ? 1 : aggregatedData.jettons.length;
-        const transactionLinker = (0, Utils_1.generateTransactionLinker)(sender.getSenderAddress(), transactionLinkerShardCount);
-        const evmValidExecutors = this.TACParams.trustedTACExecutors;
-        return await this.getFeeInfo(evmProxyMsg, transactionLinker, rawAssets, evmValidExecutors, false, undefined);
+        return this.simulator.getTransactionSimulationInfo(evmProxyMsg, sender, assets);
     }
     async getTVMExecutorFeeInfo(assets, feeSymbol) {
-        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) {
-                console.error(`Error while calculating tvm executor fee ${endpoint}:`, error);
-                lastError = error;
-            }
-        }
-        throw (0, errors_1.simulationError)(lastError);
-    }
-    async prepareCrossChainTransaction(evmProxyMsg, caller, assets, options) {
-        let { forceSend = false, isRoundTrip = undefined, protocolFee = undefined, evmValidExecutors = [], evmExecutorFee = undefined, tvmValidExecutors = [], tvmExecutorFee = undefined, } = options || {};
-        const rawAssets = await this.convertAssetsToRawFormat(assets);
-        const aggregatedData = await this.aggregateTokens(rawAssets);
-        const tokensLength = aggregatedData.jettons.length + aggregatedData.nfts.length;
-        let transactionLinkerShardCount = tokensLength == 0 ? 1 : tokensLength;
-        const transactionLinker = (0, Utils_1.generateTransactionLinker)(caller, transactionLinkerShardCount);
-        if (evmValidExecutors.length == 0) {
-            evmValidExecutors = this.TACParams.trustedTACExecutors;
-        }
-        if (tvmValidExecutors.length == 0) {
-            tvmValidExecutors = this.TACParams.trustedTONExecutors;
-        }
-        const { feeParams } = await this.getFeeInfo(evmProxyMsg, transactionLinker, rawAssets, evmValidExecutors, forceSend, isRoundTrip);
-        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;
-        }
-        const validExecutors = {
-            tac: evmValidExecutors,
-            ton: tvmValidExecutors,
-        };
-        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,
-        };
-        return { transaction, transactionLinker };
+        return this.simulator.getTVMExecutorFeeInfo(assets, feeSymbol);
     }
-    async sendCrossChainTransaction(evmProxyMsg, sender, assets, options) {
-        const caller = sender.getSenderAddress();
-        const { transaction, transactionLinker } = await this.prepareCrossChainTransaction(evmProxyMsg, caller, assets, options);
-        console.log('*****Sending transaction: ', transaction);
-        const sendTransactionResult = await sender.sendShardTransaction(transaction, this.delay, this.network, this.TONParams.contractOpener);
-        return { sendTransactionResult, ...transactionLinker };
+    async sendCrossChainTransaction(evmProxyMsg, sender, assets, options, waitOptions) {
+        return this.transactionManager.sendCrossChainTransaction(evmProxyMsg, sender, assets, options, waitOptions);
     }
-    async sendCrossChainTransactions(sender, txs) {
-        const transactions = [];
-        const transactionLinkers = [];
-        const caller = sender.getSenderAddress();
-        for (const { options, assets, evmProxyMsg } of txs) {
-            const { transaction, transactionLinker } = await this.prepareCrossChainTransaction(evmProxyMsg, caller, assets, options);
-            transactions.push(transaction);
-            transactionLinkers.push(transactionLinker);
-        }
-        console.log('*****Sending transactions: ', transactions);
-        await sender.sendShardTransactions(transactions, this.delay, this.network, this.TONParams.contractOpener);
-        return transactionLinkers;
+    async sendCrossChainTransactions(sender, txs, waitOptions) {
+        return this.transactionManager.sendCrossChainTransactions(sender, txs, waitOptions);
     }
-    // TODO move to sdk.TAC, sdk.TON
     async bridgeTokensToTON(signer, value, tonTarget, assets, tvmExecutorFee) {
-        if (assets == undefined) {
-            assets = [];
-        }
-        let 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,
-                });
-            }
-        }
-        if (value > 0) {
-            const tvmAddress = await this.getTVMTokenAddress(await this.nativeTACAddress());
-            tonAssets.push({
-                address: tvmAddress,
-                rawAmount: value,
-                type: Struct_1.AssetType.FT,
-            });
-        }
-        const suggestedTONExecutorFee = await this.getTVMExecutorFeeInfo(tonAssets, Consts_1.TAC_SYMBOL);
-        const crossChainLayerAddress = await this.TACParams.crossChainLayer.getAddress();
-        for (const asset of assets) {
-            if (asset.type == Struct_1.AssetType.FT) {
-                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();
-            }
-            if (asset.type == Struct_1.AssetType.NFT) {
-                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();
-            }
-        }
-        const shardsKey = BigInt(Math.round(Math.random() * 1e18));
-        const protocolFee = await this.TACParams.crossChainLayer.getProtocolFee();
-        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);
-        const tx = await this.TACParams.crossChainLayer
-            .connect(signer)
-            .sendMessage(outMsgVersion, encodedOutMessage, { value: totalValue });
-        await tx.wait();
-        return tx.hash;
-    }
-    get getTrustedTACExecutors() {
-        return this.TACParams.trustedTACExecutors;
-    }
-    get getTrustedTONExecutors() {
-        return this.TACParams.trustedTONExecutors;
-    }
-    async getEVMTokenAddress(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])) {
-                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;
-            }
-        }
-        return this.TACParams.tokenUtils.computeAddress(tvmTokenAddress);
-    }
-    async getTVMTokenAddress(evmTokenAddress) {
-        (0, Utils_1.validateEVMAddress)(evmTokenAddress);
-        const exists = await this.TACParams.tokenUtils['exists(address)'](evmTokenAddress);
-        if (exists) {
-            const erc721Token = this.artifacts.tac.wrappers.CrossChainLayerERC20FactoryTAC.connect(evmTokenAddress, this.TACParams.provider);
-            const info = await erc721Token.getInfo();
-            return info.tvmAddress;
-        }
-        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();
-    }
-    async getTVMNFTAddress(evmNFTAddress, tokenId) {
-        (0, Utils_1.validateEVMAddress)(evmNFTAddress);
-        let nftCollection;
-        const exists = await this.TACParams.tokenUtils['exists(address)'](evmNFTAddress);
-        if (exists) {
-            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 {
-            nftCollection = this.TONParams.contractOpener.open(wrappers_1.NFTCollection.createFromConfig({
-                ownerAddress: (0, ton_1.address)(this.TONParams.crossChainLayerAddress),
-                content: (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-ignore // bigint can be used, wrapper is not typed properly
-                    index: tokenId,
-                }, this.TONParams.nftItemCode).address.toString();
-        }
-    }
-    async getEVMNFTAddress(tvmNFTAddress, addressType) {
-        (0, Utils_1.validateTVMAddress)(tvmNFTAddress);
-        tvmNFTAddress = ton_1.Address.parse(tvmNFTAddress).toString({ bounceable: true });
-        if (addressType == Struct_1.NFTAddressType.ITEM) {
-            tvmNFTAddress = (await this.getNFTItemData(tvmNFTAddress)).collectionAddress.toString();
-            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])) {
-            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();
-        }
-        return this.TACParams.tokenUtils.computeAddressERC721(tvmNFTAddress);
+        return this.transactionManager.bridgeTokensToTON(signer, value, tonTarget, assets, tvmExecutorFee);
     }
     async isContractDeployedOnTVM(address) {
-        return (await this.TONParams.contractOpener.getContractState(ton_1.Address.parse(address))).state === 'active';
+        return this.config.isContractDeployedOnTVM(address);
     }
     async simulateTACMessage(req) {
-        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],
-                });
-                return response.data.response;
-            }
-            catch (error) {
-                console.error(`Error while simulating with ${endpoint}:`, error);
-                lastError = error;
-            }
-        }
-        throw (0, errors_1.simulationError)(lastError);
+        return this.simulator.simulateTACMessage(req);
+    }
+    async simulateTransactions(sender, txs) {
+        return this.simulator.simulateTransactions(sender, txs);
     }
 }
 exports.TacSdk = TacSdk;