@tonappchain/sdk 0.5.6 → 0.6.1-spb.0.0

package/dist/sdk/TacSdk.js

@@ -21,6 +21,8 @@ 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;
@@ -35,7 +37,7 @@ class TacSdk {
         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, sdkParams.TACParams);
+        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
@@ -50,9 +52,15 @@ class TacSdk {
         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('JETTON_MINTER_CODE');
+        const jettonMinterCode = await settings.getCellSetting('JettonMinterCode');
         await (0, Utils_1.sleep)(delay * 1000);
-        const jettonWalletCode = await settings.getCellSetting('JETTON_WALLET_CODE');
+        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,
@@ -60,26 +68,42 @@ class TacSdk {
             crossChainLayerAddress,
             jettonMinterCode,
             jettonWalletCode,
+            nftProxyAddress,
+            nftItemCode,
+            nftCollectionCode,
         };
     }
-    static async prepareTACParams(artifacts, TACParams) {
+    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 = new ethers_1.ethers.Contract(settingsAddress, TACParams?.settingsABI ?? artifacts.tac.compilationArtifacts.Settings.abi, provider);
+        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,
-            settingsAddress,
-            tokenUtilsAddress,
+            settings,
+            tokenUtils,
+            crossChainLayer,
+            trustedTACExecutors,
+            trustedTONExecutors,
             abiCoder: new ethers_1.ethers.AbiCoder(),
             crossChainLayerABI,
-            crossChainLayerAddress,
             crossChainLayerTokenABI,
             crossChainLayerTokenBytecode,
+            crossChainLayerNFTABI,
+            crossChainLayerNFTBytecode,
         };
     }
     closeConnections() {
@@ -88,9 +112,8 @@ class TacSdk {
     get nativeTONAddress() {
         return 'NONE';
     }
-    get nativeTACAddress() {
-        const crossChainLayer = new ethers_1.ethers.Contract(this.TACParams.crossChainLayerAddress, this.TACParams.crossChainLayerABI, this.TACParams.provider);
-        return crossChainLayer.NATIVE_TOKEN_ADDRESS.staticCall();
+    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)));
@@ -124,21 +147,52 @@ class TacSdk {
             exists: true,
         };
     }
-    getJettonTransferPayload(jettonData, responseAddress, evmData, crossChainTonAmount) {
+    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.transferMessage(jettonData.rawAmount, this.TONParams.jettonProxyAddress, responseAddress, Consts_1.JETTON_TRANSFER_FORWARD_TON_AMOUNT, crossChainTonAmount, evmData, queryId);
+        return JettonWallet_1.JettonWallet.burnMessage(jettonData.rawAmount, jettonData.notificationReceiverAddress, crossChainTonAmount, feeData, evmData, queryId);
     }
-    getJettonBurnPayload(jettonData, evmData, crossChainTonAmount) {
+    getNFTBurnPayload(burnData) {
         const queryId = (0, Utils_1.generateRandomNumberByTimestamp)().randomNumber;
-        return JettonWallet_1.JettonWallet.burnMessage(jettonData.rawAmount, jettonData.notificationReceiverAddress, crossChainTonAmount, evmData, queryId);
+        return wrappers_1.NFTItem.burnMessage(queryId, (0, ton_1.address)(burnData.notificationReceiverAddress), burnData.crossChainTonAmount ?? 0, burnData.evmData, burnData.feeData);
     }
-    getTonTransferPayload(responseAddress, evmData, crossChainTonAmount) {
+    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_l1MsgToL2, 32)
+            .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();
@@ -154,26 +208,51 @@ class TacSdk {
             return InternalStruct_1.AssetOpType.JETTON_TRANSFER;
         }
         const givenMinter = this.TONParams.contractOpener.open(new JettonMaster_1.JettonMaster((0, ton_1.address)(asset.address)));
-        const l2Address = await givenMinter.getL2Address();
+        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(l2Address)
+            .storeStringTail(evmAddress)
             .endCell());
         if (!expectedMinterAddress.equals(givenMinter.address)) {
             return InternalStruct_1.AssetOpType.JETTON_TRANSFER;
         }
         return InternalStruct_1.AssetOpType.JETTON_BURN;
     }
-    async aggregateJettons(assets) {
+    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));
@@ -185,53 +264,113 @@ class TacSdk {
         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 generatePayload(jetton, caller, evmData, 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);
+                }, evmData, crossChainTonAmount, feeData);
                 break;
             case InternalStruct_1.AssetOpType.JETTON_TRANSFER:
-                payload = this.getJettonTransferPayload(jetton, caller, evmData, crossChainTonAmount);
+                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) {
+    async generateCrossChainMessages(caller, evmData, aggregatedData, feeParams) {
         let crossChainTonAmount = aggregatedData.crossChainTonAmount;
-        if (aggregatedData.jettons.length == 0) {
+        let feeTonAmount = feeParams.protocolFee + feeParams.evmExecutorFee + feeParams.tvmExecutorFee;
+        if (aggregatedData.jettons.length == 0 && aggregatedData.nfts.length == 0) {
             return [
                 {
                     address: this.TONParams.crossChainLayerAddress,
-                    value: crossChainTonAmount + Consts_1.TRANSACTION_TON_AMOUNT,
-                    payload: this.getTonTransferPayload(caller, evmData, crossChainTonAmount),
+                    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.generatePayload(jetton, caller, evmData, crossChainTonAmount);
+            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 + Consts_1.TRANSACTION_TON_AMOUNT,
+                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;
     }
@@ -260,75 +399,243 @@ class TacSdk {
     }
     async convertAssetsToRawFormat(assets) {
         return await Promise.all((assets ?? []).map(async (asset) => {
-            const address = (0, ethers_1.isAddress)(asset.address)
-                ? await this.getTVMTokenAddress(asset.address)
-                : asset.address;
-            return {
-                address,
-                rawAmount: await this.getRawAmount(asset, address),
-            };
+            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 getGasLimit(evmProxyMsg, transactionLinker, rawAssets, forceSend = false) {
+    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 0n;
+                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;
         }
-        return (BigInt(tacSimulationResult.estimatedGas) * 120n) / 100n;
+        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 sendCrossChainTransaction(evmProxyMsg, sender, assets, forceSend = false) {
+    async getTransactionSimulationInfo(evmProxyMsg, sender, assets) {
         const rawAssets = await this.convertAssetsToRawFormat(assets);
-        const aggregatedData = await this.aggregateJettons(rawAssets);
+        const aggregatedData = await this.aggregateTokens(rawAssets);
         const transactionLinkerShardCount = aggregatedData.jettons.length == 0 ? 1 : aggregatedData.jettons.length;
-        const caller = sender.getSenderAddress();
+        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);
-        const gasLimit = await this.getGasLimit(evmProxyMsg, transactionLinker, rawAssets, forceSend);
-        if (evmProxyMsg.gasLimit == 0n || evmProxyMsg.gasLimit == undefined) {
-            evmProxyMsg.gasLimit = gasLimit;
+        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;
         }
-        const evmData = (0, Utils_1.buildEvmDataCell)(transactionLinker, evmProxyMsg);
-        const messages = await this.generateCrossChainMessages(caller, evmData, aggregatedData);
+        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 l2Address = await givenMinter.getL2Address();
+                const evmAddress = await givenMinter.getEVMAddress();
                 await (0, Utils_1.sleep)(this.delay * 1000);
-                return l2Address;
+                return evmAddress;
             }
         }
-        return (0, Utils_1.calculateEVMTokenAddress)(this.TACParams.abiCoder, this.TACParams.tokenUtilsAddress, this.TACParams.crossChainLayerTokenBytecode, this.TACParams.crossChainLayerAddress, tvmTokenAddress);
+        return this.TACParams.tokenUtils.computeAddress(tvmTokenAddress);
     }
     async getTVMTokenAddress(evmTokenAddress) {
         (0, Utils_1.validateEVMAddress)(evmTokenAddress);
@@ -336,7 +643,7 @@ class TacSdk {
         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.l1Address;
+            return info.tvmAddress;
         }
         const jettonMaster = JettonMaster_1.JettonMaster.createFromConfig({
             evmTokenAddress,
@@ -346,6 +653,48 @@ class TacSdk {
         });
         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 {