@subwallet/extension-base 1.2.31-0 → 1.2.33-0

package/cjs/services/transaction-service/index.js

@@ -10,15 +10,16 @@ var _TransactionError = require("@subwallet/extension-base/background/errors/Tra
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
 var _constants = require("@subwallet/extension-base/constants");
 var _transfer = require("@subwallet/extension-base/core/logic-validation/transfer");
-var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _utils = require("@subwallet/extension-base/services/balance-service/helpers/subscribe/ton/utils");
+var _utils2 = require("@subwallet/extension-base/services/chain-service/utils");
 var _constants2 = require("@subwallet/extension-base/services/request-service/constants");
 var _constants3 = require("@subwallet/extension-base/services/transaction-service/constants");
 var _eventParser = require("@subwallet/extension-base/services/transaction-service/event-parser");
 var _helpers = require("@subwallet/extension-base/services/transaction-service/helpers");
-var _utils2 = require("@subwallet/extension-base/services/transaction-service/utils");
+var _utils3 = require("@subwallet/extension-base/services/transaction-service/utils");
 var _helpers2 = require("@subwallet/extension-base/services/wallet-connect-service/helpers");
 var _types = require("@subwallet/extension-base/types");
-var _utils3 = require("@subwallet/extension-base/utils");
+var _utils4 = require("@subwallet/extension-base/utils");
 var _mergeTransactionAndSignature = require("@subwallet/extension-base/utils/eth/mergeTransactionAndSignature");
 var _parseTransaction = require("@subwallet/extension-base/utils/eth/parseTransaction");
 var _number = require("@subwallet/extension-base/utils/number");
@@ -58,7 +59,7 @@ class TransactionService {
     // Check duplicated transaction
     const existed = this.processingTransactions.filter(item => item.address === transaction.address && item.chain === transaction.chain);
     if (existed.length > 0) {
-      return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.DUPLICATE_TRANSACTION)];
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.DUPLICATE_TRANSACTION)];
     }
     return [];
   }
@@ -90,25 +91,33 @@ class TransactionService {
     // Check support for transaction
     (0, _transfer.checkSupportForTransaction)(validationResponse, transaction);
     if (!chainInfo) {
-      validationResponse.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR, (0, _i18next.t)('Cannot find network')));
+      validationResponse.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR, (0, _i18next.t)('Cannot find network')));
     }
     const evmApi = this.state.chainService.getEvmApi(chainInfo.slug);
-    const isNeedEvmApi = transaction && !(0, _helpers.isSubstrateTransaction)(transaction) && !evmApi;
-    if (isNeedEvmApi) {
-      validationResponse.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.CHAIN_DISCONNECTED, undefined));
+    const tonApi = this.state.chainService.getTonApi(chainInfo.slug);
+    const isNoEvmApi = transaction && !(0, _helpers.isSubstrateTransaction)(transaction) && !(0, _helpers.isTonTransaction)(transaction) && !evmApi; // todo: should split isEvmTx && isNoEvmApi. Because other chains type also has no Evm Api
+    const isNoTonApi = transaction && (0, _helpers.isTonTransaction)(transaction) && !tonApi;
+    if (isNoEvmApi || isNoTonApi) {
+      validationResponse.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.CHAIN_DISCONNECTED, undefined));
     }
 
     // Estimate fee for transaction
     validationResponse.estimateFee = await (0, _transfer.estimateFeeForTransaction)(validationResponse, transaction, chainInfo, evmApi);
+    const chainInfoMap = this.state.chainService.getChainInfoMap();
 
     // Check account signing transaction
-    (0, _transfer.checkSigningAccountForTransaction)(validationResponse);
+    (0, _transfer.checkSigningAccountForTransaction)(validationResponse, chainInfoMap);
     const nativeTokenInfo = this.state.chainService.getNativeTokenInfo(chain);
     const nativeTokenAvailable = await this.state.balanceService.getTransferableBalance(address, chain, nativeTokenInfo.slug, extrinsicType);
 
     // Check available balance against transaction fee
     (0, _transfer.checkBalanceWithTransactionFee)(validationResponse, transactionInput, nativeTokenInfo, nativeTokenAvailable);
 
+    // Warnings Ton address if bounceable and not active
+    // if (transaction && isTonTransaction(transaction) && tonApi) {
+    //   await checkTonAddressBounceableAndAccountNotActive(tonApi, validationResponse);
+    // }
+
     // Check additional validations
     additionalValidator && (await additionalValidator(validationResponse));
     return validationResponse;
@@ -160,8 +169,9 @@ class TransactionService {
   }
   async handleTransaction(transaction) {
     const validatedTransaction = await this.validateTransaction(transaction);
+    const ignoreWarnings = validatedTransaction.ignoreWarnings || [];
     const stopByErrors = validatedTransaction.errors.length > 0;
-    const stopByWarnings = validatedTransaction.warnings.length > 0 && !validatedTransaction.ignoreWarnings;
+    const stopByWarnings = validatedTransaction.warnings.length > 0 && validatedTransaction.warnings.some(warning => !ignoreWarnings.includes(warning.warningType));
     if (stopByErrors || stopByWarnings) {
       // @ts-ignore
       'transaction' in validatedTransaction && delete validatedTransaction.transaction;
@@ -202,7 +212,7 @@ class TransactionService {
   }
   async sendTransaction(transaction) {
     // Send Transaction
-    const emitter = await (transaction.chainType === 'substrate' ? this.signAndSendSubstrateTransaction(transaction) : this.signAndSendEvmTransaction(transaction));
+    const emitter = await (transaction.chainType === 'substrate' ? this.signAndSendSubstrateTransaction(transaction) : transaction.chainType === 'evm' ? this.signAndSendEvmTransaction(transaction) : this.signAndSendTonTransaction(transaction));
     const {
       eventsHandler
     } = transaction;
@@ -223,13 +233,13 @@ class TransactionService {
       // this.handlePostProcessing(data.id); // might enable this later
       this.onFailed({
         ...data,
-        errors: [...data.errors, new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)]
+        errors: [...data.errors, new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)]
       });
     });
     emitter.on('timeout', data => {
       this.onTimeOut({
         ...data,
-        errors: [...data.errors, new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.TIMEOUT)]
+        errors: [...data.errors, new _TransactionError.TransactionError(_types.BasicTxErrorType.TIMEOUT)]
       });
     });
 
@@ -258,13 +268,13 @@ class TransactionService {
   getTransactionLink(id) {
     const transaction = this.getTransaction(id);
     const chainInfo = this.state.chainService.getChainInfoByKey(transaction.chain);
-    return (0, _utils2.getExplorerLink)(chainInfo, transaction.extrinsicHash, 'tx');
+    return (0, _utils3.getExplorerLink)(chainInfo, transaction.extrinsicHash, 'tx');
   }
   transactionToHistories(id, startBlock, nonce, eventLogs) {
     const transaction = this.getTransaction(id);
     const extrinsicType = transaction.extrinsicType;
     const chainInfo = this.state.chainService.getChainInfoByKey(transaction.chain);
-    const formattedTransactionAddress = (0, _utils3.reformatAddress)(transaction.address);
+    const formattedTransactionAddress = (0, _utils4.reformatAddress)(transaction.address);
     const historyItem = {
       origin: 'app',
       chain: transaction.chain,
@@ -286,7 +296,7 @@ class TransactionService {
       nonce: nonce !== null && nonce !== void 0 ? nonce : 0,
       startBlock: startBlock || 0
     };
-    const nativeAsset = (0, _utils._getChainNativeTokenBasicInfo)(chainInfo);
+    const nativeAsset = (0, _utils2._getChainNativeTokenBasicInfo)(chainInfo);
     const baseNativeAmount = {
       value: '0',
       decimals: nativeAsset.decimals,
@@ -297,7 +307,7 @@ class TransactionService {
     switch (extrinsicType) {
       case _KoniTypes.ExtrinsicType.TRANSFER_BALANCE:
         {
-          const inputData = (0, _utils2.parseTransactionData)(transaction.data);
+          const inputData = (0, _utils3.parseTransactionData)(transaction.data);
           historyItem.to = inputData.to;
           const sendingTokenInfo = this.state.chainService.getAssetBySlug(inputData.tokenSlug);
           historyItem.amount = {
@@ -310,7 +320,7 @@ class TransactionService {
         break;
       case _KoniTypes.ExtrinsicType.TRANSFER_TOKEN:
         {
-          const inputData = (0, _utils2.parseTransactionData)(transaction.data);
+          const inputData = (0, _utils3.parseTransactionData)(transaction.data);
           historyItem.to = inputData.to;
           const sendingTokenInfo = this.state.chainService.getAssetBySlug(inputData.tokenSlug);
           historyItem.amount = {
@@ -323,7 +333,7 @@ class TransactionService {
         break;
       case _KoniTypes.ExtrinsicType.TRANSFER_XCM:
         {
-          const inputData = (0, _utils2.parseTransactionData)(transaction.data);
+          const inputData = (0, _utils3.parseTransactionData)(transaction.data);
           historyItem.to = inputData.to;
           const sendingTokenInfo = this.state.chainService.getAssetBySlug(inputData.tokenSlug);
           historyItem.amount = {
@@ -343,7 +353,7 @@ class TransactionService {
         break;
       case _KoniTypes.ExtrinsicType.SEND_NFT:
         {
-          const inputData = (0, _utils2.parseTransactionData)(transaction.data);
+          const inputData = (0, _utils3.parseTransactionData)(transaction.data);
           historyItem.to = inputData.recipientAddress;
           historyItem.amount = {
             decimals: 0,
@@ -354,7 +364,7 @@ class TransactionService {
         break;
       case _KoniTypes.ExtrinsicType.STAKING_BOND:
         {
-          const data = (0, _utils2.parseTransactionData)(transaction.data);
+          const data = (0, _utils3.parseTransactionData)(transaction.data);
           historyItem.amount = {
             ...baseNativeAmount,
             value: data.amount || '0'
@@ -363,7 +373,7 @@ class TransactionService {
         break;
       case _KoniTypes.ExtrinsicType.STAKING_JOIN_POOL:
         {
-          const data = (0, _utils2.parseTransactionData)(transaction.data);
+          const data = (0, _utils3.parseTransactionData)(transaction.data);
           historyItem.amount = {
             ...baseNativeAmount,
             value: data.amount || '0'
@@ -373,11 +383,11 @@ class TransactionService {
         break;
       case _KoniTypes.ExtrinsicType.STAKING_UNBOND:
         {
-          const data = (0, _utils2.parseTransactionData)(transaction.data);
+          const data = (0, _utils3.parseTransactionData)(transaction.data);
           if (data.isLiquidStaking && data.derivativeTokenInfo && data.exchangeRate && data.inputTokenInfo) {
             historyItem.amount = {
-              decimals: (0, _utils._getAssetDecimals)(data.derivativeTokenInfo),
-              symbol: (0, _utils._getAssetSymbol)(data.derivativeTokenInfo),
+              decimals: (0, _utils2._getAssetDecimals)(data.derivativeTokenInfo),
+              symbol: (0, _utils2._getAssetSymbol)(data.derivativeTokenInfo),
               value: data.amount
             };
             historyItem.additionalInfo = {
@@ -395,7 +405,7 @@ class TransactionService {
         break;
       case _KoniTypes.ExtrinsicType.STAKING_LEAVE_POOL:
         {
-          const data = (0, _utils2.parseTransactionData)(transaction.data);
+          const data = (0, _utils3.parseTransactionData)(transaction.data);
           historyItem.to = data.address || '';
           historyItem.amount = {
             ...baseNativeAmount,
@@ -405,7 +415,7 @@ class TransactionService {
         break;
       case _KoniTypes.ExtrinsicType.STAKING_CLAIM_REWARD:
         {
-          const data = (0, _utils2.parseTransactionData)(transaction.data);
+          const data = (0, _utils3.parseTransactionData)(transaction.data);
           historyItem.amount = {
             ...baseNativeAmount,
             value: data.unclaimedReward || '0'
@@ -414,7 +424,7 @@ class TransactionService {
         break;
       case _KoniTypes.ExtrinsicType.STAKING_WITHDRAW:
         {
-          const data = (0, _utils2.parseTransactionData)(transaction.data);
+          const data = (0, _utils3.parseTransactionData)(transaction.data);
           const slug = data.slug;
           const poolHandler = this.state.earningService.getPoolHandler(slug);
           const amount = {
@@ -434,7 +444,7 @@ class TransactionService {
         }
       case _KoniTypes.ExtrinsicType.STAKING_CANCEL_UNSTAKE:
         {
-          const data = (0, _utils2.parseTransactionData)(transaction.data);
+          const data = (0, _utils3.parseTransactionData)(transaction.data);
           historyItem.amount = {
             ...baseNativeAmount,
             value: data.selectedUnstaking.claimable || '0'
@@ -444,7 +454,7 @@ class TransactionService {
       case _KoniTypes.ExtrinsicType.EVM_EXECUTE:
         {
           // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-          const data = (0, _utils2.parseTransactionData)(transaction.data);
+          const data = (0, _utils3.parseTransactionData)(transaction.data);
 
           // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
           historyItem.to = (data === null || data === void 0 ? void 0 : data.to) || '';
@@ -459,13 +469,13 @@ class TransactionService {
       // eslint-disable-next-line no-fallthrough
       case _KoniTypes.ExtrinsicType.MINT_VDOT:
         {
-          const params = (0, _utils2.parseTransactionData)(transaction.data);
+          const params = (0, _utils3.parseTransactionData)(transaction.data);
           const inputTokenInfo = this.state.chainService.getAssetBySlug(params.inputTokenSlug);
           const isFeePaidWithInputAsset = params.feeTokenSlug === params.inputTokenSlug;
           historyItem.amount = {
             value: params.amount,
-            symbol: (0, _utils._getAssetSymbol)(inputTokenInfo),
-            decimals: (0, _utils._getAssetDecimals)(inputTokenInfo)
+            symbol: (0, _utils2._getAssetSymbol)(inputTokenInfo),
+            decimals: (0, _utils2._getAssetDecimals)(inputTokenInfo)
           };
           const additionalInfo = {
             slug: params.slug,
@@ -473,7 +483,7 @@ class TransactionService {
             exchangeRate: params.exchangeRate
           };
           historyItem.additionalInfo = additionalInfo;
-          eventLogs && !(0, _utils._isChainEvmCompatible)(chainInfo) && (0, _eventParser.parseLiquidStakingEvents)(historyItem, eventLogs, inputTokenInfo, chainInfo, isFeePaidWithInputAsset, extrinsicType);
+          eventLogs && !(0, _utils2._isChainEvmCompatible)(chainInfo) && (0, _eventParser.parseLiquidStakingEvents)(historyItem, eventLogs, inputTokenInfo, chainInfo, isFeePaidWithInputAsset, extrinsicType);
           break;
         }
       case _KoniTypes.ExtrinsicType.UNSTAKE_QDOT:
@@ -481,15 +491,15 @@ class TransactionService {
       // eslint-disable-next-line no-fallthrough
       case _KoniTypes.ExtrinsicType.REDEEM_QDOT:
         {
-          const data = (0, _utils2.parseTransactionData)(transaction.data);
+          const data = (0, _utils3.parseTransactionData)(transaction.data);
           const yieldPoolInfo = data.poolInfo;
           if (yieldPoolInfo.metadata.derivativeAssets) {
             const inputTokenSlug = yieldPoolInfo.metadata.inputAsset;
             const inputTokenInfo = this.state.chainService.getAssetBySlug(inputTokenSlug);
             historyItem.amount = {
               value: data.amount,
-              symbol: (0, _utils._getAssetSymbol)(inputTokenInfo),
-              decimals: (0, _utils._getAssetDecimals)(inputTokenInfo)
+              symbol: (0, _utils2._getAssetSymbol)(inputTokenInfo),
+              decimals: (0, _utils2._getAssetDecimals)(inputTokenInfo)
             };
             eventLogs && (0, _eventParser.parseLiquidStakingFastUnstakeEvents)(historyItem, eventLogs, chainInfo, extrinsicType);
             const additionalInfo = {
@@ -520,7 +530,7 @@ class TransactionService {
       // eslint-disable-next-line no-fallthrough
       case _KoniTypes.ExtrinsicType.REDEEM_VDOT:
         {
-          const data = (0, _utils2.parseTransactionData)(transaction.data);
+          const data = (0, _utils3.parseTransactionData)(transaction.data);
           const yieldPoolInfo = data.poolInfo;
           const minAmountPercents = this.state.earningService.getMinAmountPercent();
           if (yieldPoolInfo.metadata.derivativeAssets) {
@@ -530,10 +540,10 @@ class TransactionService {
             const chainInfo = this.state.chainService.getChainInfoByKey(data.poolInfo.chain);
             historyItem.amount = {
               value: data.amount,
-              symbol: (0, _utils._getAssetSymbol)(derivativeTokenInfo),
-              decimals: (0, _utils._getAssetDecimals)(derivativeTokenInfo)
+              symbol: (0, _utils2._getAssetSymbol)(derivativeTokenInfo),
+              decimals: (0, _utils2._getAssetDecimals)(derivativeTokenInfo)
             };
-            eventLogs && !(0, _utils._isChainEvmCompatible)(chainInfo) && (0, _eventParser.parseLiquidStakingFastUnstakeEvents)(historyItem, eventLogs, chainInfo, extrinsicType);
+            eventLogs && !(0, _utils2._isChainEvmCompatible)(chainInfo) && (0, _eventParser.parseLiquidStakingFastUnstakeEvents)(historyItem, eventLogs, chainInfo, extrinsicType);
             const minAmountPercent = minAmountPercents[yieldPoolInfo.slug] || 1;
             const inputTokenSlug = yieldPoolInfo.metadata.inputAsset;
             const inputTokenInfo = this.state.chainService.getAssetBySlug(inputTokenSlug);
@@ -554,23 +564,23 @@ class TransactionService {
         }
       case _KoniTypes.ExtrinsicType.TOKEN_SPENDING_APPROVAL:
         {
-          const data = (0, _utils2.parseTransactionData)(transaction.data);
+          const data = (0, _utils3.parseTransactionData)(transaction.data);
           const inputAsset = this.state.chainService.getAssetBySlug(data.contractAddress);
           historyItem.amount = {
             value: '0',
-            symbol: (0, _utils._getAssetSymbol)(inputAsset),
-            decimals: (0, _utils._getAssetDecimals)(inputAsset)
+            symbol: (0, _utils2._getAssetSymbol)(inputAsset),
+            decimals: (0, _utils2._getAssetDecimals)(inputAsset)
           };
           break;
         }
       case _KoniTypes.ExtrinsicType.SWAP:
         {
-          const data = (0, _utils2.parseTransactionData)(transaction.data); // TODO: switch by provider
+          const data = (0, _utils3.parseTransactionData)(transaction.data); // TODO: switch by provider
           const inputAsset = this.state.chainService.getAssetBySlug(data.quote.pair.from);
           historyItem.amount = {
             value: data.quote.fromAmount,
-            symbol: (0, _utils._getAssetSymbol)(inputAsset),
-            decimals: (0, _utils._getAssetDecimals)(inputAsset)
+            symbol: (0, _utils2._getAssetSymbol)(inputAsset),
+            decimals: (0, _utils2._getAssetDecimals)(inputAsset)
           };
           historyItem.additionalInfo = data;
           break;
@@ -590,7 +600,7 @@ class TransactionService {
         switch (extrinsicType) {
           case _KoniTypes.ExtrinsicType.TRANSFER_XCM:
             {
-              const inputData = (0, _utils2.parseTransactionData)(transaction.data);
+              const inputData = (0, _utils3.parseTransactionData)(transaction.data);
               receiverHistory.chain = inputData.destinationNetworkKey;
               break;
             }
@@ -651,7 +661,7 @@ class TransactionService {
     // must be done after success/failure to make sure the transaction is finalized
     const transaction = this.getTransaction(id);
     if (transaction.extrinsicType === _KoniTypes.ExtrinsicType.SEND_NFT) {
-      const inputData = (0, _utils2.parseTransactionData)(transaction.data);
+      const inputData = (0, _utils3.parseTransactionData)(transaction.data);
       try {
         const sender = _uiKeyring.default.getPair(inputData.senderAddress);
         sender && this.state.dbService.handleNftTransfer(transaction.chain, [sender.address, _constants.ALL_ACCOUNT_KEY], inputData.nftItem).then(() => {
@@ -672,7 +682,7 @@ class TransactionService {
     } else if ([_KoniTypes.ExtrinsicType.STAKING_BOND, _KoniTypes.ExtrinsicType.STAKING_UNBOND, _KoniTypes.ExtrinsicType.STAKING_WITHDRAW, _KoniTypes.ExtrinsicType.STAKING_CANCEL_UNSTAKE, _KoniTypes.ExtrinsicType.STAKING_CLAIM_REWARD, _KoniTypes.ExtrinsicType.STAKING_JOIN_POOL, _KoniTypes.ExtrinsicType.STAKING_POOL_WITHDRAW, _KoniTypes.ExtrinsicType.STAKING_LEAVE_POOL].includes(transaction.extrinsicType)) {
       this.state.eventService.emit('transaction.submitStaking', transaction.chain);
     } else if (transaction.extrinsicType === _KoniTypes.ExtrinsicType.SWAP) {
-      const inputData = (0, _utils2.parseTransactionData)(transaction.data);
+      const inputData = (0, _utils3.parseTransactionData)(transaction.data);
       const toAssetSlug = inputData.quote.pair.to;
 
       // todo: consider async
@@ -800,30 +810,30 @@ class TransactionService {
   generateHashPayload(chain, transaction) {
     const chainInfo = this.state.chainService.getChainInfoByKey(chain);
     let txObject;
-    const max = (0, _utils3.anyNumberToBN)(transaction.maxFeePerGas);
+    const max = (0, _utils4.anyNumberToBN)(transaction.maxFeePerGas);
     if (max.gt(_number.BN_ZERO)) {
       var _transaction$nonce;
       txObject = {
         nonce: (_transaction$nonce = transaction.nonce) !== null && _transaction$nonce !== void 0 ? _transaction$nonce : 0,
-        maxFeePerGas: (0, _ethereumjsUtil.addHexPrefix)((0, _utils3.anyNumberToBN)(transaction.maxFeePerGas).toString(16)),
-        maxPriorityFeePerGas: (0, _ethereumjsUtil.addHexPrefix)((0, _utils3.anyNumberToBN)(transaction.maxPriorityFeePerGas).toString(16)),
-        gasLimit: (0, _ethereumjsUtil.addHexPrefix)((0, _utils3.anyNumberToBN)(transaction.gas).toString(16)),
+        maxFeePerGas: (0, _ethereumjsUtil.addHexPrefix)((0, _utils4.anyNumberToBN)(transaction.maxFeePerGas).toString(16)),
+        maxPriorityFeePerGas: (0, _ethereumjsUtil.addHexPrefix)((0, _utils4.anyNumberToBN)(transaction.maxPriorityFeePerGas).toString(16)),
+        gasLimit: (0, _ethereumjsUtil.addHexPrefix)((0, _utils4.anyNumberToBN)(transaction.gas).toString(16)),
         to: transaction.to,
-        value: (0, _ethereumjsUtil.addHexPrefix)((0, _utils3.anyNumberToBN)(transaction.value).toString(16)),
+        value: (0, _ethereumjsUtil.addHexPrefix)((0, _utils4.anyNumberToBN)(transaction.value).toString(16)),
         data: transaction.data,
-        chainId: (0, _utils._getEvmChainId)(chainInfo),
+        chainId: (0, _utils2._getEvmChainId)(chainInfo),
         type: 2
       };
     } else {
       var _transaction$nonce2;
       txObject = {
         nonce: (_transaction$nonce2 = transaction.nonce) !== null && _transaction$nonce2 !== void 0 ? _transaction$nonce2 : 0,
-        gasPrice: (0, _ethereumjsUtil.addHexPrefix)((0, _utils3.anyNumberToBN)(transaction.gasPrice).toString(16)),
-        gasLimit: (0, _ethereumjsUtil.addHexPrefix)((0, _utils3.anyNumberToBN)(transaction.gas).toString(16)),
+        gasPrice: (0, _ethereumjsUtil.addHexPrefix)((0, _utils4.anyNumberToBN)(transaction.gasPrice).toString(16)),
+        gasLimit: (0, _ethereumjsUtil.addHexPrefix)((0, _utils4.anyNumberToBN)(transaction.gas).toString(16)),
         to: transaction.to,
-        value: (0, _ethereumjsUtil.addHexPrefix)((0, _utils3.anyNumberToBN)(transaction.value).toString(16)),
+        value: (0, _ethereumjsUtil.addHexPrefix)((0, _utils4.anyNumberToBN)(transaction.value).toString(16)),
         data: transaction.data,
-        chainId: (0, _utils._getEvmChainId)(chainInfo),
+        chainId: (0, _utils2._getEvmChainId)(chainInfo),
         type: 0
       };
     }
@@ -843,13 +853,7 @@ class TransactionService {
     const chainInfo = this.state.chainService.getChainInfoByKey(chain);
     const hasError = !!(payload.errors && payload.errors.length > 0);
     const accountPair = _uiKeyring.default.getPair(address);
-    const account = {
-      address,
-      ...accountPair.meta
-    };
-    if (!payload.account) {
-      payload.account = account;
-    }
+    const account = (0, _utils4.pairToAccount)(accountPair);
 
     // Allow sign transaction
     payload.canSign = true;
@@ -865,6 +869,9 @@ class TransactionService {
         payload.parseData = payload.data;
       }
     }
+    if (!payload.address) {
+      payload.address = address;
+    }
     if ('data' in payload && payload.data === undefined) {
       delete payload.data;
     }
@@ -895,12 +902,12 @@ class TransactionService {
     const txObject = {
       nonce: (_payload$nonce = payload.nonce) !== null && _payload$nonce !== void 0 ? _payload$nonce : 0,
       from: payload.from,
-      gasPrice: (0, _utils3.anyNumberToBN)(payload.gasPrice).toNumber(),
-      maxFeePerGas: (0, _utils3.anyNumberToBN)(payload.maxFeePerGas).toNumber(),
-      maxPriorityFeePerGas: (0, _utils3.anyNumberToBN)(payload.maxPriorityFeePerGas).toNumber(),
-      gasLimit: (0, _utils3.anyNumberToBN)(payload.gas).toNumber(),
+      gasPrice: (0, _utils4.anyNumberToBN)(payload.gasPrice).toNumber(),
+      maxFeePerGas: (0, _utils4.anyNumberToBN)(payload.maxFeePerGas).toNumber(),
+      maxPriorityFeePerGas: (0, _utils4.anyNumberToBN)(payload.maxPriorityFeePerGas).toNumber(),
+      gasLimit: (0, _utils4.anyNumberToBN)(payload.gas).toNumber(),
       to: payload.to,
-      value: (0, _utils3.anyNumberToBN)(payload.value).toNumber(),
+      value: (0, _utils4.anyNumberToBN)(payload.value).toNumber(),
       data: payload.data,
       chainId: payload.chainId
     };
@@ -953,7 +960,7 @@ class TransactionService {
             const onError = error => {
               if (error) {
                 // TODO: Change type and message
-                eventData.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNABLE_TO_SEND, error.message));
+                eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNABLE_TO_SEND, error.message));
                 emitter.emit('error', eventData);
                 onComplete();
                 reject(error);
@@ -966,13 +973,13 @@ class TransactionService {
           });
         } else {
           this.removeTransaction(id);
-          eventData.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.USER_REJECT_REQUEST));
+          eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.USER_REJECT_REQUEST));
           emitter.emit('error', eventData);
         }
       }).catch(e => {
         this.removeTransaction(id);
         // TODO: Change type
-        eventData.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNABLE_TO_SIGN, e.message));
+        eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNABLE_TO_SIGN, e.message));
         emitter.emit('error', eventData);
       });
     } else {
@@ -1017,20 +1024,20 @@ class TransactionService {
             eventData.blockNumber = rs.blockNumber;
             emitter.emit('success', eventData);
           }).once('error', e => {
-            eventData.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.SEND_TRANSACTION_FAILED, (0, _i18next.t)(e.message)));
+            eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.SEND_TRANSACTION_FAILED, (0, _i18next.t)(e.message)));
             emitter.emit('error', eventData);
           }).catch(e => {
-            eventData.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNABLE_TO_SEND, (0, _i18next.t)(e.message)));
+            eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNABLE_TO_SEND, (0, _i18next.t)(e.message)));
             emitter.emit('error', eventData);
           });
         } else {
           this.removeTransaction(id);
-          eventData.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.USER_REJECT_REQUEST));
+          eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.USER_REJECT_REQUEST));
           emitter.emit('error', eventData);
         }
       }).catch(e => {
         this.removeTransaction(id);
-        eventData.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNABLE_TO_SIGN, (0, _i18next.t)(e.message)));
+        eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNABLE_TO_SIGN, (0, _i18next.t)(e.message)));
         emitter.emit('error', eventData);
       });
     }
@@ -1070,7 +1077,7 @@ class TransactionService {
       },
       withSignedTransaction: true
     };
-    if ((0, _utils3._isRuntimeUpdated)(signedExtensions)) {
+    if ((0, _utils4._isRuntimeUpdated)(signedExtensions)) {
       const metadataHash = await this.state.chainService.calculateMetadataHash(chain);
       if (metadataHash) {
         signerOption.mode = 1;
@@ -1120,7 +1127,7 @@ class TransactionService {
               }
             } = _ref12;
             if (method === 'ExtrinsicFailed') {
-              eventData.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.SEND_TRANSACTION_FAILED, error.toString()));
+              eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.SEND_TRANSACTION_FAILED, error.toString()));
               emitter.emit('error', eventData);
             } else if (method === 'ExtrinsicSuccess') {
               emitter.emit('success', eventData);
@@ -1128,12 +1135,105 @@ class TransactionService {
           });
         }
       }).catch(e => {
-        eventData.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.SEND_TRANSACTION_FAILED, e.message));
+        eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.SEND_TRANSACTION_FAILED, e.message));
+        emitter.emit('error', eventData);
+      });
+    }).catch(e => {
+      this.removeTransaction(id);
+      eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNABLE_TO_SIGN, e.message));
+      emitter.emit('error', eventData);
+    });
+    return emitter;
+  }
+  signAndSendTonTransaction(_ref13) {
+    let {
+      address,
+      chain,
+      extrinsicType,
+      id,
+      transaction,
+      url
+    } = _ref13;
+    const walletContract = _uiKeyring.default.getPair(address).ton.currentContract;
+    const emitter = new _eventemitter.default();
+    const eventData = {
+      id,
+      errors: [],
+      warnings: [],
+      extrinsicHash: id
+    };
+    const payload = transaction;
+    const signer = message => {
+      return new Promise(resolve => {
+        this.state.requestService.addConfirmationTon(id, url || _constants2.EXTENSION_REQUEST_URL, 'tonSendTransactionRequest', {
+          ...payload,
+          messagePayload: (0, _utils.cellToBase64Str)(message),
+          messages: []
+        }, {}).then(_ref14 => {
+          let {
+            isApproved,
+            payload
+          } = _ref14;
+          if (!isApproved) {
+            this.removeTransaction(id);
+            eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.USER_REJECT_REQUEST));
+            emitter.emit('error', eventData);
+          } else {
+            if (!payload) {
+              throw new Error('Bad signature');
+            }
+            resolve(Buffer.from((0, _util.hexToU8a)(payload)));
+          }
+        }).catch(e => {
+          this.removeTransaction(id);
+          eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNABLE_TO_SIGN, (0, _i18next.t)(e.message)));
+          emitter.emit('error', eventData);
+        });
+      });
+    };
+    const tonTransactionConfig = transaction;
+    const seqno = tonTransactionConfig.seqno;
+    const messages = tonTransactionConfig.messages;
+    const transferObjectPromise = (0, _utils.getTransferCellPromise)(walletContract, signer, payload, seqno, messages);
+    transferObjectPromise.then(tx => {
+      // Emit signed event
+      emitter.emit('signed', eventData);
+      const boc = (0, _utils.externalMessage)(walletContract, seqno, tx).toBoc().toString('base64');
+      this.handleTransactionTimeout(emitter, eventData);
+      emitter.emit('send', eventData); // This event is needed after sending transaction with queue
+
+      const tonApi = this.state.chainService.getTonApi(chain);
+      tonApi.sendTonTransaction(boc).then(externalMsgHash => {
+        // the externalMsgHash is the hash of first message, not the hash of transaction.
+        if (!externalMsgHash) {
+          return;
+        }
+        tonApi.getStatusByExtMsgHash(externalMsgHash, extrinsicType).then(_ref15 => {
+          let [status, hex] = _ref15;
+          if (status && hex) {
+            eventData.extrinsicHash = hex;
+            emitter.emit('extrinsicHash', eventData);
+            emitter.emit('success', eventData);
+          }
+          if (!status && hex) {
+            eventData.extrinsicHash = hex;
+            emitter.emit('extrinsicHash', eventData);
+            eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.SEND_TRANSACTION_FAILED));
+            emitter.emit('error', eventData);
+          }
+        }).catch(e => {
+          eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.SEND_TRANSACTION_FAILED, e.message));
+          emitter.emit('error', eventData);
+        });
+
+        // todo: handle status of externalMsgHash
+      }).catch(e => {
+        eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.SEND_TRANSACTION_FAILED, e.message));
         emitter.emit('error', eventData);
       });
     }).catch(e => {
       this.removeTransaction(id);
-      eventData.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNABLE_TO_SIGN, e.message));
+      eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNABLE_TO_SIGN, e.message));
       emitter.emit('error', eventData);
     });
     return emitter;
@@ -1142,7 +1242,7 @@ class TransactionService {
     const timeout = setTimeout(() => {
       const transaction = this.getTransaction(eventData.id);
       if (transaction.status !== _KoniTypes.ExtrinsicStatus.SUCCESS && transaction.status !== _KoniTypes.ExtrinsicStatus.FAIL) {
-        eventData.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.TIMEOUT, (0, _i18next.t)('Transaction timeout')));
+        eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.TIMEOUT, (0, _i18next.t)('Transaction timeout')));
         emitter.emit('timeout', eventData);
         clearTimeout(timeout);
       }

package/cjs/services/wallet-connect-service/handler/PolkadotRequestHandler.js

@@ -62,10 +62,7 @@ class PolkadotRequestHandler {
         address: address,
         data: param.message,
         type: 'bytes'
-      }), {
-        address,
-        ...pair.meta
-      }, (0, _helpers.getWCId)(id)).then(async _ref => {
+      }), (0, _helpers.getWCId)(id)).then(async _ref => {
         let {
           signature
         } = _ref;
@@ -81,12 +78,7 @@ class PolkadotRequestHandler {
     } else if (method === _types.POLKADOT_SIGNING_METHODS.POLKADOT_SIGN_TRANSACTION) {
       const param = (0, _helpers.parseRequestParams)(request.params);
       (0, _classPrivateFieldLooseBase2.default)(this, _checkAccount)[_checkAccount](param.address, sessionAccounts);
-      const pair = _uiKeyring.default.getPair(param.address);
-      const address = pair.address;
-      (0, _classPrivateFieldLooseBase2.default)(this, _requestService)[_requestService].sign(url, new _RequestExtrinsicSign.default(param.transactionPayload), {
-        address,
-        ...pair.meta
-      }, (0, _helpers.getWCId)(id)).then(async _ref2 => {
+      (0, _classPrivateFieldLooseBase2.default)(this, _requestService)[_requestService].sign(url, new _RequestExtrinsicSign.default(param.transactionPayload), (0, _helpers.getWCId)(id)).then(async _ref2 => {
         let {
           signature
         } = _ref2;