@subwallet/extension-base 1.3.72-0 → 1.3.74-0

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

@@ -16,9 +16,10 @@ var _constants2 = require("@subwallet/extension-base/services/request-service/co
 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 _types = require("@subwallet/extension-base/services/transaction-service/types");
 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 _types2 = require("@subwallet/extension-base/types");
 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");
@@ -32,6 +33,7 @@ var _eventemitter = _interopRequireDefault(require("eventemitter3"));
 var _i18next = require("i18next");
 var _rxjs = require("rxjs");
 var _util = require("@polkadot/util");
+var _utilCrypto = require("@polkadot/util-crypto");
 var _interface = require("../open-gov/interface");
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
@@ -41,6 +43,7 @@ class TransactionService {
   aliveProcessMap = new Map();
   transactionSubject = new _rxjs.BehaviorSubject({});
   aliveProcessSubject = new _rxjs.BehaviorSubject(this.aliveProcessMap);
+  previousWrappedTxId = {};
   cacheProcessInfo = {};
   get transactions() {
     return this.transactionSubject.getValue();
@@ -59,9 +62,9 @@ class TransactionService {
   }
   checkDuplicate(transaction) {
     // Check duplicated transaction
-    const existed = this.processingTransactions.filter(item => item.address === transaction.address && item.chain === transaction.chain);
+    const existed = this.processingTransactions.filter(item => item.address === transaction.address && item.chain === transaction.chain && item.id !== transaction.id);
     if (existed.length > 0) {
-      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.DUPLICATE_TRANSACTION)];
+      return [new _TransactionError.TransactionError(_types2.BasicTxErrorType.DUPLICATE_TRANSACTION)];
     }
     return [];
   }
@@ -102,7 +105,7 @@ class TransactionService {
     // Check support for transaction
     (0, _transfer.checkSupportForTransaction)(validationResponse, transaction);
     if (!chainInfo) {
-      validationResponse.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR, (0, _i18next.t)('bg.TRANSACTION_SERVICE.services.service.transaction.cannotFindNetwork')));
+      validationResponse.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.INTERNAL_ERROR, (0, _i18next.t)('bg.TRANSACTION_SERVICE.services.service.transaction.cannotFindNetwork')));
     }
     const substrateApi = this.state.chainService.getSubstrateApi(chainInfo.slug);
     const evmApi = this.state.chainService.getEvmApi(chainInfo.slug);
@@ -116,7 +119,7 @@ class TransactionService {
     const isNoCardanoApi = transaction && (0, _helpers.isCardanoTransaction)(transaction) && !cardanoApi;
     const isNoBitcoinApi = transaction && (0, _helpers.isBitcoinTransaction)(transaction) && !bitcoinApi;
     if (isNoEvmApi || isNoTonApi || isNoCardanoApi || isNoBitcoinApi) {
-      validationResponse.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.CHAIN_DISCONNECTED, undefined));
+      validationResponse.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.CHAIN_DISCONNECTED, undefined));
     }
 
     // Estimate fee for transaction
@@ -127,26 +130,52 @@ class TransactionService {
     const isNonNativeTokenPayFee = tokenPayFeeSlug && !(0, _utils2._isNativeTokenBySlug)(tokenPayFeeSlug);
     const nonNativeTokenPayFeeInfo = isNonNativeTokenPayFee ? this.state.chainService.getAssetBySlug(tokenPayFeeSlug) : undefined;
     const priceMap = (await this.state.priceService.getPrice()).priceMap;
-
-    // Get signer account
-    let signer = address;
-    const signerSubstrateProxyAddress = transactionInput.signerSubstrateProxyAddress;
     if (!transactionInput.skipFeeRecalculation) {
-      validationResponse.estimateFee = await (0, _transfer.estimateFeeForTransaction)(validationResponse, transaction, chainInfo, evmApi, substrateApi, priceMap, feeInfo, nativeTokenInfo, nonNativeTokenPayFeeInfo, transactionInput.isTransferLocalTokenAndPayThatTokenAsFee, signerSubstrateProxyAddress);
+      validationResponse.estimateFee = await (0, _transfer.estimateFeeForTransaction)(validationResponse, transaction, chainInfo, evmApi, substrateApi, priceMap, feeInfo, nativeTokenInfo, nonNativeTokenPayFeeInfo, transactionInput.isTransferLocalTokenAndPayThatTokenAsFee);
     }
     const chainInfoMap = this.state.chainService.getChainInfoMap();
-    let substrateProxyAccountNativeTokenAvailable;
-    if (signerSubstrateProxyAddress && !(0, _utils4.isSameAddress)(signerSubstrateProxyAddress, address)) {
-      signer = signerSubstrateProxyAddress;
-      substrateProxyAccountNativeTokenAvailable = await this.state.balanceService.getTransferableBalance(signerSubstrateProxyAddress, chain, nativeTokenInfo.slug, extrinsicType);
+    if (transaction && (0, _helpers.isSubstrateTransaction)(transaction)) {
+      var _chainInfo$substrateI, _chainInfo$substrateI2;
+      if ((_chainInfo$substrateI = chainInfo.substrateInfo) !== null && _chainInfo$substrateI !== void 0 && _chainInfo$substrateI.supportMultisig && !validationResponse.wrappingStatus) {
+        const pair = _uiKeyring.default.getPair(address);
+        if (pair.meta.isMultisig) {
+          validationResponse.wrappingStatus = _types.SubstrateTransactionWrappingStatus.WRAPPABLE;
+          const pendingTransaction = this.state.multisigService.getPendingTxsForMultisigAddress({
+            multisigAddress: address,
+            chain
+          });
+          if (pendingTransaction.length > 0) {
+            const extrinsicTransaction = transactionInput.transaction;
+            const callData = extrinsicTransaction.method.toHex();
+            const callHash = (0, _utilCrypto.blake2AsHex)(callData);
+            const isExistPendingTx = pendingTransaction.find(tx => tx.callHash === callHash);
+            if (isExistPendingTx) {
+              validationResponse.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.DUPLICATE_TRANSACTION, (0, _i18next.t)('bg.TRANSACTION_SERVICE.services.service.transaction.existingMultisigPendingTransaction')));
+            }
+          }
+        }
+      }
+      if ((_chainInfo$substrateI2 = chainInfo.substrateInfo) !== null && _chainInfo$substrateI2 !== void 0 && _chainInfo$substrateI2.supportProxy && !validationResponse.wrappingStatus && !isNonNativeTokenPayFee) {
+        const {
+          substrateProxyAccounts
+        } = await this.state.substrateProxyAccountService.getSubstrateProxyAccountGroup({
+          address,
+          chain,
+          type: validationResponse.extrinsicType,
+          excludedSubstrateProxyAccounts: validationResponse.data.selectedSubstrateProxyAccounts
+        });
+        if (substrateProxyAccounts.length) {
+          validationResponse.wrappingStatus = _types.SubstrateTransactionWrappingStatus.WRAPPABLE;
+        }
+      }
     }
 
     // Check account signing transaction
-    (0, _transfer.checkSigningAccountForTransaction)(validationResponse, chainInfoMap, signer);
+    (0, _transfer.checkSigningAccountForTransaction)(validationResponse, chainInfoMap, address);
     const nativeTokenAvailable = await this.state.balanceService.getBalanceByType(address, chain, nativeTokenInfo.slug, transactionInput.balanceType, extrinsicType);
 
     // Check available balance against transaction fee
-    (0, _transfer.checkBalanceWithTransactionFee)(validationResponse, transactionInput, nativeTokenInfo, nativeTokenAvailable, substrateProxyAccountNativeTokenAvailable);
+    (0, _transfer.checkBalanceWithTransactionFee)(validationResponse, transactionInput, nativeTokenInfo, nativeTokenAvailable);
 
     // Warnings Ton address if bounceable and not active
     // if (transaction && isTonTransaction(transaction) && tonApi) {
@@ -241,6 +270,14 @@ class TransactionService {
 
     // Add Transaction
     transactions[transaction.id] = transaction;
+
+    // Store previous wrapped tx id for multisig tx to remove it when create new wrapped tx
+    if (transaction.wrappingStatus === _types.SubstrateTransactionWrappingStatus.WRAP_RESULT) {
+      const data = transaction.data;
+      if (data.transactionId) {
+        this.previousWrappedTxId[data.transactionId] = transaction.id;
+      }
+    }
     this.transactionSubject.next({
       ...transactions
     });
@@ -269,6 +306,135 @@ class TransactionService {
       warnings: []
     };
   }
+
+  /**
+   * Wrapped transaction flow:
+   *
+   * Create base transaction (WRAPPABLE)
+   *   - skip fee validation
+   *   - NOT submitted to chain
+   *   - acts as the logical / UI-facing transaction
+   *   ↓
+   * Inject event emitter into base transaction
+   *   - base transaction listens to wrapped transaction events
+   *   - used to resolve the original transaction promise
+   *   ↓
+   * User selects signer in UI
+   *   - proxy account or multisig signatory
+   *   ↓
+   * Prepare wrapped transaction
+   *   - resolve actual signer
+   *   - build wrapped extrinsic (proxy / multisig)
+   *   - attach validators & event forwarders
+   *   ↓
+   * Mark base transaction as WRAP_SOURCE
+   *   ↓
+   * Create & submit wrapped transaction (WRAP_RESULT)
+   *   ↓
+   * Forward wrapped transaction events → base transaction
+   *   ↓
+   * Cleanup temporary data
+   *
+   */
+  async handleWrappedTransaction(transaction) {
+    const transactionData = transaction.data;
+
+    // Origin tx id:
+    // - transactionData.transactionId: wrapped from existing tx
+    // - transaction.id: direct wrapped tx ( when transaction was signed by proxied address )
+    const originTransactionId = transactionData.transactionId || transaction.id || '';
+
+    // Remove previous wrapped transaction (select signer flow)
+    if (this.previousWrappedTxId[originTransactionId]) {
+      this.removeTransaction(this.previousWrappedTxId[originTransactionId]);
+    }
+
+    /**
+     * ─────────────────────────────
+     * Validation phase
+     * ─────────────────────────────
+     */
+    const validatedTransaction = await this.validateTransaction(transaction);
+    const ignoreWarnings = validatedTransaction.ignoreWarnings || [];
+    const hasBlockingErrors = validatedTransaction.errors.length > 0;
+    const hasBlockingWarnings = validatedTransaction.warnings.length > 0 && validatedTransaction.warnings.some(warning => !ignoreWarnings.includes(warning.warningType));
+    if (hasBlockingErrors || hasBlockingWarnings) {
+      // Cleanup runtime-only fields before returning
+      // @ts-ignore
+      'transaction' in validatedTransaction && delete validatedTransaction.transaction;
+      'additionalValidator' in validatedTransaction && delete validatedTransaction.additionalValidator;
+      'eventsHandler' in validatedTransaction && delete validatedTransaction.eventsHandler;
+      // Remove emitter before returning response
+      'emitterTransaction' in validatedTransaction && delete validatedTransaction.emitterTransaction;
+      return validatedTransaction;
+    }
+
+    // Validation passed → warnings already acknowledged
+    validatedTransaction.warnings = [];
+
+    /**
+     * ─────────────────────────────
+     * Submit wrapped transaction
+     * ─────────────────────────────
+     */
+
+    // Mark original transaction as wrapped
+    if (transactionData.transactionId) {
+      this.updateTransaction(transactionData.transactionId, {
+        wrappingStatus: _types.SubstrateTransactionWrappingStatus.WRAP_SOURCE,
+        estimateFee: validatedTransaction.estimateFee,
+        errors: []
+      });
+    }
+    const emitter = await this.addTransaction(validatedTransaction);
+
+    /**
+     * Async side-effect:
+     * - wait for signed / success / error / timeout
+     * - mutate validatedTransaction accordingly
+     */
+    if (emitter) {
+      new Promise(resolve => {
+        const resolveWithResult = data => {
+          validatedTransaction.id = data.id;
+          validatedTransaction.extrinsicHash = data.extrinsicHash;
+          resolve();
+        };
+        if (transaction.resolveOnDone) {
+          emitter.on('success', resolveWithResult);
+        } else {
+          emitter.on('signed', resolveWithResult);
+        }
+        emitter.on('error', data => {
+          if (data.errors.length > 0) {
+            validatedTransaction.errors.push(...data.errors);
+            resolve();
+          }
+        });
+        emitter.on('timeout', data => {
+          if (transaction.errorOnTimeOut && data.errors.length > 0) {
+            validatedTransaction.errors.push(...data.errors);
+            resolve();
+          }
+        });
+      }).finally(() => {
+        // Cleanup runtime-only fields
+        // @ts-ignore
+        'transaction' in validatedTransaction && delete validatedTransaction.transaction;
+        'additionalValidator' in validatedTransaction && delete validatedTransaction.additionalValidator;
+        'eventsHandler' in validatedTransaction && delete validatedTransaction.eventsHandler;
+
+        // Remove base multisig transaction after approval
+        if (transactionData.multisigMetadata && transactionData.transactionId) {
+          this.removeTransaction(transactionData.transactionId);
+        }
+      });
+    }
+
+    // Remove emitter before returning response
+    'emitterTransaction' in validatedTransaction && delete validatedTransaction.emitterTransaction;
+    return validatedTransaction;
+  }
   async handleTransaction(transaction) {
     const validatedTransaction = await this.validateTransaction(transaction);
     const ignoreWarnings = validatedTransaction.ignoreWarnings || [];
@@ -284,7 +450,6 @@ class TransactionService {
     validatedTransaction.warnings = [];
     const emitter = await this.addTransaction(validatedTransaction);
     await new Promise((resolve, reject) => {
-      // TODO
       if (transaction.resolveOnDone) {
         emitter.on('success', data => {
           validatedTransaction.id = data.id;
@@ -336,7 +501,7 @@ class TransactionService {
     // Fill transaction default info
     const transactionUpdated = this.fillTransactionDefaultInfo(validatedTransaction);
 
-    // Add Transaction
+    // Add transaction
     transactionsSubject[transactionUpdated.id] = {
       ...transactionUpdated,
       emitterTransaction: emitter
@@ -361,7 +526,7 @@ class TransactionService {
       }
       this.onFailed({
         ...data,
-        errors: [...data.errors, new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)]
+        errors: [...data.errors, new _TransactionError.TransactionError(_types2.BasicTxErrorType.INTERNAL_ERROR)]
       });
     });
     emitter.on('send', data => {
@@ -373,7 +538,7 @@ class TransactionService {
     emitter.on('timeout', data => {
       this.onTimeOut({
         ...data,
-        errors: [...data.errors, new _TransactionError.TransactionError(_types.BasicTxErrorType.TIMEOUT)]
+        errors: [...data.errors, new _TransactionError.TransactionError(_types2.BasicTxErrorType.TIMEOUT)]
       });
     });
 
@@ -500,6 +665,13 @@ class TransactionService {
       eventsHandler,
       step
     } = transaction;
+
+    // Inject emitter into transaction for wrapped tx flow
+    if (transaction.wrappingStatus === _types.SubstrateTransactionWrappingStatus.WRAPPABLE) {
+      this.updateTransaction(transaction.id, {
+        emitterTransaction: emitter
+      });
+    }
     emitter.on('signed', data => {
       this.onSigned(data);
     });
@@ -508,7 +680,7 @@ class TransactionService {
       if (step) {
         this.updateProcessStepStatus(step, {
           transactionId: transaction.id,
-          status: _types.StepStatus.SUBMITTING,
+          status: _types2.StepStatus.SUBMITTING,
           chain: transaction.chain
         });
       }
@@ -518,7 +690,7 @@ class TransactionService {
       if (step) {
         this.updateProcessStepStatus(step, {
           extrinsicHash: data.extrinsicHash,
-          status: _types.StepStatus.PROCESSING
+          status: _types2.StepStatus.PROCESSING
         });
       }
     });
@@ -527,7 +699,7 @@ class TransactionService {
       this.onSuccess(data);
       if (step) {
         this.updateProcessStepStatus(step, {
-          status: _types.StepStatus.COMPLETE
+          status: _types2.StepStatus.COMPLETE
         });
       }
     });
@@ -535,12 +707,12 @@ class TransactionService {
       // this.handlePostProcessing(data.id); // might enable this later
       this.onFailed({
         ...data,
-        errors: [...data.errors, new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)]
+        errors: [...data.errors, new _TransactionError.TransactionError(_types2.BasicTxErrorType.INTERNAL_ERROR)]
       });
       if (step) {
         const rejectError = data.errors.find(error => {
           // TODO: REFACTOR ERROR CODE
-          return [_types.BasicTxErrorType.UNABLE_TO_SIGN, _types.BasicTxErrorType.USER_REJECT_REQUEST].includes(error.errorType);
+          return [_types2.BasicTxErrorType.UNABLE_TO_SIGN, _types2.BasicTxErrorType.USER_REJECT_REQUEST].includes(error.errorType);
         });
 
         /**
@@ -551,7 +723,7 @@ class TransactionService {
           this.deleteProcess(step);
         } else {
           this.updateProcessStepStatus(step, {
-            status: _types.StepStatus.FAILED
+            status: _types2.StepStatus.FAILED
           });
         }
       }
@@ -559,11 +731,11 @@ class TransactionService {
     emitter.on('timeout', data => {
       this.onTimeOut({
         ...data,
-        errors: [...data.errors, new _TransactionError.TransactionError(_types.BasicTxErrorType.TIMEOUT)]
+        errors: [...data.errors, new _TransactionError.TransactionError(_types2.BasicTxErrorType.TIMEOUT)]
       });
       if (step) {
         this.updateProcessStepStatus(step, {
-          status: _types.StepStatus.TIMEOUT
+          status: _types2.StepStatus.TIMEOUT
         });
       }
     });
@@ -584,7 +756,7 @@ class TransactionService {
       if (step) {
         this.updateProcessStepStatus(step, {
           transactionId: transaction.id,
-          status: _types.StepStatus.SUBMITTING,
+          status: _types2.StepStatus.SUBMITTING,
           chain: transaction.chain
         });
       }
@@ -593,14 +765,14 @@ class TransactionService {
       if (step) {
         this.updateProcessStepStatus(step, {
           extrinsicHash: data.extrinsicHash,
-          status: _types.StepStatus.PROCESSING
+          status: _types2.StepStatus.PROCESSING
         });
       }
     });
     emitter.on('success', data => {
       if (step) {
         this.updateProcessStepStatus(step, {
-          status: _types.StepStatus.COMPLETE
+          status: _types2.StepStatus.COMPLETE
         });
       }
     });
@@ -608,12 +780,12 @@ class TransactionService {
       // this.handlePostProcessing(data.id); // might enable this later
       this.onFailed({
         ...data,
-        errors: [...data.errors, new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)]
+        errors: [...data.errors, new _TransactionError.TransactionError(_types2.BasicTxErrorType.INTERNAL_ERROR)]
       });
       if (step) {
         const rejectError = data.errors.find(error => {
           // TODO: REFACTOR ERROR CODE
-          return [_types.BasicTxErrorType.UNABLE_TO_SIGN, _types.BasicTxErrorType.USER_REJECT_REQUEST].includes(error.errorType);
+          return [_types2.BasicTxErrorType.UNABLE_TO_SIGN, _types2.BasicTxErrorType.USER_REJECT_REQUEST].includes(error.errorType);
         });
 
         /**
@@ -624,7 +796,7 @@ class TransactionService {
           this.deleteProcess(step);
         } else {
           this.updateProcessStepStatus(step, {
-            status: _types.StepStatus.FAILED
+            status: _types2.StepStatus.FAILED
           });
         }
       }
@@ -647,7 +819,7 @@ class TransactionService {
       if (step) {
         this.updateProcessStepStatus(step, {
           transactionId: transaction.id,
-          status: _types.StepStatus.SUBMITTING,
+          status: _types2.StepStatus.SUBMITTING,
           chain: transaction.chain
         });
       }
@@ -657,7 +829,7 @@ class TransactionService {
       if (step) {
         this.updateProcessStepStatus(step, {
           extrinsicHash: data.extrinsicHash,
-          status: _types.StepStatus.PROCESSING
+          status: _types2.StepStatus.PROCESSING
         });
       }
     });
@@ -666,7 +838,7 @@ class TransactionService {
       this.onSuccess(data);
       if (step) {
         this.updateProcessStepStatus(step, {
-          status: _types.StepStatus.COMPLETE
+          status: _types2.StepStatus.COMPLETE
         });
       }
     });
@@ -674,12 +846,12 @@ class TransactionService {
       // this.handlePostProcessing(data.id); // might enable this later
       this.onFailed({
         ...data,
-        errors: [...data.errors, new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)]
+        errors: [...data.errors, new _TransactionError.TransactionError(_types2.BasicTxErrorType.INTERNAL_ERROR)]
       });
       if (step) {
         const rejectError = data.errors.find(error => {
           // TODO: REFACTOR ERROR CODE
-          return [_types.BasicTxErrorType.UNABLE_TO_SIGN, _types.BasicTxErrorType.USER_REJECT_REQUEST].includes(error.errorType);
+          return [_types2.BasicTxErrorType.UNABLE_TO_SIGN, _types2.BasicTxErrorType.USER_REJECT_REQUEST].includes(error.errorType);
         });
 
         /**
@@ -690,7 +862,7 @@ class TransactionService {
           this.deleteProcess(step);
         } else {
           this.updateProcessStepStatus(step, {
-            status: _types.StepStatus.FAILED
+            status: _types2.StepStatus.FAILED
           });
         }
       }
@@ -698,11 +870,11 @@ class TransactionService {
     emitter.on('timeout', data => {
       this.onTimeOut({
         ...data,
-        errors: [...data.errors, new _TransactionError.TransactionError(_types.BasicTxErrorType.TIMEOUT)]
+        errors: [...data.errors, new _TransactionError.TransactionError(_types2.BasicTxErrorType.TIMEOUT)]
       });
       if (step) {
         this.updateProcessStepStatus(step, {
-          status: _types.StepStatus.TIMEOUT
+          status: _types2.StepStatus.TIMEOUT
         });
       }
     });
@@ -719,6 +891,9 @@ class TransactionService {
         ...this.transactions
       });
     }
+    if (this.previousWrappedTxId[id]) {
+      delete this.previousWrappedTxId[id];
+    }
   }
   updateTransaction(id, data) {
     const transaction = this.transactions[id];
@@ -1131,6 +1306,22 @@ class TransactionService {
           };
           break;
         }
+      case _KoniTypes.ExtrinsicType.MULTISIG_APPROVE_TX:
+        // todo
+        historyItem.additionalInfo = (0, _utils3.parseTransactionData)(transaction.data);
+        break;
+      case _KoniTypes.ExtrinsicType.MULTISIG_EXECUTE_TX:
+        // todo
+        historyItem.additionalInfo = (0, _utils3.parseTransactionData)(transaction.data);
+        break;
+      case _KoniTypes.ExtrinsicType.MULTISIG_CANCEL_TX:
+        // todo
+        historyItem.additionalInfo = (0, _utils3.parseTransactionData)(transaction.data);
+        break;
+      case _KoniTypes.ExtrinsicType.MULTISIG_INIT_TX:
+        // todo
+        historyItem.additionalInfo = (0, _utils3.parseTransactionData)(transaction.data);
+        break;
       case _KoniTypes.ExtrinsicType.ADD_SUBSTRATE_PROXY_ACCOUNT:
         {
           const data = (0, _utils3.parseTransactionData)(transaction.data);
@@ -1180,6 +1371,10 @@ class TransactionService {
           }
           break;
         }
+      case _KoniTypes.ExtrinsicType.SUBSTRATE_PROXY_INIT_TX:
+        // todo
+        historyItem.additionalInfo = (0, _utils3.parseTransactionData)(transaction.data);
+        break;
       case _KoniTypes.ExtrinsicType.UNKNOWN:
         break;
     }
@@ -1327,20 +1522,22 @@ class TransactionService {
       blockHash: blockHash || '',
       blockTime
     }).catch(console.error);
-    const info = (0, _util.isHex)(extrinsicHash) ? extrinsicHash : (0, _helpers.getBaseTransactionInfo)(transaction, this.state.chainService.getChainInfoMap());
-    this.state.notificationService.notify({
-      type: _KoniTypes.NotificationType.SUCCESS,
-      title: (0, _i18next.t)('bg.TRANSACTION_SERVICE.services.service.transaction.transactionCompleted'),
-      message: (0, _i18next.t)('bg.TRANSACTION_SERVICE.services.service.transaction.transactionInfoCompleted', {
-        replace: {
-          info
-        }
-      }),
-      action: {
-        url: this.getTransactionLink(id)
-      },
-      notifyViaBrowser: true
-    });
+    if (transaction.wrappingStatus !== _types.SubstrateTransactionWrappingStatus.WRAP_SOURCE) {
+      const info = (0, _util.isHex)(extrinsicHash) ? extrinsicHash : (0, _helpers.getBaseTransactionInfo)(transaction, this.state.chainService.getChainInfoMap());
+      this.state.notificationService.notify({
+        type: _KoniTypes.NotificationType.SUCCESS,
+        title: (0, _i18next.t)('bg.TRANSACTION_SERVICE.services.service.transaction.transactionCompleted'),
+        message: (0, _i18next.t)('bg.TRANSACTION_SERVICE.services.service.transaction.transactionInfoCompleted', {
+          replace: {
+            info
+          }
+        }),
+        action: {
+          url: this.getTransactionLink(id)
+        },
+        notifyViaBrowser: true
+      });
+    }
     this.state.eventService.emit('transaction.done', transaction);
   }
   onFailed(_ref5) {
@@ -1367,20 +1564,22 @@ class TransactionService {
         blockNumber: blockNumber || 0,
         blockHash: blockHash || ''
       }).catch(console.error);
-      const info = (0, _util.isHex)(transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash) ? transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash : (0, _helpers.getBaseTransactionInfo)(transaction, this.state.chainService.getChainInfoMap());
-      this.state.notificationService.notify({
-        type: _KoniTypes.NotificationType.ERROR,
-        title: (0, _i18next.t)('bg.TRANSACTION_SERVICE.services.service.transaction.transactionFailed'),
-        message: (0, _i18next.t)('bg.TRANSACTION_SERVICE.services.service.transaction.transactionInfoFailed', {
-          replace: {
-            info
-          }
-        }),
-        action: {
-          url: this.getTransactionLink(id)
-        },
-        notifyViaBrowser: true
-      });
+      if (transaction.wrappingStatus !== _types.SubstrateTransactionWrappingStatus.WRAP_SOURCE) {
+        const info = (0, _util.isHex)(transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash) ? transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash : (0, _helpers.getBaseTransactionInfo)(transaction, this.state.chainService.getChainInfoMap());
+        this.state.notificationService.notify({
+          type: _KoniTypes.NotificationType.ERROR,
+          title: (0, _i18next.t)('bg.TRANSACTION_SERVICE.services.service.transaction.transactionFailed'),
+          message: (0, _i18next.t)('bg.TRANSACTION_SERVICE.services.service.transaction.transactionInfoFailed', {
+            replace: {
+              info
+            }
+          }),
+          action: {
+            url: this.getTransactionLink(id)
+          },
+          notifyViaBrowser: true
+        });
+      }
     }
     this.state.eventService.emit('transaction.failed', transaction);
   }
@@ -1406,20 +1605,22 @@ class TransactionService {
         blockNumber: blockNumber || 0,
         blockHash: blockHash || ''
       }).catch(console.error);
-      const info = (0, _util.isHex)(transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash) ? transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash : (0, _helpers.getBaseTransactionInfo)(transaction, this.state.chainService.getChainInfoMap());
-      this.state.notificationService.notify({
-        type: _KoniTypes.NotificationType.ERROR,
-        title: (0, _i18next.t)('bg.TRANSACTION_SERVICE.services.service.transaction.transactionTimedOut'),
-        message: (0, _i18next.t)('bg.TRANSACTION_SERVICE.services.service.transaction.transactionInfoTimedOut', {
-          replace: {
-            info
-          }
-        }),
-        action: {
-          url: this.getTransactionLink(id)
-        },
-        notifyViaBrowser: true
-      });
+      if (transaction.wrappingStatus !== _types.SubstrateTransactionWrappingStatus.WRAP_SOURCE) {
+        const info = (0, _util.isHex)(transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash) ? transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash : (0, _helpers.getBaseTransactionInfo)(transaction, this.state.chainService.getChainInfoMap());
+        this.state.notificationService.notify({
+          type: _KoniTypes.NotificationType.ERROR,
+          title: (0, _i18next.t)('bg.TRANSACTION_SERVICE.services.service.transaction.transactionTimedOut'),
+          message: (0, _i18next.t)('bg.TRANSACTION_SERVICE.services.service.transaction.transactionInfoTimedOut', {
+            replace: {
+              info
+            }
+          }),
+          action: {
+            url: this.getTransactionLink(id)
+          },
+          notifyViaBrowser: true
+        });
+      }
     }
     this.state.eventService.emit('transaction.timeout', transaction);
   }
@@ -1586,7 +1787,7 @@ class TransactionService {
             const onError = error => {
               if (error) {
                 // TODO: Change type and message
-                eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNABLE_TO_SEND, error.message));
+                eventData.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.UNABLE_TO_SEND, error.message));
                 emitter.emit('error', eventData);
                 onComplete();
                 reject(error);
@@ -1599,13 +1800,13 @@ class TransactionService {
           });
         } else {
           this.removeTransaction(id);
-          eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.USER_REJECT_REQUEST));
+          eventData.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.USER_REJECT_REQUEST));
           emitter.emit('error', eventData);
         }
       }).catch(e => {
         this.removeTransaction(id);
         // TODO: Change type
-        eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNABLE_TO_SIGN, e.message));
+        eventData.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.UNABLE_TO_SIGN, e.message));
         emitter.emit('error', eventData);
       });
     } else {
@@ -1652,20 +1853,20 @@ class TransactionService {
             eventData.blockNumber = rs.blockNumber;
             emitter.emit('success', eventData);
           }).once('error', e => {
-            eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.SEND_TRANSACTION_FAILED, (0, _i18next.t)(e.message)));
+            eventData.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.SEND_TRANSACTION_FAILED, (0, _i18next.t)(e.message)));
             emitter.emit('error', eventData);
           }).catch(e => {
-            eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNABLE_TO_SEND, (0, _i18next.t)(e.message)));
+            eventData.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.UNABLE_TO_SEND, (0, _i18next.t)(e.message)));
             emitter.emit('error', eventData);
           });
         } else {
           this.removeTransaction(id);
-          eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.USER_REJECT_REQUEST));
+          eventData.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.USER_REJECT_REQUEST));
           emitter.emit('error', eventData);
         }
       }).catch(e => {
         this.removeTransaction(id);
-        eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNABLE_TO_SIGN, (0, _i18next.t)(e.message)));
+        eventData.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.UNABLE_TO_SIGN, (0, _i18next.t)(e.message)));
         emitter.emit('error', eventData);
       });
     }
@@ -1718,12 +1919,12 @@ class TransactionService {
         emitter.emit('extrinsicHash', eventData);
         emitter.emit('success', eventData);
       } else {
-        eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.USER_REJECT_REQUEST));
+        eventData.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.USER_REJECT_REQUEST));
         emitter.emit('error', eventData);
       }
     }).catch(e => {
       this.removeTransaction(id);
-      eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNABLE_TO_SIGN, (0, _i18next.t)(e.message)));
+      eventData.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.UNABLE_TO_SIGN, (0, _i18next.t)(e.message)));
       emitter.emit('error', eventData);
     });
     return emitter;
@@ -1773,7 +1974,7 @@ class TransactionService {
           this.handleTransactionTimeout(emitter, eventData);
           transaction.cronCheckTxSuccess().then(order => {
             if (!order) {
-              eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.SEND_TRANSACTION_FAILED));
+              eventData.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.SEND_TRANSACTION_FAILED));
               emitter.emit('error', eventData);
             } else {
               eventData.extrinsicHash = order.txHash;
@@ -1781,38 +1982,39 @@ class TransactionService {
               emitter.emit('success', eventData);
             }
           }).catch(e => {
-            eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.SEND_TRANSACTION_FAILED, (0, _i18next.t)(e.message)));
+            eventData.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.SEND_TRANSACTION_FAILED, (0, _i18next.t)(e.message)));
             emitter.emit('error', eventData);
           });
         }).catch(e => {
-          eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNABLE_TO_SEND, (0, _i18next.t)(e.message)));
+          eventData.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.UNABLE_TO_SEND, (0, _i18next.t)(e.message)));
           emitter.emit('error', eventData);
         });
       } else {
         this.removeTransaction(id);
-        eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.USER_REJECT_REQUEST));
+        eventData.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.USER_REJECT_REQUEST));
         emitter.emit('error', eventData);
       }
     }).catch(e => {
       this.removeTransaction(id);
-      eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNABLE_TO_SIGN, (0, _i18next.t)(e.message)));
+      eventData.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.UNABLE_TO_SIGN, (0, _i18next.t)(e.message)));
       emitter.emit('error', eventData);
     });
     return emitter;
   }
-  async signAndSendSubstrateTransaction(_ref12) {
+  signAndSendSubstrateTransaction(_ref12) {
     var _this$state$chainServ;
     let {
       address,
       chain,
+      data,
       feeCustom,
       id,
       signAfterCreate,
-      signerSubstrateProxyAddress,
       step,
       tokenPayFeeSlug,
       transaction,
-      url
+      url,
+      wrappingStatus
     } = _ref12;
     const tip = (feeCustom === null || feeCustom === void 0 ? void 0 : feeCustom.tip) || '0';
     const feeAssetId = tokenPayFeeSlug && !(0, _utils2._isNativeTokenBySlug)(tokenPayFeeSlug) && _constants._SUPPORT_TOKEN_PAY_FEE_GROUP.assetHub.includes(chain) ? (_this$state$chainServ = this.state.chainService.getAssetBySlug(tokenPayFeeSlug).metadata) === null || _this$state$chainServ === void 0 ? void 0 : _this$state$chainServ.multilocation : undefined;
@@ -1824,13 +2026,13 @@ class TransactionService {
       extrinsicHash: id,
       processId: step === null || step === void 0 ? void 0 : step.processId
     };
-    let extrinsic = transaction;
-    let signer = address;
-    if (signerSubstrateProxyAddress && signerSubstrateProxyAddress !== address) {
-      const substrateApi = this.state.chainService.getSubstrateApi(chain);
-      await substrateApi.isReady;
-      signer = signerSubstrateProxyAddress;
-      extrinsic = substrateApi.api.tx.proxy.proxy(address, null, transaction);
+    const extrinsic = transaction;
+    const signer = address;
+    let transactionId = id;
+    if (wrappingStatus === _types.SubstrateTransactionWrappingStatus.WRAP_RESULT) {
+      // we will use the original transaction's ID for this request,
+      // because we only want the popup to appear once and keep the old one.
+      transactionId = data.transactionId || id;
     }
 
     // const registry = extrinsic.registry;
@@ -1842,7 +2044,7 @@ class TransactionService {
           const {
             signature,
             signedTransaction
-          } = await this.state.requestService.signInternalTransaction(id, signer, url || _constants2.EXTENSION_REQUEST_URL, payload, signAfterCreate);
+          } = await this.state.requestService.signInternalTransaction(transactionId, signer, url || _constants2.EXTENSION_REQUEST_URL, payload, signAfterCreate, wrappingStatus);
           return {
             id: new Date().getTime(),
             signature,
@@ -1925,7 +2127,7 @@ class TransactionService {
                 }
               } = _ref14;
               if (method === 'ExtrinsicFailed') {
-                eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.SEND_TRANSACTION_FAILED, error.toString()));
+                eventData.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.SEND_TRANSACTION_FAILED, error.toString()));
                 emitter.emit('error', eventData);
                 isFinish = true;
               } else if (method === 'ExtrinsicSuccess') {
@@ -1936,12 +2138,12 @@ class TransactionService {
           }
         }
       }).catch(e => {
-        eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.SEND_TRANSACTION_FAILED, e.message));
+        eventData.errors.push(new _TransactionError.TransactionError(_types2.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));
+      eventData.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.UNABLE_TO_SIGN, e.message));
       emitter.emit('error', eventData);
     });
     return emitter;
@@ -1979,7 +2181,7 @@ class TransactionService {
           } = _ref16;
           if (!isApproved) {
             this.removeTransaction(id);
-            eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.USER_REJECT_REQUEST));
+            eventData.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.USER_REJECT_REQUEST));
             emitter.emit('error', eventData);
           } else {
             if (!payload) {
@@ -1989,7 +2191,7 @@ class TransactionService {
           }
         }).catch(e => {
           this.removeTransaction(id);
-          eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNABLE_TO_SIGN, (0, _i18next.t)(e.message)));
+          eventData.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.UNABLE_TO_SIGN, (0, _i18next.t)(e.message)));
           emitter.emit('error', eventData);
         });
       });
@@ -2021,22 +2223,22 @@ class TransactionService {
           if (!status && hex) {
             eventData.extrinsicHash = hex;
             emitter.emit('extrinsicHash', eventData);
-            eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.SEND_TRANSACTION_FAILED));
+            eventData.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.SEND_TRANSACTION_FAILED));
             emitter.emit('error', eventData);
           }
         }).catch(e => {
-          eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.SEND_TRANSACTION_FAILED, e.message));
+          eventData.errors.push(new _TransactionError.TransactionError(_types2.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));
+        eventData.errors.push(new _TransactionError.TransactionError(_types2.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));
+      eventData.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.UNABLE_TO_SIGN, e.message));
       emitter.emit('error', eventData);
     });
     return emitter;
@@ -2064,7 +2266,7 @@ class TransactionService {
       } = _ref19;
       if (!isApproved) {
         this.removeTransaction(id);
-        eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.USER_REJECT_REQUEST));
+        eventData.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.USER_REJECT_REQUEST));
         emitter.emit('error', eventData);
       } else {
         if (!payload) {
@@ -2081,7 +2283,7 @@ class TransactionService {
         // send qua api
         cardanoApi.sendCardanoTxReturnHash(payload).then(txHash => {
           if (!txHash) {
-            eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.SEND_TRANSACTION_FAILED));
+            eventData.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.SEND_TRANSACTION_FAILED));
             emitter.emit('error', eventData);
           }
           eventData.extrinsicHash = txHash;
@@ -2090,22 +2292,22 @@ class TransactionService {
           // todo: wait transaction by fetch txHash by API
           cardanoApi.getStatusByTxHash(txHash, transactionConfig.cardanoTtlOffset).then(status => {
             if (!status) {
-              eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.SEND_TRANSACTION_FAILED));
+              eventData.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.SEND_TRANSACTION_FAILED));
               emitter.emit('error', eventData);
             }
             emitter.emit('success', eventData);
           }).catch(e => {
-            eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.SEND_TRANSACTION_FAILED, e.message));
+            eventData.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.SEND_TRANSACTION_FAILED, e.message));
             emitter.emit('error', eventData);
           });
         }).catch(e => {
-          eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.SEND_TRANSACTION_FAILED, e.message));
+          eventData.errors.push(new _TransactionError.TransactionError(_types2.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, (0, _i18next.t)(e.message)));
+      eventData.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.UNABLE_TO_SIGN, (0, _i18next.t)(e.message)));
       emitter.emit('error', eventData);
     });
     return emitter;
@@ -2121,14 +2323,13 @@ class TransactionService {
       emitter.emit('extrinsicHash', eventData);
     });
     event.on('success', transactionStatus => {
-      console.log(transactionStatus);
       eventData.blockHash = transactionStatus.block_hash || undefined;
       eventData.blockNumber = transactionStatus.block_height || undefined;
       eventData.blockTime = transactionStatus.block_time ? transactionStatus.block_time * 1000 : undefined;
       emitter.emit('success', eventData);
     });
     event.on('error', error => {
-      eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNABLE_TO_SEND, error));
+      eventData.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.UNABLE_TO_SEND, error));
       emitter.emit('error', eventData);
     });
   };
@@ -2165,7 +2366,7 @@ class TransactionService {
     // const isExternal = !!account.isExternal;
 
     if (isInjected) {
-      throw new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED);
+      throw new _TransactionError.TransactionError(_types2.BasicTxErrorType.UNSUPPORTED);
     } else {
       this.state.requestService.addConfirmationBitcoin(id, url || _constants2.EXTENSION_REQUEST_URL, 'bitcoinSendTransactionRequest', payload, {}).then(_ref21 => {
         let {
@@ -2194,17 +2395,17 @@ class TransactionService {
             emitter.emit('success', eventData);
           });
           event.on('error', error => {
-            eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNABLE_TO_SEND, error));
+            eventData.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.UNABLE_TO_SEND, error));
             emitter.emit('error', eventData);
           });
         } else {
           this.removeTransaction(id);
-          eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.USER_REJECT_REQUEST));
+          eventData.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.USER_REJECT_REQUEST));
           emitter.emit('error', eventData);
         }
       }).catch(e => {
         this.removeTransaction(id);
-        eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNABLE_TO_SIGN, e.message));
+        eventData.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.UNABLE_TO_SIGN, e.message));
         emitter.emit('error', eventData);
       });
     }
@@ -2214,7 +2415,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(_types.BasicTxErrorType.TIMEOUT, (0, _i18next.t)('bg.TRANSACTION_SERVICE.services.service.transaction.transactionTimeout')));
+        eventData.errors.push(new _TransactionError.TransactionError(_types2.BasicTxErrorType.TIMEOUT, (0, _i18next.t)('bg.TRANSACTION_SERVICE.services.service.transaction.transactionTimeout')));
         emitter.emit('timeout', eventData);
         clearTimeout(timeout);
       }
@@ -2239,7 +2440,7 @@ class TransactionService {
     const poolHandler = this.state.earningService.getPoolHandler(slug);
     if (poolHandler) {
       const type = poolHandler.type;
-      if (type === _types.YieldPoolType.NATIVE_STAKING) {
+      if (type === _types2.YieldPoolType.NATIVE_STAKING) {
         return;
       }
     } else {
@@ -2281,40 +2482,40 @@ class TransactionService {
       const step = process.steps.find(item => item.id === stepId);
       if (step) {
         Object.assign(step, data);
-        if ([_types.StepStatus.PREPARE || _types.StepStatus.PROCESSING].includes(step.status)) {
+        if ([_types2.StepStatus.PREPARE || _types2.StepStatus.PROCESSING].includes(step.status)) {
           process.currentStepId = step.id;
         }
-        if (step.status === _types.StepStatus.COMPLETE) {
+        if (step.status === _types2.StepStatus.COMPLETE) {
           const nextStep = process.steps.find(item => item.id === stepId + 1);
           if (nextStep) {
-            nextStep.status = _types.StepStatus.PREPARE;
+            nextStep.status = _types2.StepStatus.PREPARE;
             process.currentStepId = nextStep.id;
           }
-        } else if ([_types.StepStatus.FAILED, _types.StepStatus.TIMEOUT].includes(step.status)) {
+        } else if ([_types2.StepStatus.FAILED, _types2.StepStatus.TIMEOUT].includes(step.status)) {
           const nextSteps = process.steps.filter(item => item.id > stepId);
           nextSteps.forEach(item => {
-            item.status = _types.StepStatus.CANCELLED;
+            item.status = _types2.StepStatus.CANCELLED;
           });
         }
       }
-      if (process.steps.some(item => [_types.StepStatus.PROCESSING, _types.StepStatus.SUBMITTING].includes(item.status))) {
-        process.status = _types.StepStatus.PROCESSING;
+      if (process.steps.some(item => [_types2.StepStatus.PROCESSING, _types2.StepStatus.SUBMITTING].includes(item.status))) {
+        process.status = _types2.StepStatus.PROCESSING;
       }
-      if (process.steps.some(item => item.status === _types.StepStatus.TIMEOUT)) {
-        process.status = _types.StepStatus.TIMEOUT;
+      if (process.steps.some(item => item.status === _types2.StepStatus.TIMEOUT)) {
+        process.status = _types2.StepStatus.TIMEOUT;
       }
-      if (process.steps.every(item => item.status === _types.StepStatus.COMPLETE)) {
+      if (process.steps.every(item => item.status === _types2.StepStatus.COMPLETE)) {
         const lastStep = process.steps[process.steps.length - 1];
         process.lastTransactionChain = lastStep.chain;
         process.lastTransactionId = lastStep.transactionId;
-        process.status = _types.StepStatus.COMPLETE;
+        process.status = _types2.StepStatus.COMPLETE;
       }
-      if (process.steps.some(item => item.status === _types.StepStatus.FAILED)) {
-        process.status = _types.StepStatus.FAILED;
+      if (process.steps.some(item => item.status === _types2.StepStatus.FAILED)) {
+        process.status = _types2.StepStatus.FAILED;
       }
       this.aliveProcessMap.set(processId, process);
       this.state.dbService.upsertProcessTransaction(process).catch(console.error);
-      if ([_types.StepStatus.COMPLETE, _types.StepStatus.FAILED, _types.StepStatus.TIMEOUT].includes(process.status)) {
+      if ([_types2.StepStatus.COMPLETE, _types2.StepStatus.FAILED, _types2.StepStatus.TIMEOUT].includes(process.status)) {
         this.aliveProcessMap.delete(processId);
       }
       this.updateAliveProcess();
@@ -2322,7 +2523,7 @@ class TransactionService {
       this.state.dbService.getProcessTransactionById(processId).then(process => {
         if (process) {
           const step = process.steps.find(item => item.id === stepId);
-          if (step && step.status === _types.StepStatus.TIMEOUT && [_types.StepStatus.COMPLETE, _types.StepStatus.FAILED].includes(data.status)) {
+          if (step && step.status === _types2.StepStatus.TIMEOUT && [_types2.StepStatus.COMPLETE, _types2.StepStatus.FAILED].includes(data.status)) {
             Object.assign(step, data);
             const isLastStep = process.steps[process.steps.length - 1].id = stepId;
             if (isLastStep) {