@tonappchain/sdk 0.6.5-mainnet-alpha → 0.6.5-smart-accounts-1

package/dist/sdk/TacSdk.js

@@ -4,32 +4,36 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TacSdk = void 0;
-const axios_1 = __importDefault(require("axios"));
 const ton_1 = require("@ton/ton");
+const artifacts_1 = require("@tonappchain/artifacts");
+const wrappers_1 = require("@tonappchain/artifacts/dist/src/ton/wrappers");
+const axios_1 = __importDefault(require("axios"));
 const ethers_1 = require("ethers");
-// import structs
-const Struct_1 = require("../structs/Struct");
+const errors_1 = require("../errors");
+const instances_1 = require("../errors/instances");
+const retryableContractOpener_1 = require("../adapters/retryableContractOpener");
 // import internal structs
 const InternalStruct_1 = require("../structs/InternalStruct");
+// import structs
+const Struct_1 = require("../structs/Struct");
 // jetton imports
 const JettonMaster_1 = require("../wrappers/JettonMaster");
 const JettonWallet_1 = require("../wrappers/JettonWallet");
 // ton settings
 const Settings_1 = require("../wrappers/Settings");
 const Consts_1 = require("./Consts");
+const OperationTracker_1 = require("./OperationTracker");
 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");
 class TacSdk {
-    constructor(network, delay, artifacts, TONParams, TACParams, liteSequencerEndpoints) {
+    constructor(network, delay, artifacts, TONParams, TACParams, liteSequencerEndpoints, debug) {
         this.network = network;
         this.delay = delay;
         this.artifacts = artifacts;
         this.TONParams = TONParams;
         this.TACParams = TACParams;
         this.liteSequencerEndpoints = liteSequencerEndpoints;
+        this.debug = debug;
+        this.operationTracker = new OperationTracker_1.OperationTracker(network, liteSequencerEndpoints, debug);
     }
     static async create(sdkParams) {
         const network = sdkParams.network;
@@ -37,19 +41,16 @@ class TacSdk {
         const artifacts = network === Struct_1.Network.TESTNET ? artifacts_1.testnet : artifacts_1.mainnet;
         const TONParams = await this.prepareTONParams(delay, artifacts, sdkParams.TONParams);
         const TACParams = await this.prepareTACParams(artifacts, delay, sdkParams.TACParams);
+        const debug = sdkParams.debug ?? false;
         const liteSequencerEndpoints = sdkParams.customLiteSequencerEndpoints ??
             (network === Struct_1.Network.TESTNET
                 ? artifacts_1.testnet.PUBLIC_LITE_SEQUENCER_ENDPOINTS
                 : artifacts_1.mainnet.PUBLIC_LITE_SEQUENCER_ENDPOINTS);
-        return new TacSdk(network, delay, artifacts, TONParams, TACParams, liteSequencerEndpoints);
+        return new TacSdk(network, delay, artifacts, TONParams, TACParams, liteSequencerEndpoints, debug);
     }
     static async prepareTONParams(delay, artifacts, TONParams) {
-        const contractOpener = TONParams?.contractOpener ??
-            new ton_1.TonClient({
-                endpoint: new URL('api/v2/jsonRPC', artifacts.TON_RPC_ENDPOINT_BY_TAC).toString()
-            });
-        const settingsAddress = TONParams?.settingsAddress
-            ?? artifacts.TON_SETTINGS_ADDRESS;
+        const contractOpener = TONParams?.contractOpener ?? (await (0, retryableContractOpener_1.createDefaultRetryableOpener)(artifacts));
+        const settingsAddress = TONParams?.settingsAddress ?? artifacts.TON_SETTINGS_ADDRESS;
         const settings = contractOpener.open(new Settings_1.Settings(ton_1.Address.parse(settingsAddress)));
         const jettonProxyAddress = await settings.getAddressSetting('JettonProxyAddress');
         await (0, Utils_1.sleep)(delay * 1000);
@@ -78,8 +79,7 @@ class TacSdk {
     }
     static async prepareTACParams(artifacts, delay, TACParams) {
         const provider = TACParams?.provider ?? ethers_1.ethers.getDefaultProvider(artifacts.TAC_RPC_ENDPOINT);
-        const settingsAddress = TACParams?.settingsAddress?.toString()
-            ?? artifacts.TAC_SETTINGS_ADDRESS;
+        const settingsAddress = TACParams?.settingsAddress?.toString() ?? artifacts.TAC_SETTINGS_ADDRESS;
         const settings = artifacts.tac.wrappers.SettingsFactoryTAC.connect(settingsAddress, provider);
         const crossChainLayerABI = TACParams?.crossChainLayerABI ?? artifacts.tac.compilationArtifacts.CrossChainLayer.abi;
         const crossChainLayerAddress = await settings.getAddressSetting((0, ethers_1.keccak256)((0, ethers_1.toUtf8Bytes)('CrossChainLayerAddress')));
@@ -95,6 +95,7 @@ class TacSdk {
         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;
+        const smartAccountFactory = artifacts.tac.wrappers.TacSAFactory_factoryTAC.connect(artifacts.TAC_SMART_ACCOUNT_FACTORY_ADDRESS, provider);
         return {
             provider,
             settings,
@@ -108,6 +109,7 @@ class TacSdk {
             crossChainLayerTokenBytecode,
             crossChainLayerNFTABI,
             crossChainLayerNFTBytecode,
+            smartAccountFactory,
         };
     }
     closeConnections() {
@@ -130,6 +132,9 @@ class TacSdk {
         const userJettonWallet = this.TONParams.contractOpener.open(new JettonWallet_1.JettonWallet(ton_1.Address.parse(userJettonWalletAddress)));
         return userJettonWallet.getJettonBalance();
     }
+    async getTacSmartAccountAddress(tvmUserAddress, evmApplicationAddress) {
+        return await this.TACParams.smartAccountFactory.getSmartAccountForApplication(tvmUserAddress, evmApplicationAddress);
+    }
     async getUserJettonBalanceExtended(userAddress, tokenAddress) {
         const masterAddress = ton_1.Address.parse(tokenAddress);
         const masterState = await this.TONParams.contractOpener.getContractState(masterAddress);
@@ -186,7 +191,13 @@ class TacSdk {
             .storeMaybeRef(evmData)
             .endCell();
     }
+    debugLog(message) {
+        if (this.debug) {
+            console.log(`[TacSdk Debug] ${message}`);
+        }
+    }
     async getJettonOpType(asset) {
+        this.debugLog(`Getting jetton op type for ${(0, Utils_1.formatObjectForLogging)(asset)}`);
         const { code: givenMinterCodeBOC } = await this.TONParams.contractOpener.getContractState((0, ton_1.address)(asset.address));
         if (!givenMinterCodeBOC) {
             throw errors_1.emptyContractError;
@@ -194,11 +205,13 @@ class TacSdk {
         const givenMinterCode = ton_1.Cell.fromBoc(givenMinterCodeBOC)[0];
         await (0, Utils_1.sleep)(this.delay * 1000);
         if (!this.TONParams.jettonMinterCode.equals(givenMinterCode)) {
+            this.debugLog(`Jetton ${(0, Utils_1.formatObjectForLogging)(asset)} requires JETTON_TRANSFER operation`);
             return InternalStruct_1.AssetOpType.JETTON_TRANSFER;
         }
         const givenMinter = this.TONParams.contractOpener.open(new JettonMaster_1.JettonMaster((0, ton_1.address)(asset.address)));
         const evmAddress = await givenMinter.getEVMAddress();
         await (0, Utils_1.sleep)(this.delay * 1000);
+        this.debugLog(`Jetton ${(0, Utils_1.formatObjectForLogging)(asset)} has evm address ${evmAddress}`);
         const expectedMinterAddress = await (0, Utils_1.calculateContractAddress)(this.TONParams.jettonMinterCode, (0, ton_1.beginCell)()
             .storeCoins(0)
             .storeAddress((0, ton_1.address)(this.TONParams.crossChainLayerAddress))
@@ -208,11 +221,14 @@ class TacSdk {
             .storeStringTail(evmAddress)
             .endCell());
         if (!expectedMinterAddress.equals(givenMinter.address)) {
+            this.debugLog(`Jetton ${(0, Utils_1.formatObjectForLogging)(asset)} requires JETTON_TRANSFER operation`);
             return InternalStruct_1.AssetOpType.JETTON_TRANSFER;
         }
+        this.debugLog(`Jetton ${(0, Utils_1.formatObjectForLogging)(asset)} requires JETTON_BURN operation`);
         return InternalStruct_1.AssetOpType.JETTON_BURN;
     }
     async getNFTOpType(asset) {
+        this.debugLog(`Getting NFT op type for ${(0, Utils_1.formatObjectForLogging)(asset)}`);
         const { code: itemCodeBOC } = await this.TONParams.contractOpener.getContractState((0, ton_1.address)(asset.address));
         if (!itemCodeBOC) {
             throw errors_1.emptyContractError;
@@ -220,8 +236,10 @@ class TacSdk {
         const givenNFTItemCode = ton_1.Cell.fromBoc(itemCodeBOC)[0];
         await (0, Utils_1.sleep)(this.delay * 1000);
         if (!this.TONParams.nftItemCode.equals(givenNFTItemCode)) {
+            this.debugLog(`NFT ${(0, Utils_1.formatObjectForLogging)(asset)} requires NFT_TRANSFER operation`);
             return InternalStruct_1.AssetOpType.NFT_TRANSFER;
         }
+        this.debugLog(`NFT ${(0, Utils_1.formatObjectForLogging)(asset)} requires NFT_BURN operation`);
         return InternalStruct_1.AssetOpType.NFT_BURN;
     }
     async getNFTItemAddressTON(collectionAddress, itemIndex) {
@@ -235,6 +253,7 @@ class TacSdk {
         return await nftItem.getNFTData();
     }
     async aggregateTokens(assets) {
+        this.debugLog(`Aggregating tokens`);
         const uniqueAssetsMap = new Map();
         let crossChainTonAmount = 0n;
         for await (const asset of assets ?? []) {
@@ -255,6 +274,8 @@ class TacSdk {
             rawAmount,
             type: Struct_1.AssetType.FT,
         }));
+        this.debugLog(`Aggregated ${jettons.length} jettons`);
+        this.debugLog(`Crosschain ton amount: ${crossChainTonAmount}`);
         uniqueAssetsMap.clear();
         for await (const asset of assets ?? []) {
             if (asset.type !== Struct_1.AssetType.NFT)
@@ -267,6 +288,7 @@ class TacSdk {
             rawAmount,
             type: Struct_1.AssetType.NFT,
         }));
+        this.debugLog(`Aggregated ${nfts.length} nfts`);
         return {
             jettons,
             nfts,
@@ -274,9 +296,10 @@ class TacSdk {
         };
     }
     async generateJettonPayload(jetton, caller, evmData, crossChainTonAmount, forwardFeeTonAmount, feeParams) {
+        this.debugLog(`Generating jetton payload for ${(0, Utils_1.formatObjectForLogging)(jetton)}`);
         const opType = await this.getJettonOpType(jetton);
         await (0, Utils_1.sleep)(this.delay * 1000);
-        console.log(`***** Jetton ${jetton.address} requires ${opType} operation`);
+        this.debugLog(`Generation fee data with params: ${(0, Utils_1.formatObjectForLogging)(feeParams)}`);
         const feeData = (0, Utils_1.generateFeeData)(feeParams);
         let payload;
         switch (opType) {
@@ -290,12 +313,14 @@ class TacSdk {
                 payload = this.getJettonTransferPayload(jetton, caller, evmData, crossChainTonAmount, forwardFeeTonAmount, feeData);
                 break;
         }
+        this.debugLog('Generating jetton payload success');
         return payload;
     }
     async generateNFTPayload(nft, caller, evmData, crossChainTonAmount, forwardFeeTonAmount, feeParams) {
+        this.debugLog(`Generating NFT payload for ${(0, Utils_1.formatObjectForLogging)(nft)}`);
         const opType = await this.getNFTOpType(nft);
         await (0, Utils_1.sleep)(this.delay * 1000);
-        console.log(`***** NFT ${nft.address} requires ${opType} operation`);
+        this.debugLog(`Generation fee data with params: ${(0, Utils_1.formatObjectForLogging)(feeParams)}`);
         const feeData = (0, Utils_1.generateFeeData)(feeParams);
         let payload;
         switch (opType) {
@@ -319,11 +344,15 @@ class TacSdk {
                 }, forwardFeeTonAmount);
                 break;
         }
+        this.debugLog('Generating NFT payload success');
         return payload;
     }
     async generateCrossChainMessages(caller, evmData, aggregatedData, feeParams) {
+        this.debugLog(`Generating cross-chain messages`);
         let crossChainTonAmount = aggregatedData.crossChainTonAmount;
         let feeTonAmount = feeParams.protocolFee + feeParams.evmExecutorFee + feeParams.tvmExecutorFee;
+        this.debugLog(`Crosschain ton amount: ${crossChainTonAmount}`);
+        this.debugLog(`Fee ton amount: ${feeTonAmount}`);
         if (aggregatedData.jettons.length == 0 && aggregatedData.nfts.length == 0) {
             return [
                 {
@@ -361,38 +390,51 @@ class TacSdk {
             feeTonAmount = 0n;
             currentFeeParams = undefined;
         }
+        this.debugLog('Generating cross-chain messages success');
         return messages;
     }
     async getRawAmount(asset, precalculatedAddress) {
+        this.debugLog(`Getting raw amount for ${(0, Utils_1.formatObjectForLogging)(precalculatedAddress ?? 'TON')}`);
         if ('rawAmount' in asset) {
-            // User specified raw format amount
+            this.debugLog(`Provided raw amount: ${asset.rawAmount}`);
             return asset.rawAmount;
         }
         if (!precalculatedAddress) {
             // User specified TON Coin
-            return (0, ton_1.toNano)(asset.amount);
+            const rawAmount = (0, ton_1.toNano)(asset.amount);
+            this.debugLog(`TON raw amount: ${rawAmount}`);
+            return rawAmount;
         }
         if (typeof asset.decimals === 'number') {
             // User manually set decimals
-            return (0, Utils_1.calculateRawAmount)(asset.amount, asset.decimals);
+            const rawAmount = (0, Utils_1.calculateRawAmount)(asset.amount, asset.decimals);
+            this.debugLog(`Raw amount calculated from decimals: ${rawAmount}`);
+            return rawAmount;
         }
         // Get decimals from chain
         (0, Utils_1.validateTVMAddress)(precalculatedAddress);
+        this.debugLog('Getting decimals from chain');
         const contract = this.TONParams.contractOpener.open(new JettonMaster_1.JettonMaster((0, ton_1.address)(precalculatedAddress)));
         const { content } = await contract.getJettonData();
         await (0, Utils_1.sleep)(this.delay * 1000);
         if (!content.metadata.decimals) {
             // if decimals not specified use default value 9
+            this.debugLog('Decimals not specified, using default value 9');
             return (0, ton_1.toNano)(asset.amount);
         }
-        return (0, Utils_1.calculateRawAmount)(asset.amount, Number(content.metadata.decimals));
+        const rawAmount = (0, Utils_1.calculateRawAmount)(asset.amount, Number(content.metadata.decimals));
+        this.debugLog(`Raw amount calculated from decimals(${content.metadata.decimals}): ${rawAmount}`);
+        return rawAmount;
     }
     async convertAssetsToRawFormat(assets) {
+        this.debugLog(`Converting assets to raw format`);
         return await Promise.all((assets ?? []).map(async (asset) => {
+            this.debugLog(`Converting asset to raw format: ${(0, Utils_1.formatObjectForLogging)(asset)}`);
             if (asset.type === Struct_1.AssetType.FT) {
                 const address = (0, ethers_1.isAddress)(asset.address)
                     ? await this.getTVMTokenAddress(asset.address)
                     : asset.address;
+                this.debugLog(`Token address on TON: ${address}`);
                 return {
                     address,
                     rawAmount: await this.getRawAmount(asset, address),
@@ -404,6 +446,7 @@ class TacSdk {
                     const address = (0, ethers_1.isAddress)(asset.collectionAddress)
                         ? await this.getTVMNFTAddress(asset.collectionAddress, asset.itemIndex)
                         : await this.getNFTItemAddressTON(asset.collectionAddress, asset.itemIndex);
+                    this.debugLog(`NFT address on TON: ${address}`);
                     await (0, Utils_1.sleep)(this.delay * 1000);
                     return {
                         address,
@@ -421,9 +464,12 @@ class TacSdk {
             throw instances_1.invalidAssetType;
         }));
     }
-    async getFeeInfo(evmProxyMsg, transactionLinker, rawAssets, forceSend = false, isRoundTrip = true, evmValidExecutors = this.TACParams.trustedTACExecutors) {
+    async getFeeInfo(evmProxyMsg, transactionLinker, rawAssets, forceSend = false, isRoundTrip = true, evmValidExecutors = this.TACParams.trustedTACExecutors, tvmValidExecutors = this.TACParams.trustedTONExecutors) {
+        this.debugLog('Getting fee info');
         const crossChainLayer = this.TONParams.contractOpener.open(this.artifacts.ton.wrappers.CrossChainLayer.createFromAddress(ton_1.Address.parse(this.TONParams.crossChainLayerAddress)));
         const fullStateCCL = await crossChainLayer.getFullData();
+        await (0, Utils_1.sleep)(this.delay * 1000);
+        this.debugLog(`Full state CCL: ${(0, Utils_1.formatObjectForLogging)(fullStateCCL)}`);
         const tacSimulationBody = {
             tacCallParams: {
                 arguments: evmProxyMsg.encodedParameters ?? '0x',
@@ -431,6 +477,7 @@ class TacSdk {
                 target: evmProxyMsg.evmTargetAddress,
             },
             evmValidExecutors: evmValidExecutors,
+            tvmValidExecutors: tvmValidExecutors,
             extraData: '0x',
             shardsKey: transactionLinker.shardsKey,
             tonAssets: rawAssets.map((asset) => ({
@@ -440,10 +487,13 @@ class TacSdk {
             })),
             tonCaller: transactionLinker.caller,
         };
-        isRoundTrip = isRoundTrip ?? (rawAssets.length != 0);
+        isRoundTrip = isRoundTrip ?? rawAssets.length != 0;
+        this.debugLog(`Is round trip: ${isRoundTrip}`);
         const tacSimulationResult = await this.simulateTACMessage(tacSimulationBody);
+        this.debugLog(`TAC simulation ${tacSimulationResult.simulationStatus ? 'success' : 'failed'}`);
         if (!tacSimulationResult.simulationStatus) {
             if (forceSend) {
+                this.debugLog('Force send is true, returning fee params');
                 return {
                     feeParams: {
                         isRoundTrip,
@@ -467,16 +517,21 @@ class TacSdk {
             evmExecutorFee: BigInt(tacSimulationResult.suggestedTacExecutionFee),
             tvmExecutorFee: BigInt(tacSimulationResult.suggestedTonExecutionFee) * BigInt(isRoundTrip),
         };
+        this.debugLog(`Collected fee params: ${(0, Utils_1.formatObjectForLogging)(feeParams)}`);
         return { feeParams: feeParams, simulation: tacSimulationResult };
     }
     async getTransactionSimulationInfo(evmProxyMsg, sender, assets) {
+        this.debugLog('Getting transaction simulation info');
         const rawAssets = await this.convertAssetsToRawFormat(assets);
         const aggregatedData = await this.aggregateTokens(rawAssets);
         const transactionLinkerShardCount = aggregatedData.jettons.length == 0 ? 1 : aggregatedData.jettons.length;
+        this.debugLog(`Transaction linker shard count: ${transactionLinkerShardCount}`);
         const transactionLinker = (0, Utils_1.generateTransactionLinker)(sender.getSenderAddress(), transactionLinkerShardCount);
+        this.debugLog(`Transaction linker: ${(0, Utils_1.formatObjectForLogging)(transactionLinker)}`);
         return await this.getFeeInfo(evmProxyMsg, transactionLinker, rawAssets);
     }
     async getTVMExecutorFeeInfo(assets, feeSymbol) {
+        this.debugLog('Getting TVM executor fee info');
         const rawAssets = await this.convertAssetsToRawFormat(assets);
         const requestBody = {
             tonAssets: rawAssets.map((asset) => ({
@@ -493,26 +548,32 @@ class TacSdk {
                 return response.data.response;
             }
             catch (error) {
-                console.error(`Error while calculating tvm executor fee ${endpoint}:`, error);
+                this.debugLog(`Error while calculating tvm executor fee ${endpoint}: ${error}`);
                 lastError = error;
             }
         }
+        this.debugLog('Error while calculating tvm executor fee on all endpoints');
         throw (0, errors_1.simulationError)(lastError);
     }
     async prepareCrossChainTransaction(evmProxyMsg, caller, assets, options) {
-        let { forceSend = false, isRoundTrip = undefined, protocolFee = undefined, evmValidExecutors = [], evmExecutorFee = undefined, tvmValidExecutors = [], tvmExecutorFee = undefined, } = options || {};
+        this.debugLog('Preparing cross-chain transaction');
+        const { forceSend = false, isRoundTrip = undefined, protocolFee = undefined, evmExecutorFee = undefined, tvmExecutorFee = undefined, } = options || {};
+        let { evmValidExecutors = [], tvmValidExecutors = [] } = options || {};
         const rawAssets = await this.convertAssetsToRawFormat(assets);
         const aggregatedData = await this.aggregateTokens(rawAssets);
         const tokensLength = aggregatedData.jettons.length + aggregatedData.nfts.length;
-        let transactionLinkerShardCount = tokensLength == 0 ? 1 : tokensLength;
+        this.debugLog(`Tokens length: ${tokensLength}`);
+        const transactionLinkerShardCount = tokensLength == 0 ? 1 : tokensLength;
+        this.debugLog(`Transaction linker shard count: ${transactionLinkerShardCount}`);
         const transactionLinker = (0, Utils_1.generateTransactionLinker)(caller, transactionLinkerShardCount);
+        this.debugLog(`Generated transaction linker: ${(0, Utils_1.formatObjectForLogging)(transactionLinker)}`);
         if (evmValidExecutors.length == 0) {
             evmValidExecutors = this.TACParams.trustedTACExecutors;
         }
         if (tvmValidExecutors.length == 0) {
             tvmValidExecutors = this.TACParams.trustedTONExecutors;
         }
-        const { feeParams } = await this.getFeeInfo(evmProxyMsg, transactionLinker, rawAssets, forceSend, isRoundTrip, evmValidExecutors);
+        const { feeParams } = await this.getFeeInfo(evmProxyMsg, transactionLinker, rawAssets, forceSend, isRoundTrip, evmValidExecutors, tvmValidExecutors);
         if (evmProxyMsg.gasLimit == undefined) {
             evmProxyMsg.gasLimit = feeParams.gasLimit;
         }
@@ -525,10 +586,12 @@ class TacSdk {
         if (protocolFee != undefined) {
             feeParams.protocolFee = protocolFee;
         }
+        this.debugLog(`Resulting fee params: ${(0, Utils_1.formatObjectForLogging)(feeParams)}`);
         const validExecutors = {
             tac: evmValidExecutors,
             ton: tvmValidExecutors,
         };
+        this.debugLog(`Valid executors: ${(0, Utils_1.formatObjectForLogging)(validExecutors)}`);
         const evmData = (0, Utils_1.buildEvmDataCell)(transactionLinker, evmProxyMsg, validExecutors);
         const messages = await this.generateCrossChainMessages(caller, evmData, aggregatedData, feeParams);
         await (0, Utils_1.sleep)(this.delay * 1000);
@@ -537,34 +600,70 @@ class TacSdk {
             messages,
             network: this.network,
         };
+        this.debugLog('Transaction prepared');
         return { transaction, transactionLinker };
     }
-    async sendCrossChainTransaction(evmProxyMsg, sender, assets, options) {
+    async sendCrossChainTransaction(evmProxyMsg, sender, assets, options, waitOptions) {
         const caller = sender.getSenderAddress();
+        this.debugLog(`Caller: ${caller}`);
         const { transaction, transactionLinker } = await this.prepareCrossChainTransaction(evmProxyMsg, caller, assets, options);
-        console.log('*****Sending transaction: ', transaction);
+        this.debugLog(`*****Sending transaction: ${(0, Utils_1.formatObjectForLogging)(transaction)}`);
         const sendTransactionResult = await sender.sendShardTransaction(transaction, this.delay, this.network, this.TONParams.contractOpener);
-        return { sendTransactionResult, ...transactionLinker };
+        return waitOptions
+            ? {
+                sendTransactionResult,
+                operationId: await this.operationTracker.getOperationId(transactionLinker, {
+                    ...waitOptions,
+                    successCheck: (operationId) => !!operationId,
+                    log: this.debugLog.bind(this),
+                }),
+                ...transactionLinker,
+            }
+            : { sendTransactionResult, ...transactionLinker };
     }
-    async sendCrossChainTransactions(sender, txs) {
+    async sendCrossChainTransactions(sender, txs, waitOptions) {
         const transactions = [];
         const transactionLinkers = [];
         const caller = sender.getSenderAddress();
+        this.debugLog(`Caller: ${caller}`);
+        this.debugLog('Preparing multiple cross-chain transactions');
         for (const { options, assets, evmProxyMsg } of txs) {
             const { transaction, transactionLinker } = await this.prepareCrossChainTransaction(evmProxyMsg, caller, assets, options);
             transactions.push(transaction);
             transactionLinkers.push(transactionLinker);
         }
-        console.log('*****Sending transactions: ', transactions);
+        this.debugLog(`*****Sending transactions: ${(0, Utils_1.formatObjectForLogging)(transactions)}`);
         await sender.sendShardTransactions(transactions, this.delay, this.network, this.TONParams.contractOpener);
+        if (waitOptions) {
+            this.debugLog(`Waiting for operation IDs`);
+            try {
+                const operationIds = await this.operationTracker.getOperationIdsByShardsKeys(transactionLinkers.map((linker) => linker.shardsKey), caller, {
+                    ...waitOptions,
+                    log: this.debugLog.bind(this),
+                    successCheck: (operationIds) => {
+                        return (Object.keys(operationIds).length == transactionLinkers.length &&
+                            Object.values(operationIds).every((ids) => ids.operationIds.length > 0));
+                    },
+                });
+                this.debugLog(`Operation IDs: ${(0, Utils_1.formatObjectForLogging)(operationIds)}`);
+                return transactionLinkers.map((linker) => ({
+                    ...linker,
+                    operationId: operationIds[linker.shardsKey].operationIds[0],
+                }));
+            }
+            catch (error) {
+                this.debugLog(`Error while waiting for operation IDs: ${error}`);
+            }
+        }
         return transactionLinkers;
     }
     // TODO move to sdk.TAC, sdk.TON
     async bridgeTokensToTON(signer, value, tonTarget, assets, tvmExecutorFee) {
+        this.debugLog('Bridging tokens to TON');
         if (assets == undefined) {
             assets = [];
         }
-        let tonAssets = [];
+        const tonAssets = [];
         for (const asset of assets) {
             if (asset.type == Struct_1.AssetType.FT) {
                 const tvmAddress = await this.getTVMTokenAddress(asset.address);
@@ -583,7 +682,9 @@ class TacSdk {
                 });
             }
         }
+        this.debugLog(`TON assets: ${(0, Utils_1.formatObjectForLogging)(tonAssets)}`);
         if (value > 0) {
+            this.debugLog('Adding native TAC to TON assets');
             const tvmAddress = await this.getTVMTokenAddress(await this.nativeTACAddress());
             tonAssets.push({
                 address: tvmAddress,
@@ -592,21 +693,28 @@ class TacSdk {
             });
         }
         const suggestedTONExecutorFee = await this.getTVMExecutorFeeInfo(tonAssets, Consts_1.TAC_SYMBOL);
+        this.debugLog(`Suggested TON executor fee: ${(0, Utils_1.formatObjectForLogging)(suggestedTONExecutorFee)}`);
         const crossChainLayerAddress = await this.TACParams.crossChainLayer.getAddress();
         for (const asset of assets) {
             if (asset.type == Struct_1.AssetType.FT) {
+                this.debugLog(`Approving token ${asset.address} for ${crossChainLayerAddress}`);
                 const tokenContract = this.artifacts.tac.wrappers.ERC20FactoryTAC.connect(asset.address, this.TACParams.provider);
                 const tx = await tokenContract.connect(signer).approve(crossChainLayerAddress, asset.rawAmount);
                 await tx.wait();
+                this.debugLog(`Approved ${asset.address} for ${crossChainLayerAddress}`);
             }
             if (asset.type == Struct_1.AssetType.NFT) {
+                this.debugLog(`Approving collection ${asset.collectionAddress} for ${crossChainLayerAddress}`);
                 const tokenContract = this.artifacts.tac.wrappers.ERC721FactoryTAC.connect(asset.collectionAddress, this.TACParams.provider);
                 const tx = await tokenContract.connect(signer).approve(crossChainLayerAddress, asset.itemIndex);
                 await tx.wait();
+                this.debugLog(`Approved ${asset.collectionAddress} for ${crossChainLayerAddress}`);
             }
         }
         const shardsKey = BigInt(Math.round(Math.random() * 1e18));
+        this.debugLog(`Shards key: ${shardsKey}`);
         const protocolFee = await this.TACParams.crossChainLayer.getProtocolFee();
+        this.debugLog(`Protocol fee: ${protocolFee}`);
         const outMessage = {
             shardsKey: shardsKey,
             tvmTarget: tonTarget,
@@ -631,10 +739,12 @@ class TacSdk {
         const encodedOutMessage = this.artifacts.tac.utils.encodeOutMessageV1(outMessage);
         const outMsgVersion = 1n;
         const totalValue = value + BigInt(outMessage.tvmProtocolFee) + BigInt(outMessage.tvmExecutorFee);
+        this.debugLog(`Total value: ${totalValue}`);
         const tx = await this.TACParams.crossChainLayer
             .connect(signer)
             .sendMessage(outMsgVersion, encodedOutMessage, { value: totalValue });
         await tx.wait();
+        this.debugLog(`Transaction hash: ${tx.hash}`);
         return tx.hash;
     }
     get getTrustedTACExecutors() {
@@ -644,28 +754,34 @@ class TacSdk {
         return this.TACParams.trustedTONExecutors;
     }
     async getEVMTokenAddress(tvmTokenAddress) {
+        this.debugLog(`Getting EVM token address for ${tvmTokenAddress}`);
         if (tvmTokenAddress !== this.nativeTONAddress) {
             (0, Utils_1.validateTVMAddress)(tvmTokenAddress);
             tvmTokenAddress = ton_1.Address.parse(tvmTokenAddress).toString({ bounceable: true });
             const { code: givenMinterCodeBOC } = await this.TONParams.contractOpener.getContractState((0, ton_1.address)(tvmTokenAddress));
             await (0, Utils_1.sleep)(this.delay * 1000);
             if (givenMinterCodeBOC && this.TONParams.jettonMinterCode.equals(ton_1.Cell.fromBoc(givenMinterCodeBOC)[0])) {
+                this.debugLog(`Computing EVM token address using jetton minter`);
                 const givenMinter = this.TONParams.contractOpener.open(new JettonMaster_1.JettonMaster((0, ton_1.address)(tvmTokenAddress)));
                 const evmAddress = await givenMinter.getEVMAddress();
                 await (0, Utils_1.sleep)(this.delay * 1000);
                 return evmAddress;
             }
         }
+        this.debugLog(`Computing EVM token address using token utils`);
         return this.TACParams.tokenUtils.computeAddress(tvmTokenAddress);
     }
     async getTVMTokenAddress(evmTokenAddress) {
+        this.debugLog(`Getting TVM token address for ${evmTokenAddress}`);
         (0, Utils_1.validateEVMAddress)(evmTokenAddress);
         const exists = await this.TACParams.tokenUtils['exists(address)'](evmTokenAddress);
         if (exists) {
+            this.debugLog(`Getting TVM token address using cross chain layer ERC20 factory`);
             const erc721Token = this.artifacts.tac.wrappers.CrossChainLayerERC20FactoryTAC.connect(evmTokenAddress, this.TACParams.provider);
             const info = await erc721Token.getInfo();
             return info.tvmAddress;
         }
+        this.debugLog(`Getting TVM token address using jetton minter`);
         const jettonMaster = JettonMaster_1.JettonMaster.createFromConfig({
             evmTokenAddress,
             crossChainLayerAddress: (0, ton_1.address)(this.TONParams.crossChainLayerAddress),
@@ -675,10 +791,12 @@ class TacSdk {
         return jettonMaster.address.toString();
     }
     async getTVMNFTAddress(evmNFTAddress, tokenId) {
+        this.debugLog(`Getting TVM NFT ${tokenId ? `item ${tokenId}` : 'collection'} address for ${evmNFTAddress}`);
         (0, Utils_1.validateEVMAddress)(evmNFTAddress);
         let nftCollection;
         const exists = await this.TACParams.tokenUtils['exists(address)'](evmNFTAddress);
         if (exists) {
+            this.debugLog(`Getting TVM NFT address using cross chain layer ERC721 factory`);
             const erc721Token = this.artifacts.tac.wrappers.CrossChainLayerERC721FactoryTAC.connect(evmNFTAddress, this.TACParams.provider);
             const info = await erc721Token.getInfo();
             nftCollection = this.TONParams.contractOpener.open(wrappers_1.NFTCollection.createFromAddress((0, ton_1.address)(info.tvmAddress)));
@@ -687,9 +805,12 @@ class TacSdk {
                 : (await nftCollection.getNFTAddressByIndex(tokenId)).toString();
         }
         else {
+            this.debugLog(`Getting TVM NFT address using TON NFT collection contract`);
             nftCollection = this.TONParams.contractOpener.open(wrappers_1.NFTCollection.createFromConfig({
-                ownerAddress: (0, ton_1.address)(this.TONParams.crossChainLayerAddress),
-                content: (0, ton_1.beginCell)().endCell(),
+                adminAddress: (0, ton_1.address)(this.TONParams.crossChainLayerAddress),
+                newAdminAddress: null,
+                commonContent: (0, ton_1.beginCell)().endCell(),
+                collectionContent: (0, ton_1.beginCell)().endCell(),
                 nftItemCode: this.TONParams.nftItemCode,
                 originalAddress: evmNFTAddress,
             }, this.TONParams.nftCollectionCode));
@@ -698,43 +819,50 @@ class TacSdk {
                 : 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
+                    // @ts-expect-error // bigint can be used, wrapper is not typed properly
                     index: tokenId,
                 }, this.TONParams.nftItemCode).address.toString();
         }
     }
     async getEVMNFTAddress(tvmNFTAddress, addressType) {
+        this.debugLog(`Getting EVM NFT address for ${tvmNFTAddress}`);
         (0, Utils_1.validateTVMAddress)(tvmNFTAddress);
         tvmNFTAddress = ton_1.Address.parse(tvmNFTAddress).toString({ bounceable: true });
         if (addressType == Struct_1.NFTAddressType.ITEM) {
+            this.debugLog(`Retrieving collection address for item ${tvmNFTAddress}`);
             tvmNFTAddress = (await this.getNFTItemData(tvmNFTAddress)).collectionAddress.toString();
+            this.debugLog(`Collection address: ${tvmNFTAddress}`);
             addressType = Struct_1.NFTAddressType.COLLECTION;
             await (0, Utils_1.sleep)(this.delay * 1000);
         }
         const { code: givenNFTCollection } = await this.TONParams.contractOpener.getContractState((0, ton_1.address)(tvmNFTAddress));
         await (0, Utils_1.sleep)(this.delay * 1000);
         if (givenNFTCollection && this.TONParams.nftCollectionCode.equals(ton_1.Cell.fromBoc(givenNFTCollection)[0])) {
+            this.debugLog(`Getting EVM NFT address using TON NFT collection contract`);
             const nftCollection = this.TONParams.contractOpener.open(wrappers_1.NFTCollection.createFromAddress((0, ton_1.address)(tvmNFTAddress)));
             const evmAddress = await nftCollection.getOriginalAddress();
             await (0, Utils_1.sleep)(this.delay * 1000);
             return evmAddress.toString();
         }
+        this.debugLog(`Computing EVM NFT address using token utils`);
         return this.TACParams.tokenUtils.computeAddressERC721(tvmNFTAddress);
     }
     async isContractDeployedOnTVM(address) {
         return (await this.TONParams.contractOpener.getContractState(ton_1.Address.parse(address))).state === 'active';
     }
     async simulateTACMessage(req) {
+        this.debugLog('Simulating TAC message');
         let lastError;
         for (const endpoint of this.liteSequencerEndpoints) {
             try {
                 const response = await axios_1.default.post(new URL('tac/simulator/simulate-message', endpoint).toString(), req, {
                     transformResponse: [Utils_1.toCamelCaseTransformer],
                 });
+                this.debugLog('TAC message simulation success');
                 return response.data.response;
             }
             catch (error) {
-                console.error(`Error while simulating with ${endpoint}:`, error);
+                this.debugLog(`Error while simulating with ${endpoint}: ${error}`);
                 lastError = error;
             }
         }

package/dist/sdk/Utils.d.ts

@@ -1,7 +1,7 @@
 import { Address, Cell } from '@ton/ton';
 import { AbiCoder } from 'ethers';
-import { EvmProxyMsg, FeeParams, TransactionLinker, ValidExecutors } from '../structs/Struct';
 import { RandomNumberByTimestamp } from '../structs/InternalStruct';
+import { EvmProxyMsg, FeeParams, TransactionLinker, ValidExecutors, WaitOptions } from '../structs/Struct';
 export declare const sleep: (ms: number) => Promise<unknown>;
 export declare function generateRandomNumber(interval: number): number;
 export declare function generateRandomNumberByTimestamp(): RandomNumberByTimestamp;
@@ -15,5 +15,7 @@ export declare function calculateEVMTokenAddress(abiCoder: AbiCoder, tokenUtilsA
 export declare const convertKeysToCamelCase: <T>(data: T) => T;
 export declare const calculateRawAmount: (amount: number, decimals: number) => bigint;
 export declare const calculateAmount: (rawAmount: bigint, decimals: number) => number;
-export declare const toCamelCaseTransformer: (data: any) => any;
+export declare const toCamelCaseTransformer: (data: string) => any;
 export declare const generateFeeData: (feeParams?: FeeParams) => Cell | undefined;
+export declare function waitUntilSuccess<T, A extends unknown[]>(options: WaitOptions<T> | undefined, operation: (...args: A) => Promise<T>, ...args: A): Promise<T>;
+export declare function formatObjectForLogging(obj: unknown): string;