@tonappchain/sdk 0.6.1-v3.0.1 → 0.6.1-v3.0.3

package/dist/sdk/TacSdk.js

@@ -0,0 +1,713 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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 Consts_1 = require("./Consts");
+const Utils_1 = require("./Utils");
+const artifacts_1 = require("@tonappchain/artifacts");
+const errors_1 = require("../errors");
+const contractOpener_1 = require("../adapters/contractOpener");
+const wrappers_1 = require("@tonappchain/artifacts/dist/src/ton/wrappers");
+const instances_1 = require("../errors/instances");
+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;
+    }
+    static async create(sdkParams) {
+        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 ?? (await (0, contractOpener_1.orbsOpener4)(network));
+        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,
+        };
+    }
+    closeConnections() {
+        return this.TONParams.contractOpener.closeConnections?.call(this);
+    }
+    get nativeTONAddress() {
+        return 'NONE';
+    }
+    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);
+    }
+    generateFeeData(feeParams) {
+        if (feeParams) {
+            let feeDataBuilder = (0, ton_1.beginCell)()
+                .storeBit(feeParams.isRoundTrip)
+                .storeCoins(feeParams.protocolFee)
+                .storeCoins(feeParams.evmExecutorFee);
+            if (feeParams.isRoundTrip) {
+                feeDataBuilder.storeCoins(feeParams.tvmExecutorFee);
+            }
+            return feeDataBuilder.endCell();
+        }
+        else {
+            return undefined;
+        }
+    }
+    getTonTransferPayload(responseAddress, evmData, crossChainTonAmount, feeParams) {
+        const queryId = (0, Utils_1.generateRandomNumberByTimestamp)().randomNumber;
+        const feeData = this.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 = this.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;
+    }
+    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 = this.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();
+        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);
+                    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 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',
+            feeAssetAddress: '',
+            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 };
+    }
+    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);
+    }
+    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 };
+    }
+    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 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;
+    }
+    // TODO move to sdk.TAC, sdk.TON
+    async bridgeTokensToTON(signer, value, tonTarget, assets, tvmExecutorFee) {
+        if (assets == undefined) {
+            assets = [];
+        }
+        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();
+        let tvmExecutorFeeInTON = 0n;
+        if (tvmExecutorFee != undefined) {
+            tvmExecutorFeeInTON = tvmExecutorFee;
+        }
+        else {
+            tvmExecutorFeeInTON =
+                ((((0, ton_1.toNano)('0.065') + (0, ton_1.toNano)('0.05')) * BigInt(assets.length + 1 + Number(value != 0n)) +
+                    (0, ton_1.toNano)('0.2')) *
+                    120n) /
+                    100n; // TODO calc that
+        }
+        const tonToTacRate = 100n;
+        const scale = 10n ** 9n;
+        const tonToTacRateScaled = tonToTacRate * scale;
+        const tvmExecutorFeeInTAC = tonToTacRateScaled * tvmExecutorFeeInTON;
+        const outMessage = {
+            shardsKey: shardsKey,
+            tvmTarget: tonTarget,
+            tvmPayload: '',
+            tvmProtocolFee: protocolFee,
+            tvmExecutorFee: tvmExecutorFeeInTAC,
+            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 bytecode = await this.TACParams.provider.getCode(evmTokenAddress);
+        if (bytecode.includes(ethers_1.ethers.id('getInfo()').slice(2, 10))) {
+            const contract = new ethers_1.ethers.Contract(evmTokenAddress, this.TACParams.crossChainLayerTokenABI, this.TACParams.provider);
+            const info = await contract.getInfo.staticCall();
+            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 bytecode = await this.TACParams.provider.getCode(evmNFTAddress);
+        if (bytecode.includes(ethers_1.ethers.id('getInfo()').slice(2, 10))) {
+            const contract = new ethers_1.ethers.Contract(evmNFTAddress, this.TACParams.crossChainLayerNFTABI, this.TACParams.provider);
+            const info = await contract.getInfo.staticCall();
+            nftCollection = this.TONParams.contractOpener.open(wrappers_1.NFTCollection.createFromAddress(info.tvmAddress));
+        }
+        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()
+            : (await nftCollection.getNFTAddressByIndex(tokenId)).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.computeAddress(tvmNFTAddress);
+    }
+    async isContractDeployedOnTVM(address) {
+        return (await this.TONParams.contractOpener.getContractState(ton_1.Address.parse(address))).state === 'active';
+    }
+    async simulateTACMessage(req) {
+        for (const endpoint of this.liteSequencerEndpoints) {
+            try {
+                const response = await axios_1.default.post(`${endpoint}/tac/simulator/simulate-message`, req, {
+                    transformResponse: [Utils_1.toCamelCaseTransformer],
+                });
+                return response.data.response;
+            }
+            catch (error) {
+                console.error(`Error while simulating with ${endpoint}:`, error);
+            }
+        }
+        throw errors_1.simulationError;
+    }
+}
+exports.TacSdk = TacSdk;