@subwallet/extension-base 1.3.42-0 → 1.3.44-0

package/cjs/koni/background/handlers/Extension.js

@@ -57,9 +57,10 @@ var _parseTransaction2 = require("@subwallet/extension-base/utils/eth/parseTrans
 var _getId = require("@subwallet/extension-base/utils/getId");
 var _keyring = require("@subwallet/keyring");
 var _types4 = require("@subwallet/keyring/types");
+var _utils9 = require("@subwallet/keyring/utils");
 var _validate = require("@subwallet/keyring/utils/address/validate");
 var _uiKeyring = require("@subwallet/ui-keyring");
-var _utils9 = require("@walletconnect/utils");
+var _utils10 = require("@walletconnect/utils");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
 var bitcoin = _interopRequireWildcard(require("bitcoinjs-lib"));
 var _i18next = require("i18next");
@@ -67,7 +68,7 @@ var _rxjs = require("rxjs");
 var _types5 = require("@polkadot/types");
 var _util = require("@polkadot/util");
 var _utilCrypto = require("@polkadot/util-crypto");
-var _utils10 = require("../utils");
+var _utils11 = require("../utils");
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
@@ -590,7 +591,8 @@ class KoniExtension {
       evm: _types4.EthereumKeypairTypes,
       substrate: _types4.SubstrateKeypairTypes,
       ton: _types4.TonKeypairTypes,
-      cardano: _types4.CardanoKeypairTypes
+      cardano: _types4.CardanoKeypairTypes,
+      bitcoin: _types4.BitcoinKeypairTypes
     };
     return !!accountAuthTypes && accountAuthTypes.some(authType => {
       var _validTypes$authType;
@@ -705,7 +707,8 @@ class KoniExtension {
       substrate: 'substrateInfo',
       evm: 'evmInfo',
       cardano: 'cardanoInfo',
-      ton: 'tonInfo'
+      ton: 'tonInfo',
+      bitcoin: 'bitcoinInfo'
     };
     const typeInfoKey = typeInfoMap[authSwitchNetworkType];
     if (!typeInfoKey || !chainInfo[typeInfoKey]) {
@@ -1401,6 +1404,7 @@ class KoniExtension {
         if (transferAll) {
           inputData.value = transferAmount.value;
         }
+        console.log('PSPT transaction', transaction.toHex());
       } else {
         const substrateApi = this.#koniState.getSubstrateApi(chain);
         [transaction, transferAmount.value] = await (0, _token.createSubstrateExtrinsic)({
@@ -1712,6 +1716,192 @@ class KoniExtension {
       eventsHandler: eventsHandler
     });
   }
+  async makeBitcoinDappTransferConfirmation(inputData) {
+    const {
+      chain,
+      feeCustom,
+      feeOption,
+      from,
+      id,
+      to,
+      tokenSlug,
+      transferAll,
+      value
+    } = inputData;
+    const transferTokenInfo = this.#koniState.chainService.getAssetBySlug(tokenSlug);
+    const errors = (0, _transfer.validateTransferRequest)(transferTokenInfo, from, to, value, transferAll);
+    const warnings = [];
+    const chainInfo = this.#koniState.getChainInfo(chain);
+    const nativeTokenInfo = this.#koniState.getNativeTokenInfo(chain);
+    const nativeTokenSlug = nativeTokenInfo.slug;
+    const isTransferNativeToken = nativeTokenSlug === tokenSlug;
+    let chainType = _KoniTypes.ChainType.BITCOIN;
+    const tokenBaseAmount = {
+      value: '0',
+      symbol: transferTokenInfo.symbol,
+      decimals: transferTokenInfo.decimals || 0
+    };
+    const transferAmount = {
+      ...tokenBaseAmount
+    };
+    let transaction;
+    let overrideFeeCustom;
+    let calculatedBitcoinFeeRate;
+
+    // Get native token amount
+    const freeBalance = await this.getAddressTransferableBalance({
+      address: from,
+      networkKey: chain,
+      token: tokenSlug
+    });
+    const txVal = transferAll ? freeBalance.value : value || '0';
+    try {
+      if ((0, _utils6._isChainBitcoinCompatible)(chainInfo)) {
+        chainType = _KoniTypes.ChainType.BITCOIN;
+        const bitcoinApi = this.#koniState.getBitcoinApi(chain); // Get Bitcoin API map
+        const network = chainInfo.isTestnet ? bitcoin.networks.testnet : bitcoin.networks.bitcoin;
+        const feeInfo = await this.#koniState.feeService.subscribeChainFee((0, _getId.getId)(), chain, 'bitcoin');
+        [transaction, transferAmount.value, calculatedBitcoinFeeRate] = await (0, _bitcoinTransfer.createBitcoinTransaction)({
+          bitcoinApi,
+          chain,
+          from,
+          feeInfo,
+          to,
+          transferAll: transferAll,
+          value: txVal,
+          network: network
+        });
+        if (calculatedBitcoinFeeRate) {
+          const feeRate = parseFloat(calculatedBitcoinFeeRate);
+          if (!isNaN(feeRate)) {
+            overrideFeeCustom = {
+              feeRate
+            };
+          }
+        }
+      }
+    } catch (e) {
+      const error = e;
+      if (error.message.includes('transfer amount exceeds balance')) {
+        error.message = (0, _i18next.t)('Insufficient balance');
+      }
+      throw error;
+    }
+    const transferNativeAmount = isTransferNativeToken ? transferAmount.value : '0';
+    return this.#koniState.transactionService.handleTransactionAfterConfirmation({
+      id,
+      errors,
+      warnings,
+      address: from,
+      chain: chain,
+      feeCustom: overrideFeeCustom || feeCustom,
+      feeOption: overrideFeeCustom ? 'custom' : feeOption,
+      chainType,
+      transferNativeAmount,
+      transaction,
+      data: inputData,
+      extrinsicType: isTransferNativeToken ? _KoniTypes.ExtrinsicType.TRANSFER_BALANCE : _KoniTypes.ExtrinsicType.TRANSFER_TOKEN,
+      ignoreWarnings: [],
+      isTransferAll: isTransferNativeToken ? transferAll : false,
+      edAsWarning: isTransferNativeToken
+    });
+  }
+  async makePsbtTransferAfterConfirmation(inputData_) {
+    var _txOutput$;
+    const {
+      chain,
+      from,
+      id,
+      psbt,
+      tokenSlug,
+      txInput,
+      txOutput,
+      value
+    } = inputData_;
+    let inputAmount = new _bignumber.default(0);
+    const transferTokenInfo = this.#koniState.chainService.getAssetBySlug(tokenSlug);
+    const totalUtxoInput = txInput.reduce((total, _ref33) => {
+      let {
+        address,
+        amount
+      } = _ref33;
+      if (!address || !amount) {
+        return total;
+      }
+      if ((0, _utils8.isSameAddress)(address, from)) {
+        inputAmount = new _bignumber.default(amount);
+      }
+      return total.plus(new _bignumber.default(amount || 0));
+    }, new _bignumber.default(0));
+    const totalUtxoOutput = txOutput.reduce((total, _ref34) => {
+      let {
+        address,
+        amount
+      } = _ref34;
+      if (!address || !amount) {
+        return total;
+      }
+      return total.plus(new _bignumber.default(amount));
+    }, new _bignumber.default(0));
+    const estimateFeeValue = totalUtxoInput.minus(totalUtxoOutput).toString();
+    const errors = (0, _transfer.validateTransferRequest)(transferTokenInfo, from, ((_txOutput$ = txOutput[0]) === null || _txOutput$ === void 0 ? void 0 : _txOutput$.address) || '', value, false);
+    const warnings = [];
+    const chainInfo = this.#koniState.getChainInfo(chain);
+    const {
+      decimals,
+      symbol
+    } = (0, _utils6._getChainNativeTokenBasicInfo)(chainInfo);
+    const estimateFee = {
+      symbol,
+      decimals,
+      value: estimateFeeValue,
+      tooHigh: false
+    };
+    const nativeTokenInfo = this.#koniState.getNativeTokenInfo(chain);
+    const nativeTokenSlug = nativeTokenInfo.slug;
+    const isTransferNativeToken = nativeTokenSlug === tokenSlug;
+    const chainType = _KoniTypes.ChainType.BITCOIN;
+    const bitcoinNetwork = chainInfo.isTestnet ? bitcoin.networks.testnet : bitcoin.networks.bitcoin;
+    const psbtGenerate = bitcoin.Psbt.fromHex(psbt, {
+      network: bitcoinNetwork
+    });
+    const tokenBaseAmount = {
+      value: inputData_.value,
+      symbol: transferTokenInfo.symbol,
+      decimals: transferTokenInfo.decimals || 0
+    };
+    const transferAmount = {
+      ...tokenBaseAmount
+    };
+
+    // Get native token amount
+    const freeBalance = await this.getAddressTransferableBalance({
+      address: from,
+      networkKey: chain,
+      token: tokenSlug
+    });
+    if (new _bignumber.default(freeBalance.value).lt(inputAmount)) {
+      throw new Error((0, _i18next.t)('Insufficient balance'));
+    }
+    const transferNativeAmount = isTransferNativeToken ? transferAmount.value : '0';
+    return this.#koniState.transactionService.handleTransactionAfterConfirmation({
+      id,
+      errors,
+      warnings,
+      address: from,
+      chain: chain,
+      estimateFee,
+      chainType,
+      transferNativeAmount,
+      transaction: psbtGenerate,
+      data: inputData_,
+      extrinsicType: isTransferNativeToken ? _KoniTypes.ExtrinsicType.TRANSFER_BALANCE : _KoniTypes.ExtrinsicType.TRANSFER_TOKEN,
+      ignoreWarnings: [],
+      isTransferAll: false,
+      edAsWarning: isTransferNativeToken,
+      skipFeeRecalculation: true
+    });
+  }
   async getTokensCanPayFee(request) {
     var _tokensHasBalanceInfo;
     const {
@@ -1831,28 +2021,28 @@ class KoniExtension {
   disableChain(networkKey) {
     return this.#koniState.disableChain(networkKey);
   }
-  async enableChain(_ref33) {
+  async enableChain(_ref35) {
     let {
       chainSlug,
       enableTokens
-    } = _ref33;
+    } = _ref35;
     return await this.#koniState.enableChain(chainSlug, enableTokens);
   }
-  async enableChainWithPriorityAssets(_ref34) {
+  async enableChainWithPriorityAssets(_ref36) {
     let {
       chainSlug,
       enableTokens
-    } = _ref34;
+    } = _ref36;
     return await this.#koniState.enableChainWithPriorityAssets(chainSlug, enableTokens);
   }
   async reconnectChain(chainSlug) {
     return this.#koniState.chainService.reconnectChain(chainSlug);
   }
-  async validateNetwork(_ref35) {
+  async validateNetwork(_ref37) {
     let {
       existedChainSlug,
       provider
-    } = _ref35;
+    } = _ref37;
     return await this.#koniState.validateCustomChain(provider, existedChainSlug);
   }
   resetDefaultNetwork() {
@@ -1924,13 +2114,13 @@ class KoniExtension {
   async validateCustomAsset(data) {
     return await this.#koniState.validateCustomAsset(data);
   }
-  async getAddressTransferableBalance(_ref36) {
+  async getAddressTransferableBalance(_ref38) {
     let {
       address,
       extrinsicType,
       networkKey,
       token
-    } = _ref36;
+    } = _ref38;
     if (token && _constants2._MANTA_ZK_CHAIN_GROUP.includes(networkKey)) {
       const tokenInfo = this.#koniState.chainService.getAssetBySlug(token);
       if (tokenInfo.symbol.startsWith(_constants2._ZK_ASSET_PREFIX)) {
@@ -1939,13 +2129,13 @@ class KoniExtension {
     }
     return await this.#koniState.balanceService.getTransferableBalance(address, networkKey, token, extrinsicType);
   }
-  async getAddressTotalBalance(_ref37) {
+  async getAddressTotalBalance(_ref39) {
     let {
       address,
       extrinsicType,
       networkKey,
       token
-    } = _ref37;
+    } = _ref39;
     return await this.#koniState.balanceService.getTotalBalance(address, networkKey, token, extrinsicType);
   }
   async subscribeMaxTransferable(request, id, port) {
@@ -2000,11 +2190,11 @@ class KoniExtension {
       freeBalance: freeBalanceSubject,
       fee: feeSubject
     }).subscribe({
-      next: _ref38 => {
+      next: _ref40 => {
         let {
           fee,
           freeBalance
-        } = _ref38;
+        } = _ref40;
         (0, _utils8.calculateMaxTransferable)(id, _request, freeBalance, fee).then(cb).catch(console.error);
       }
     });
@@ -2038,13 +2228,144 @@ class KoniExtension {
     });
     return (0, _utils8.calculateMaxTransferable)(id, _request, freeBalance, fee);
   }
-  async subscribeAddressTransferableBalance(_ref39, id, port) {
+  async subscribeTransferableWhenConfirmation(_ref41, id, port) {
+    let {
+      address,
+      chain,
+      feeCustom,
+      feeOption: _feeOptions,
+      to,
+      token,
+      value
+    } = _ref41;
+    const cb = (0, _subscriptions.createSubscription)(id, port);
+    const freeBalanceSubject = new _rxjs.Subject();
+    const feeSubject = new _rxjs.Subject();
+    const feeType = 'bitcoin';
+    let error;
+    const convertData = async (freeBalance, fee, feeOption, feeCustom) => {
+      let estimatedFee = '0';
+      let feeOptions = null;
+      const amount = parseInt(value || '0');
+      const neededUtxos = [];
+      let sum = new _bignumber.default(0);
+      let sizeInfo = null;
+      try {
+        const _fee = fee;
+        const _feeCustom = feeCustom;
+        const combineFee = (0, _utils8.combineBitcoinFee)(_fee, _feeOptions, _feeCustom);
+        const bitcoinApi = this.#koniState.chainService.getBitcoinApi(chain);
+        let utxos = await (0, _utils8.getTransferableBitcoinUtxos)(bitcoinApi, address);
+        const recipients = [address, to || address];
+        utxos = utxos.sort((a, b) => b.value - a.value);
+        const filteredUtxos = (0, _utils8.filterUneconomicalUtxos)({
+          utxos,
+          feeRate: combineFee.feeRate,
+          recipients,
+          sender: address
+        });
+        for (const utxo of filteredUtxos) {
+          sizeInfo = (0, _utils8.getSizeInfo)({
+            inputLength: neededUtxos.length,
+            sender: address,
+            recipients
+          });
+          const currentValue = new _bignumber.default(amount).plus(Math.ceil(sizeInfo.txVBytes * combineFee.feeRate));
+          if (sum.gte(currentValue)) {
+            break;
+          }
+          sum = sum.plus(utxo.value);
+          neededUtxos.push(utxo);
+        }
+
+        // re calculate
+        sizeInfo = (0, _utils8.getSizeInfo)({
+          inputLength: neededUtxos.length,
+          sender: address,
+          recipients
+        });
+        if (!sizeInfo) {
+          sizeInfo = (0, _utils8.getSizeInfo)({
+            inputLength: utxos.length || 1,
+            sender: address,
+            recipients
+          });
+        }
+        estimatedFee = Math.ceil(sizeInfo.txVBytes * combineFee.feeRate).toString();
+        const amountLeft = sum.minus(amount).minus(new _bignumber.default(estimatedFee));
+        if (amountLeft.lte(0)) {
+          error = 'Insufficient balance';
+        } else {
+          const senderAddressInfo = (0, _utils9.getBitcoinAddressInfo)(address);
+          const dustLimit = _constants.BTC_DUST_AMOUNT[senderAddressInfo.type] || 546;
+          if (amountLeft.lte(dustLimit)) {
+            sizeInfo = (0, _utils8.getSizeInfo)({
+              inputLength: neededUtxos.length,
+              sender: address,
+              recipients: [to || address]
+            });
+            estimatedFee = sum.minus(amount).toString();
+          }
+        }
+        feeOptions = {
+          ...fee,
+          vSize: sizeInfo.txVBytes,
+          estimatedFee
+        };
+      } catch (e) {
+        feeOptions = {
+          ...fee,
+          estimatedFee,
+          vSize: 0
+        };
+        error = e.message || e;
+        console.warn('Unable to estimate fee', e);
+      }
+      return {
+        feeOptions: feeOptions,
+        feeType,
+        error,
+        id
+      };
+    };
+    const subscription = (0, _rxjs.combineLatest)({
+      freeBalance: freeBalanceSubject,
+      fee: feeSubject
+    }).subscribe({
+      next: _ref42 => {
+        let {
+          fee,
+          freeBalance
+        } = _ref42;
+        convertData(freeBalance, fee, _feeOptions, feeCustom).then(cb).catch(console.error);
+      }
+    });
+    const [unsubBalance, freeBalance] = await this.#koniState.balanceService.subscribeBalance(address, chain, token, 'transferable', _KoniTypes.ExtrinsicType.TRANSFER_BALANCE, data => {
+      freeBalanceSubject.next(data); // Must be called after subscription
+    });
+
+    const fee = await this.#koniState.feeService.subscribeChainFee(id, chain, feeType, data => {
+      feeSubject.next(data); // Must be called after subscription
+    });
+
+    const unsub = () => {
+      subscription.unsubscribe();
+      unsubBalance();
+      this.#koniState.feeService.unsubscribeChainFee(id, chain, feeType);
+    };
+    this.createUnsubscriptionHandle(id, unsub);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return convertData(freeBalance, fee, _feeOptions, feeCustom);
+  }
+  async subscribeAddressTransferableBalance(_ref43, id, port) {
     let {
       address,
       extrinsicType,
       networkKey,
       token
-    } = _ref39;
+    } = _ref43;
     const cb = (0, _subscriptions.createSubscription)(id, port);
     const convertData = data => {
       return {
@@ -2095,11 +2416,11 @@ class KoniExtension {
       isSendingSelf
     };
   }
-  async enableChains(_ref40) {
+  async enableChains(_ref44) {
     let {
       chainSlugs,
       enableTokens
-    } = _ref40;
+    } = _ref44;
     try {
       await Promise.all(chainSlugs.map(chainSlug => this.enableChain({
         chainSlug,
@@ -2243,30 +2564,30 @@ class KoniExtension {
 
   // Parse transaction
 
-  parseSubstrateTransaction(_ref41) {
+  parseSubstrateTransaction(_ref45) {
     let {
       data,
       networkKey
-    } = _ref41;
+    } = _ref45;
     const apiProps = this.#koniState.getSubstrateApi(networkKey);
     const apiPromise = apiProps.api;
     return (0, _parseTransaction.parseSubstrateTransaction)(data, apiPromise);
   }
-  async parseEVMRLP(_ref42) {
+  async parseEVMRLP(_ref46) {
     let {
       data
-    } = _ref42;
+    } = _ref46;
     return await (0, _parseTransaction2.parseEvmRlp)(data, this.#koniState.getChainInfoMap(), this.#koniState.getEvmApiMap());
   }
 
   // Sign
 
-  qrSignSubstrate(_ref43) {
+  qrSignSubstrate(_ref47) {
     let {
       address,
       data,
       networkKey
-    } = _ref43;
+    } = _ref47;
     const pair = _uiKeyring.keyring.getPair(address);
     (0, _util.assert)(pair, (0, _i18next.t)('Unable to find account'));
     if (pair.isLocked) {
@@ -2283,13 +2604,13 @@ class KoniExtension {
       signature: signed
     };
   }
-  async qrSignEVM(_ref44) {
+  async qrSignEVM(_ref48) {
     let {
       address,
       chainId,
       message,
       type
-    } = _ref44;
+    } = _ref48;
     let signed;
     const network = this.getNetworkJsonByChainId(chainId);
     if (!network) {
@@ -2373,11 +2694,11 @@ class KoniExtension {
     });
     return this.#koniState.getNominatorMetadata();
   }
-  async getBondingOptions(_ref45) {
+  async getBondingOptions(_ref49) {
     let {
       chain,
       type
-    } = _ref45;
+    } = _ref49;
     const apiProps = this.#koniState.getSubstrateApi(chain);
     const chainInfo = this.#koniState.getChainInfo(chain);
     const chainStakingMetadata = await this.#koniState.getStakingMetadataByChain(chain, type);
@@ -2567,12 +2888,12 @@ class KoniExtension {
   }
 
   // EVM Transaction
-  async parseContractInput(_ref46) {
+  async parseContractInput(_ref50) {
     let {
       chainId,
       contract,
       data
-    } = _ref46;
+    } = _ref50;
     const network = this.getNetworkJsonByChainId(chainId);
     return await (0, _parseTransaction2.parseContractInput)(data, contract, network);
   }
@@ -2672,10 +2993,10 @@ class KoniExtension {
 
   // Unlock wallet
 
-  keyringUnlock(_ref47) {
+  keyringUnlock(_ref51) {
     let {
       password
-    } = _ref47;
+    } = _ref51;
     try {
       _uiKeyring.keyring.unlockKeyring(password);
       // this.#koniState.initMantaPay(password)
@@ -2706,11 +3027,11 @@ class KoniExtension {
 
   // Export mnemonic
 
-  keyringExportMnemonic(_ref48) {
+  keyringExportMnemonic(_ref52) {
     let {
       address,
       password
-    } = _ref48;
+    } = _ref52;
     const pair = _uiKeyring.keyring.getPair(address);
     const result = pair.exportMnemonic(password);
     return {
@@ -2720,10 +3041,10 @@ class KoniExtension {
 
   // Reset wallet
 
-  async resetWallet(_ref49) {
+  async resetWallet(_ref53) {
     let {
       resetAll
-    } = _ref49;
+    } = _ref53;
     try {
       await this.#koniState.resetWallet(resetAll);
       return {
@@ -2739,10 +3060,10 @@ class KoniExtension {
   }
 
   // Signing substrate request
-  async signingApprovePasswordV2(_ref50) {
+  async signingApprovePasswordV2(_ref54) {
     let {
       id
-    } = _ref50;
+    } = _ref54;
     const queued = this.#koniState.getSignRequest(id);
     (0, _util.assert)(queued, (0, _i18next.t)('Unable to proceed. Please try again'));
     const {
@@ -2771,12 +3092,12 @@ class KoniExtension {
     let registry = new _types5.TypeRegistry();
     if (isJsonPayload(payload)) {
       const [, chainInfo] = this.#koniState.findNetworkKeyByGenesisHash(payload.genesisHash);
-      const registries = await Promise.all([(0, _utils10.setupApiRegistry)(chainInfo, this.#koniState), (0, _utils10.setupDatabaseRegistry)(chainInfo, payload, this.#koniState), (0, _utils10.setupDappRegistry)(payload, this.#koniState)]);
+      const registries = await Promise.all([(0, _utils11.setupApiRegistry)(chainInfo, this.#koniState), (0, _utils11.setupDatabaseRegistry)(chainInfo, payload, this.#koniState), (0, _utils11.setupDappRegistry)(payload, this.#koniState)]);
       const validRegistries = registries.filter(item => !!(item !== null && item !== void 0 && item.registry));
       if (validRegistries.length === 0) {
         registry.setSignedExtensions(payload.signedExtensions);
       } else {
-        registry = (0, _utils10.getSuitableRegistry)(validRegistries, payload);
+        registry = (0, _utils11.getSuitableRegistry)(validRegistries, payload);
       }
     }
     const result = request.sign(registry, pair);
@@ -2901,10 +3222,10 @@ class KoniExtension {
   getSupportedSmartContractTypes() {
     return this.#koniState.getSupportedSmartContractTypes();
   }
-  getTransaction(_ref51) {
+  getTransaction(_ref55) {
     let {
       id
-    } = _ref51;
+    } = _ref55;
     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     const {
       transaction,
@@ -2915,11 +3236,12 @@ class KoniExtension {
   async subscribeTransactions(id, port) {
     const cb = (0, _subscriptions.createSubscription)(id, port);
     function convertRs(rs, processMap) {
-      return Object.fromEntries(Object.entries(rs).map(_ref52 => {
-        let [key, value] = _ref52;
+      return Object.fromEntries(Object.entries(rs).map(_ref56 => {
+        let [key, value] = _ref56;
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const {
           additionalValidator,
+          emitterTransaction,
           eventsHandler,
           step,
           transaction,
@@ -2941,11 +3263,11 @@ class KoniExtension {
     const subscription = (0, _rxjs.combineLatest)({
       transactions: transactionsObservable,
       processMap: processTransactionObservable
-    }).subscribe(_ref53 => {
+    }).subscribe(_ref57 => {
       let {
         processMap,
         transactions
-      } = _ref53;
+      } = _ref57;
       cb(convertRs(transactions, processMap));
     });
     port.onDisconnect.addListener(() => {
@@ -2966,10 +3288,10 @@ class KoniExtension {
     });
     return notificationSubject.value;
   }
-  async reloadCron(_ref54) {
+  async reloadCron(_ref58) {
     let {
       data
-    } = _ref54;
+    } = _ref58;
     if (data === 'nft') {
       return await this.#koniState.reloadNft();
     } else if (data === 'staking') {
@@ -3012,10 +3334,10 @@ class KoniExtension {
   }
 
   // Phishing detect
-  async passPhishingPage(_ref55) {
+  async passPhishingPage(_ref59) {
     let {
       url
-    } = _ref55;
+    } = _ref59;
     return await this.#koniState.approvePassPhishingPage(url);
   }
 
@@ -3036,10 +3358,10 @@ class KoniExtension {
   /// Wallet connect
 
   // Connect
-  async connectWalletConnect(_ref56) {
+  async connectWalletConnect(_ref60) {
     let {
       uri
-    } = _ref56;
+    } = _ref60;
     await this.#koniState.walletConnectService.connect(uri);
     return true;
   }
@@ -3052,11 +3374,11 @@ class KoniExtension {
     });
     return this.#koniState.requestService.allConnectWCRequests;
   }
-  async approveWalletConnectSession(_ref57) {
+  async approveWalletConnectSession(_ref61) {
     let {
       accounts: selectedAccounts,
       id
-    } = _ref57;
+    } = _ref61;
     const request = this.#koniState.requestService.getConnectWCRequest(id);
     if ((0, _helpers2.isProposalExpired)(request.request.params)) {
       throw new Error('The proposal has been expired');
@@ -3068,22 +3390,22 @@ class KoniExtension {
     const availableNamespaces = {};
     const namespaces = {};
     const chainInfoMap = this.#koniState.getChainInfoMap();
-    Object.entries(requiredNamespaces).forEach(_ref58 => {
-      let [key, namespace] = _ref58;
+    Object.entries(requiredNamespaces).forEach(_ref62 => {
+      let [key, namespace] = _ref62;
       if ((0, _helpers2.isSupportWalletConnectNamespace)(key)) {
         if (namespace.chains) {
           const unSupportChains = namespace.chains.filter(chain => !(0, _helpers2.isSupportWalletConnectChain)(chain, chainInfoMap));
           if (unSupportChains.length) {
-            throw new Error((0, _utils9.getSdkError)('UNSUPPORTED_CHAINS').message + ' ' + unSupportChains.toString());
+            throw new Error((0, _utils10.getSdkError)('UNSUPPORTED_CHAINS').message + ' ' + unSupportChains.toString());
           }
           availableNamespaces[key] = namespace;
         }
       } else {
-        throw new Error((0, _utils9.getSdkError)('UNSUPPORTED_NAMESPACE_KEY').message + ' ' + key);
+        throw new Error((0, _utils10.getSdkError)('UNSUPPORTED_NAMESPACE_KEY').message + ' ' + key);
       }
     });
-    Object.entries(optionalNamespaces).forEach(_ref59 => {
-      let [key, namespace] = _ref59;
+    Object.entries(optionalNamespaces).forEach(_ref63 => {
+      let [key, namespace] = _ref63;
       if ((0, _helpers2.isSupportWalletConnectNamespace)(key)) {
         if (namespace.chains) {
           const supportChains = namespace.chains.filter(chain => (0, _helpers2.isSupportWalletConnectChain)(chain, chainInfoMap)) || [];
@@ -3107,8 +3429,8 @@ class KoniExtension {
         }
       }
     });
-    Object.entries(availableNamespaces).forEach(_ref60 => {
-      let [key, namespace] = _ref60;
+    Object.entries(availableNamespaces).forEach(_ref64 => {
+      let [key, namespace] = _ref64;
       if (namespace.chains) {
         const accounts = selectedAccounts.filter(address => {
           const [_namespace] = address.split(':');
@@ -3132,10 +3454,10 @@ class KoniExtension {
     request.resolve();
     return true;
   }
-  async rejectWalletConnectSession(_ref61) {
+  async rejectWalletConnectSession(_ref65) {
     let {
       id
-    } = _ref61;
+    } = _ref65;
     const request = this.#koniState.requestService.getConnectWCRequest(id);
     const wcId = request.request.id;
     if ((0, _helpers2.isProposalExpired)(request.request.params)) {
@@ -3157,10 +3479,10 @@ class KoniExtension {
     });
     return this.#koniState.walletConnectService.sessions;
   }
-  async disconnectWalletConnectSession(_ref62) {
+  async disconnectWalletConnectSession(_ref66) {
     let {
       topic
-    } = _ref62;
+    } = _ref66;
     await this.#koniState.walletConnectService.disconnect(topic);
     return true;
   }
@@ -3173,18 +3495,18 @@ class KoniExtension {
     });
     return this.#koniState.requestService.allNotSupportWCRequests;
   }
-  approveWalletConnectNotSupport(_ref63) {
+  approveWalletConnectNotSupport(_ref67) {
     let {
       id
-    } = _ref63;
+    } = _ref67;
     const request = this.#koniState.requestService.getNotSupportWCRequest(id);
     request.resolve();
     return true;
   }
-  rejectWalletConnectNotSupport(_ref64) {
+  rejectWalletConnectNotSupport(_ref68) {
     let {
       id
-    } = _ref64;
+    } = _ref68;
     const request = this.#koniState.requestService.getNotSupportWCRequest(id);
     request.reject(new Error('USER_REJECTED'));
     return true;
@@ -3192,11 +3514,11 @@ class KoniExtension {
 
   /// Manta
 
-  async enableMantaPay(_ref65) {
+  async enableMantaPay(_ref69) {
     let {
       address,
       password
-    } = _ref65;
+    } = _ref69;
     // always takes the current account
     function timeout() {
       return new Promise(resolve => setTimeout(resolve, 1500));
@@ -3286,11 +3608,11 @@ class KoniExtension {
   async disableMantaPay(address) {
     return this.#koniState.disableMantaPay(address);
   }
-  async isTonBounceableAddress(_ref66) {
+  async isTonBounceableAddress(_ref70) {
     let {
       address,
       chain
-    } = _ref66;
+    } = _ref70;
     try {
       const tonApi = this.#koniState.getTonApi(chain);
       const state = await tonApi.getAccountState(address);
@@ -3336,10 +3658,10 @@ class KoniExtension {
 
   /* Metadata */
 
-  async findRawMetadata(_ref67) {
+  async findRawMetadata(_ref71) {
     let {
       genesisHash
-    } = _ref67;
+    } = _ref71;
     const {
       metadata,
       specVersion,
@@ -3353,20 +3675,20 @@ class KoniExtension {
       userExtensions
     };
   }
-  async calculateMetadataHash(_ref68) {
+  async calculateMetadataHash(_ref72) {
     let {
       chain
-    } = _ref68;
+    } = _ref72;
     const hash = await this.#koniState.calculateMetadataHash(chain);
     return {
       metadataHash: hash || ''
     };
   }
-  async shortenMetadata(_ref69) {
+  async shortenMetadata(_ref73) {
     let {
       chain,
       txBlob
-    } = _ref69;
+    } = _ref73;
     const shorten = await this.#koniState.shortenMetadata(chain, txBlob);
     return {
       txMetadata: shorten || ''
@@ -3719,18 +4041,18 @@ class KoniExtension {
 
   /* Campaign */
 
-  unlockDotCheckCanMint(_ref70) {
+  unlockDotCheckCanMint(_ref74) {
     let {
       address,
       network,
       slug
-    } = _ref70;
+    } = _ref74;
     return this.#koniState.mintCampaignService.unlockDotCampaign.canMint(address, slug, network);
   }
-  unlockDotSubscribeMintedData(id, port, _ref71) {
+  unlockDotSubscribeMintedData(id, port, _ref75) {
     let {
       transactionId
-    } = _ref71;
+    } = _ref75;
     const cb = (0, _subscriptions.createSubscription)(id, port);
     const subscription = this.#koniState.mintCampaignService.unlockDotCampaign.subscribeMintedNft(transactionId, cb);
     this.createUnsubscriptionHandle(id, subscription.unsubscribe);
@@ -3762,10 +4084,10 @@ class KoniExtension {
     });
     return filterBanner(await this.#koniState.campaignService.getProcessingCampaign());
   }
-  async completeCampaignBanner(_ref72) {
+  async completeCampaignBanner(_ref76) {
     let {
       slug
-    } = _ref72;
+    } = _ref76;
     const campaign = await this.#koniState.dbService.getCampaign(slug);
     if (campaign) {
       await this.#koniState.dbService.upsertCampaign({
@@ -4300,8 +4622,8 @@ class KoniExtension {
                         resolve();
                       }
                     };
-                    this.#koniState.balanceService.subscribeTransferableBalance(address, waitXcmData.chain, waitXcmData.token, waitXcmData.nextTxType, onRs).then(_ref73 => {
-                      let [_unsub, rs] = _ref73;
+                    this.#koniState.balanceService.subscribeTransferableBalance(address, waitXcmData.chain, waitXcmData.token, waitXcmData.nextTxType, onRs).then(_ref77 => {
+                      let [_unsub, rs] = _ref77;
                       unsub = _unsub;
                       onRs(rs);
                     }).catch(console.error);
@@ -4732,6 +5054,8 @@ class KoniExtension {
         return await this.updateAssetSetting(request);
       case 'pri(transfer.subscribe)':
         return this.subscribeMaxTransferable(request, id, port);
+      case 'pri(transfer.confirmation.subscribe)':
+        return this.subscribeTransferableWhenConfirmation(request, id, port);
       case 'pri(freeBalance.get)':
         return this.getAddressTransferableBalance(request);
       case 'pri(freeBalance.subscribe)':
@@ -4750,6 +5074,10 @@ class KoniExtension {
       /// Transfer
       case 'pri(accounts.transfer)':
         return await this.makeTransfer(request);
+      case 'pri(accounts.bitcoin.dapp.transfer.confirmation)':
+        return await this.makeBitcoinDappTransferConfirmation(request);
+      case 'pri(accounts.psbt.transfer.confirmation)':
+        return await this.makePsbtTransferAfterConfirmation(request);
       case 'pri(accounts.crossChainTransfer)':
         return await this.makeCrossChainTransfer(request);
       case 'pri(accounts.getOptimalTransferProcess)':