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

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

@@ -8,6 +8,7 @@ var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
 var _constants = require("@subwallet/extension-base/constants");
 var _types = require("@subwallet/extension-base/services/base/types");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _bitcoinHistory = require("@subwallet/extension-base/services/history-service/bitcoin-history");
 var _recoverHistoryStatus = require("@subwallet/extension-base/services/history-service/helpers/recoverHistoryStatus");
 var _subscanExtrinsicParserHelper = require("@subwallet/extension-base/services/history-service/helpers/subscan-extrinsic-parser-helper");
 var _subscanHistory = require("@subwallet/extension-base/services/history-service/subscan-history");
@@ -149,20 +150,48 @@ class HistoryService {
       console.log('fetchAllPossibleTransferItems-receive error', e);
     });
   }
+
+  // Only 1 address is passed in
+  async fetchBitcoinTransactionHistory(chain, addresses) {
+    const chainInfo = this.chainService.getChainInfoByKey(chain);
+    const chainState = this.chainService.getChainStateByKey(chain);
+    if (!chainState.active) {
+      return;
+    }
+    const bitcoinApi = this.chainService.getBitcoinApi(chain);
+    const allParsedItems = [];
+    for (const address of addresses) {
+      const transferItems = await bitcoinApi.api.getAddressTransaction(address);
+      const parsedItems = transferItems.map((item, index) => {
+        const parsedItem = (0, _bitcoinHistory.parseBitcoinTransferData)(address, item, chainInfo);
+        return {
+          ...parsedItem,
+          apiTxIndex: index
+        };
+      });
+      allParsedItems.push(...parsedItems);
+    }
+    await this.addHistoryItems(allParsedItems);
+  }
   subscribeHistories(chain, proxyId, cb) {
     const addresses = this.keyringService.context.getDecodedAddresses(proxyId, false);
+    const chainInfo = this.chainService.getChainInfoByKey(chain);
     const evmAddresses = (0, _utils2.getAddressesByChainType)(addresses, [_KoniTypes.ChainType.EVM]);
     const substrateAddresses = (0, _utils2.getAddressesByChainType)(addresses, [_KoniTypes.ChainType.SUBSTRATE]);
+    const bitcoinAddresses = (0, _utils2.getAddressesByChainType)(addresses, [_KoniTypes.ChainType.BITCOIN], chainInfo);
     const subscription = this.historySubject.subscribe(items => {
       cb(items.filter(filterHistoryItemByAddressAndChain(chain, addresses)));
     });
-    const chainInfo = this.chainService.getChainInfoByKey(chain);
     if ((0, _utils._isChainSubstrateCompatible)(chainInfo)) {
       if ((0, _utils._isChainEvmCompatible)(chainInfo)) {
         this.fetchSubscanTransactionHistory(chain, evmAddresses);
       } else {
         this.fetchSubscanTransactionHistory(chain, substrateAddresses);
       }
+    } else if ((0, _utils._isChainBitcoinCompatible)(chainInfo)) {
+      this.fetchBitcoinTransactionHistory(chain, bitcoinAddresses).catch(e => {
+        console.log('fetchBitcoinTransactionHistory Error', e);
+      });
     }
     return {
       unsubscribe: subscription.unsubscribe,
@@ -203,7 +232,8 @@ class HistoryService {
       if (needUpdateItem) {
         updateRecords.push({
           ...needUpdateItem,
-          status: item.status
+          status: item.status,
+          apiTxIndex: item.apiTxIndex
         });
         return;
       }
@@ -256,6 +286,9 @@ class HistoryService {
       switch (recoverResult.status) {
         case _recoverHistoryStatus.HistoryRecoverStatus.API_INACTIVE:
           break;
+        case _recoverHistoryStatus.HistoryRecoverStatus.TX_PENDING:
+          delete this.#needRecoveryHistories[currentExtrinsicHash];
+          break;
         case _recoverHistoryStatus.HistoryRecoverStatus.FAILED:
         case _recoverHistoryStatus.HistoryRecoverStatus.SUCCESS:
           updateData.status = recoverResult.status === _recoverHistoryStatus.HistoryRecoverStatus.SUCCESS ? _KoniTypes.ExtrinsicStatus.SUCCESS : _KoniTypes.ExtrinsicStatus.FAIL;
@@ -293,7 +326,12 @@ class HistoryService {
     const histories = await this.dbService.getHistories();
     this.#needRecoveryHistories = {};
     histories.filter(history => {
-      return [_KoniTypes.ExtrinsicStatus.PROCESSING, _KoniTypes.ExtrinsicStatus.SUBMITTING].includes(history.status);
+      if ([_KoniTypes.ExtrinsicStatus.PROCESSING, _KoniTypes.ExtrinsicStatus.SUBMITTING].includes(history.status)) {
+        return true;
+      } else if (history.status === _KoniTypes.ExtrinsicStatus.SUCCESS && history.chainType === 'bitcoin') {
+        return !history.blockTime;
+      }
+      return false;
     }).filter(history => {
       if (history.type === _KoniTypes.ExtrinsicType.TRANSFER_XCM) {
         const data = history.additionalInfo;

package/cjs/services/keyring-service/context/handlers/Derive.js

@@ -15,7 +15,7 @@ var _Base = require("./Base");
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-const validDeriveKeypairTypes = [..._types2.SubstrateKeypairTypes, ..._types2.EthereumKeypairTypes, 'ton', 'cardano'];
+const validDeriveKeypairTypes = [..._types2.SubstrateKeypairTypes, ..._types2.EthereumKeypairTypes, 'ton', 'cardano', ..._types2.BitcoinKeypairTypes];
 
 /**
  * @class AccountDeriveHandler

package/cjs/services/keyring-service/context/handlers/Migration.js

@@ -82,7 +82,7 @@ class AccountMigrationHandler extends _Base.AccountBaseHandler {
           proxyId
         }).result;
         const newChainTypes = Object.values(_types.AccountChainType).filter(type => !unifiedAccount.chainTypes.includes(type) && _types.SUPPORTED_ACCOUNT_CHAIN_TYPES.includes(type));
-        const keypairTypes = newChainTypes.map(chainType => (0, _utils.getDefaultKeypairTypeFromAccountChainType)(chainType));
+        const keypairTypes = newChainTypes.flatMap(chainType => (0, _utils.getDefaultKeypairTypeFromAccountChainType)(chainType));
         keypairTypes.forEach(type => {
           const suri = (0, _utils.getSuri)(mnemonic, type);
           const pair = _uiKeyring.keyring.createFromUri(suri, {}, type);
@@ -187,7 +187,7 @@ class AccountMigrationHandler extends _Base.AccountBaseHandler {
         password,
         proxyId: firstAccountOldProxyId
       }).result;
-      const keypairTypes = _types.SUPPORTED_ACCOUNT_CHAIN_TYPES.map(chainType => (0, _utils.getDefaultKeypairTypeFromAccountChainType)(chainType));
+      const keypairTypes = _types.SUPPORTED_ACCOUNT_CHAIN_TYPES.flatMap(chainType => (0, _utils.getDefaultKeypairTypeFromAccountChainType)(chainType));
       keypairTypes.forEach(type => {
         const suri = (0, _utils.getSuri)(mnemonic, type);
         const pair = _uiKeyring.keyring.createFromUri(suri, {}, type);

package/cjs/services/keyring-service/context/handlers/Mnemonic.js

@@ -7,6 +7,7 @@ exports.SEED_LENGTHS = exports.SEED_DEFAULT_LENGTH = exports.AccountMnemonicHand
 var _types = require("@subwallet/extension-base/types");
 var _utils = require("@subwallet/extension-base/utils");
 var _keyring = require("@subwallet/keyring");
+var _types2 = require("@subwallet/keyring/types");
 var _utils2 = require("@subwallet/keyring/utils");
 var _uiKeyring = require("@subwallet/ui-keyring");
 var _i18next = require("i18next");
@@ -36,7 +37,7 @@ class AccountMnemonicHandler extends _Base.AccountBaseHandler {
       mnemonic: _seed,
       type = 'general'
     } = _ref;
-    const types = type === 'general' ? ['sr25519', 'ethereum', 'ton', 'cardano'] : ['ton-native'];
+    const types = type === 'general' ? ['sr25519', ..._types2.EthereumKeypairTypes, 'ton', ..._types2.CardanoKeypairTypes, ..._types2.BitcoinKeypairTypes] : ['ton-native'];
     const seed = _seed || type === 'general' ? (0, _utilCrypto.mnemonicGenerate)(length) : await (0, _keyring.tonMnemonicGenerate)(length);
     const rs = {
       mnemonic: seed,
@@ -70,7 +71,7 @@ class AccountMnemonicHandler extends _Base.AccountBaseHandler {
       try {
         (0, _util.assert)((0, _utilCrypto.mnemonicValidate)(phrase), (0, _i18next.t)('Invalid seed phrase. Please try again.'));
         mnemonicTypes = 'general';
-        pairTypes = ['sr25519', 'ethereum', 'ton'];
+        pairTypes = ['sr25519', ..._types2.EthereumKeypairTypes, 'ton', ..._types2.CardanoKeypairTypes, ..._types2.BitcoinKeypairTypes];
       } catch (e) {
         (0, _util.assert)((0, _utils2.tonMnemonicValidate)(phrase), (0, _i18next.t)('Invalid seed phrase. Please try again.'));
         mnemonicTypes = 'ton';
@@ -107,7 +108,7 @@ class AccountMnemonicHandler extends _Base.AccountBaseHandler {
     const addressDict = {};
     let changedAccount = false;
     const hasMasterPassword = _uiKeyring.keyring.keyring.hasMasterPassword;
-    const types = type ? [type] : ['sr25519', 'ethereum', 'ton', 'cardano'];
+    const types = type ? [type] : ['sr25519', ..._types2.EthereumKeypairTypes, 'ton', ..._types2.CardanoKeypairTypes, ..._types2.BitcoinKeypairTypes];
     if (!hasMasterPassword) {
       if (!password) {
         throw Error((0, _i18next.t)('The password of each account is needed to set up master password'));

package/cjs/services/migration-service/scripts/MigrateNewUnifiedAccount.js

@@ -0,0 +1,29 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _Base = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/Base"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class MigrateNewUnifiedAccount extends _Base.default {
+  async run() {
+    try {
+      return new Promise(resolve => {
+        this.state.settingService.getSettings(currentSettings => {
+          this.state.settingService.setSettings({
+            ...currentSettings,
+            isAcknowledgedUnifiedAccountMigration: false
+          });
+          resolve();
+        });
+      });
+    } catch (e) {
+      console.error(e);
+    }
+  }
+}
+exports.default = MigrateNewUnifiedAccount;

package/cjs/services/migration-service/scripts/index.js

@@ -26,6 +26,7 @@ var _EnableVaraChain = _interopRequireDefault(require("./EnableVaraChain"));
 var _MigrateAuthUrls = _interopRequireDefault(require("./MigrateAuthUrls"));
 var _MigrateImportedToken = _interopRequireDefault(require("./MigrateImportedToken"));
 var _MigrateNetworkSettings = _interopRequireDefault(require("./MigrateNetworkSettings"));
+var _MigrateNewUnifiedAccount = _interopRequireDefault(require("./MigrateNewUnifiedAccount"));
 var _MigrateTokenDecimals = _interopRequireDefault(require("./MigrateTokenDecimals"));
 var _MigrateTransactionHistory = _interopRequireDefault(require("./MigrateTransactionHistory"));
 var _MigrateTransactionHistoryBridge = _interopRequireDefault(require("./MigrateTransactionHistoryBridge"));
@@ -70,8 +71,9 @@ var _default = {
   '1.3.6-01': _MigrateTransactionHistoryBridge.default,
   '1.3.10-01': _ClearMetadataDatabase.default,
   '1.3.26-01': _DisableZeroBalanceTokens.default,
-  [MYTHOS_MIGRATION_KEY]: _ClearMetadataForMythos.default
+  [MYTHOS_MIGRATION_KEY]: _ClearMetadataForMythos.default,
   // [`${EVERYTIME}-1.1.42-02`]: MigrateTransactionHistoryBySymbol
   // [`${EVERYTIME}-1`]: AutoEnableChainsTokens
+  '1.3.42-01': _MigrateNewUnifiedAccount.default
 };
 exports.default = _default;

package/cjs/services/request-service/handler/BitcoinRequestHandler.js

@@ -0,0 +1,440 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _BitcoinProviderError = require("@subwallet/extension-base/background/errors/BitcoinProviderError");
+var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _bitcoinTransfer = require("@subwallet/extension-base/services/balance-service/transfer/bitcoin-transfer");
+var _types = require("@subwallet/extension-base/types");
+var _utils = require("@subwallet/extension-base/utils");
+var _getId = require("@subwallet/extension-base/utils/getId");
+var _request = require("@subwallet/extension-base/utils/request");
+var _uiKeyring = _interopRequireDefault(require("@subwallet/ui-keyring"));
+var bitcoin = _interopRequireWildcard(require("bitcoinjs-lib"));
+var _i18next = require("i18next");
+var _rxjs = require("rxjs");
+var _util = require("@polkadot/util");
+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-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class BitcoinRequestHandler {
+  #requestService;
+  #chainService;
+  #transactionService;
+  #feeService;
+  #logger;
+  confirmationsQueueSubjectBitcoin = new _rxjs.BehaviorSubject({
+    bitcoinSignatureRequest: {},
+    bitcoinSendTransactionRequest: {},
+    bitcoinWatchTransactionRequest: {},
+    bitcoinSendTransactionRequestAfterConfirmation: {},
+    bitcoinSignPsbtRequest: {}
+  });
+  confirmationsPromiseMap = {};
+  constructor(requestService, chainService, feeService, transactionService) {
+    this.#requestService = requestService;
+    this.#chainService = chainService;
+    this.#feeService = feeService;
+    this.#transactionService = transactionService;
+    this.#logger = (0, _util.logger)('BitcoinRequestHandler');
+  }
+  get numBitcoinRequests() {
+    let count = 0;
+    Object.values(this.confirmationsQueueSubjectBitcoin.getValue()).forEach(x => {
+      count += Object.keys(x).length;
+    });
+    return count;
+  }
+  getConfirmationsQueueSubjectBitcoin() {
+    return this.confirmationsQueueSubjectBitcoin;
+  }
+  async addConfirmationBitcoin(id, url, type, payload) {
+    let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+    let validator = arguments.length > 5 ? arguments[5] : undefined;
+    const confirmations = this.confirmationsQueueSubjectBitcoin.getValue();
+    const confirmationType = confirmations[type];
+    const payloadJson = JSON.stringify(payload);
+    const isInternal = (0, _request.isInternalRequest)(url);
+    if (['bitcoinSignatureRequest', 'bitcoinSendTransactionRequest', 'bitcoinSendTransactionRequestAfterConfirmation'].includes(type)) {
+      const isAlwaysRequired = await this.#requestService.settingService.isAlwaysRequired;
+      if (isAlwaysRequired) {
+        this.#requestService.keyringService.lock();
+      }
+    }
+
+    // Check duplicate request
+    const duplicated = Object.values(confirmationType).find(c => c.url === url && c.payloadJson === payloadJson);
+    if (duplicated) {
+      throw new Error('Duplicate request');
+    }
+    confirmationType[id] = {
+      id,
+      url,
+      isInternal,
+      payload,
+      payloadJson,
+      ...options
+    };
+    const promise = new Promise((resolve, reject) => {
+      this.confirmationsPromiseMap[id] = {
+        validator: validator,
+        resolver: {
+          resolve: resolve,
+          reject: reject
+        }
+      };
+    });
+    this.confirmationsQueueSubjectBitcoin.next(confirmations);
+    if (!isInternal) {
+      this.#requestService.popupOpen();
+    }
+    this.#requestService.updateIconV2();
+    return promise;
+  }
+  updateConfirmationBitcoin(id, type, payload) {
+    let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+    let validator = arguments.length > 4 ? arguments[4] : undefined;
+    const confirmations = this.confirmationsQueueSubjectBitcoin.getValue();
+    const confirmationType = confirmations[type];
+
+    // Check duplicate request
+    const exists = confirmationType[id];
+    if (!exists) {
+      throw new Error('Request does not exist');
+    }
+    const payloadJson = JSON.stringify(payload);
+    confirmationType[id] = {
+      ...exists,
+      payload,
+      payloadJson,
+      ...options
+    };
+    if (validator) {
+      this.confirmationsPromiseMap[id].validator = validator;
+    }
+    this.confirmationsQueueSubjectBitcoin.next(confirmations);
+  }
+  signMessageBitcoin(confirmation) {
+    const {
+      account,
+      payload
+    } = confirmation.payload;
+    const address = account.address;
+    const pair = _uiKeyring.default.getPair(address);
+    if (pair.isLocked) {
+      _uiKeyring.default.unlockPair(pair.address);
+    }
+
+    // Check if payload is a string
+    if (typeof payload === 'string') {
+      // Assume BitcoinSigner is an instance that implements the BitcoinSigner interface
+      return {
+        signature: pair.bitcoin.signMessage(payload),
+        message: payload,
+        address
+      }; // Assuming compressed = false
+    } else if (payload instanceof Uint8Array) {
+      // Check if payload is a byte array (Uint8Array)
+      // Convert Uint8Array to string
+      const payloadString = Buffer.from(payload).toString('hex');
+
+      // Assume BitcoinSigner is an instance that implements the BitcoinSigner interface
+      return {
+        signature: pair.bitcoin.signMessage(payloadString),
+        message: payload.toString(),
+        address
+      }; // Assuming compressed = false
+    } else {
+      // Handle the case where payload is invalid
+      throw new Error('Invalid payload type');
+    }
+  }
+  signTransactionBitcoin(request) {
+    // Extract necessary information from the BitcoinSendTransactionRequest
+    const {
+      account,
+      hashPayload
+    } = request.payload;
+    const address = account.address;
+    const pair = _uiKeyring.default.getPair(address);
+
+    // Unlock the pair if it is locked
+    if (pair.isLocked) {
+      _uiKeyring.default.unlockPair(pair.address);
+    }
+    const psbt = bitcoin.Psbt.fromHex(hashPayload);
+
+    // Finalize all inputs in the Psbt
+    // Sign the Psbt using the pair's bitcoin object
+    const signedTransaction = pair.bitcoin.signTransaction(psbt, psbt.txInputs.map((v, i) => i));
+    signedTransaction.finalizeAllInputs();
+    return signedTransaction.extractTransaction().toHex();
+  }
+  async signTransactionBitcoinWithPayload(request) {
+    const transaction = this.#transactionService.getTransaction(request.id);
+    const {
+      chain,
+      emitterTransaction,
+      feeCustom,
+      feeOption,
+      id
+    } = transaction;
+    const {
+      from,
+      to,
+      value
+    } = transaction.data;
+    if (!emitterTransaction) {
+      throw new _BitcoinProviderError.BitcoinProviderError(_KoniTypes.BitcoinProviderErrorType.INTERNAL_ERROR);
+    }
+    const chainInfo = this.#chainService.getChainInfoByKey(chain);
+    const bitcoinApi = this.#chainService.getBitcoinApi(chain);
+    const eventData = {
+      id,
+      errors: [],
+      warnings: [],
+      extrinsicHash: id
+    };
+    const network = chainInfo.isTestnet ? bitcoin.networks.testnet : bitcoin.networks.bitcoin;
+    const feeInfo = await this.#feeService.subscribeChainFee((0, _getId.getId)(), chain, 'bitcoin');
+    const [psbt] = await (0, _bitcoinTransfer.createBitcoinTransaction)({
+      bitcoinApi,
+      chain,
+      from,
+      feeCustom,
+      feeOption,
+      feeInfo,
+      to,
+      transferAll: false,
+      value: value || '0',
+      network
+    });
+    const pair = _uiKeyring.default.getPair(from);
+
+    // Unlock the pair if it is locked
+    if (pair.isLocked) {
+      _uiKeyring.default.unlockPair(pair.address);
+    }
+
+    // Finalize all inputs in the Psbt
+
+    // Sign the Psbt using the pair's bitcoin object
+    const signedTransaction = pair.bitcoin.signTransaction(psbt, psbt.txInputs.map((v, i) => i));
+    signedTransaction.finalizeAllInputs();
+    const signature = signedTransaction.extractTransaction().toHex();
+    this.#transactionService.emitterEventTransaction(emitterTransaction, eventData, chainInfo.slug, signature);
+    const {
+      promise,
+      reject,
+      resolve
+    } = (0, _utils.createPromiseHandler)();
+    emitterTransaction.on('extrinsicHash', data => {
+      if (!data.extrinsicHash) {
+        reject(_KoniTypes.BitcoinProviderErrorType.INTERNAL_ERROR);
+      } else {
+        resolve(data.extrinsicHash);
+      }
+    });
+    emitterTransaction.on('error', error => {
+      reject(error);
+    });
+    return promise;
+  }
+  async signPsbt(request) {
+    // Extract necessary information from the BitcoinSendTransactionRequest
+    const {
+      account,
+      payload
+    } = request.payload;
+    const {
+      allowedSighash,
+      broadcast,
+      psbt,
+      signAtIndex
+    } = payload;
+    const transaction = this.#transactionService.getTransaction(request.id);
+    let eventData = {
+      id: request.id,
+      errors: [],
+      warnings: [],
+      extrinsicHash: request.id
+    };
+
+    // todo: validate type of the account
+
+    if (Object.keys(account).length === 0) {
+      throw new _BitcoinProviderError.BitcoinProviderError(_KoniTypes.BitcoinProviderErrorType.INVALID_PARAMS, 'Please connect to Wallet to try this request');
+    }
+    const pair = _uiKeyring.default.getPair(account.address);
+
+    // Unlock the pair if it is locked
+    if (pair.isLocked) {
+      _uiKeyring.default.unlockPair(pair.address);
+    }
+    const signAtIndexGenerate = signAtIndex ? (0, _util.isArray)(signAtIndex) ? signAtIndex : [signAtIndex] : [...Array(psbt.inputCount)].map((_, i) => i);
+    let psptSignedTransaction = null;
+
+    // Sign the Psbt using the pair's bitcoin object
+    try {
+      psptSignedTransaction = pair.bitcoin.signTransaction(psbt, signAtIndexGenerate, allowedSighash);
+    } catch (e) {
+      if (transaction) {
+        var _transaction$emitterT;
+        (_transaction$emitterT = transaction.emitterTransaction) === null || _transaction$emitterT === void 0 ? void 0 : _transaction$emitterT.emit('error', {
+          ...eventData,
+          errors: [new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, e.message)],
+          id: transaction.id,
+          extrinsicHash: transaction.id
+        });
+      }
+      throw new Error(e.message);
+    }
+    if (!psptSignedTransaction) {
+      throw new Error('Unable to sign');
+    }
+    if (!broadcast) {
+      for (const index of signAtIndexGenerate) {
+        psptSignedTransaction.finalizeInput(index);
+      }
+      return {
+        psbt: psptSignedTransaction.toHex()
+      };
+    }
+    if (!transaction) {
+      throw new _BitcoinProviderError.BitcoinProviderError(_KoniTypes.BitcoinProviderErrorType.INTERNAL_ERROR);
+    }
+    const {
+      chain,
+      emitterTransaction,
+      id
+    } = transaction;
+    eventData = {
+      id,
+      errors: [],
+      warnings: [],
+      extrinsicHash: id
+    };
+    if (!emitterTransaction) {
+      throw new _BitcoinProviderError.BitcoinProviderError(_KoniTypes.BitcoinProviderErrorType.INTERNAL_ERROR);
+    }
+    const chainInfo = this.#chainService.getChainInfoByKey(chain);
+    try {
+      psptSignedTransaction.finalizeAllInputs();
+    } catch (e) {
+      emitterTransaction.emit('error', {
+        ...eventData,
+        errors: [new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, e.message)]
+      });
+      throw new Error(e.message);
+    }
+    const hexTransaction = psptSignedTransaction.extractTransaction().toHex();
+    this.#transactionService.emitterEventTransaction(emitterTransaction, eventData, chainInfo.slug, hexTransaction);
+    const {
+      promise,
+      reject,
+      resolve
+    } = (0, _utils.createPromiseHandler)();
+    emitterTransaction.on('extrinsicHash', data => {
+      if (!data.extrinsicHash || !psptSignedTransaction) {
+        reject(_KoniTypes.BitcoinProviderErrorType.INTERNAL_ERROR);
+      } else {
+        var _psptSignedTransactio;
+        resolve({
+          psbt: (_psptSignedTransactio = psptSignedTransaction) === null || _psptSignedTransactio === void 0 ? void 0 : _psptSignedTransactio.toHex(),
+          txid: data.extrinsicHash
+        });
+      }
+    });
+    emitterTransaction.on('error', error => {
+      reject(error);
+    });
+    return promise;
+  }
+  async decorateResultBitcoin(t, request, result) {
+    if (t === 'bitcoinSignatureRequest') {
+      result.payload = this.signMessageBitcoin(request);
+    } else if (t === 'bitcoinSendTransactionRequest') {
+      result.payload = this.signTransactionBitcoin(request);
+    } else if (t === 'bitcoinSignPsbtRequest') {
+      result.payload = await this.signPsbt(request);
+    } else if (t === 'bitcoinSendTransactionRequestAfterConfirmation') {
+      result.payload = await this.signTransactionBitcoinWithPayload(request);
+    }
+    if (t === 'bitcoinSignatureRequest' || t === 'bitcoinSendTransactionRequest' || t === 'bitcoinSignPsbtRequest' || t === 'bitcoinSendTransactionRequestAfterConfirmation') {
+      const isAlwaysRequired = await this.#requestService.settingService.isAlwaysRequired;
+      if (isAlwaysRequired) {
+        this.#requestService.keyringService.lock();
+      }
+    }
+  }
+  async completeConfirmationBitcoin(request) {
+    const confirmations = this.confirmationsQueueSubjectBitcoin.getValue();
+    for (const ct in request) {
+      const type = ct;
+      const result = request[type];
+      const {
+        id,
+        isApproved
+      } = result;
+      const {
+        resolver,
+        validator
+      } = this.confirmationsPromiseMap[id];
+      const confirmation = confirmations[type][id];
+      if (!resolver || !confirmation) {
+        this.#logger.error((0, _i18next.t)('Unable to proceed. Please try again'), type, id);
+        throw new Error('Unable to proceed. Please try again');
+      }
+      if (isApproved) {
+        try {
+          // Fill signature for some special type
+          await this.decorateResultBitcoin(type, confirmation, result);
+          const error = validator && validator(result);
+          if (error) {
+            resolver.reject(error);
+          }
+        } catch (e) {
+          resolver.reject(e);
+        }
+      }
+
+      // Delete confirmations from queue
+      delete this.confirmationsPromiseMap[id];
+      delete confirmations[type][id];
+      this.confirmationsQueueSubjectBitcoin.next(confirmations);
+
+      // Update icon, and close queue
+      this.#requestService.updateIconV2(this.#requestService.numAllRequests === 0);
+      resolver.resolve(result);
+    }
+    return true;
+  }
+  resetWallet() {
+    const confirmations = this.confirmationsQueueSubjectBitcoin.getValue();
+    for (const [type, requests] of Object.entries(confirmations)) {
+      for (const confirmation of Object.values(requests)) {
+        const {
+          id
+        } = confirmation;
+        const {
+          resolver
+        } = this.confirmationsPromiseMap[id];
+        if (!resolver || !confirmation) {
+          console.error('Not found confirmation', type, id);
+        } else {
+          resolver.reject(new Error('Reset wallet'));
+        }
+        delete this.confirmationsPromiseMap[id];
+        delete confirmations[type][id];
+      }
+    }
+    this.confirmationsQueueSubjectBitcoin.next(confirmations);
+  }
+}
+exports.default = BitcoinRequestHandler;