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

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

@@ -46,10 +46,6 @@ class TransactionService {
   }
   constructor(state) {
     this.state = state;
-    this.eventService = state.eventService;
-    this.historyService = state.historyService;
-    this.notificationService = state.notificationService;
-    this.chainService = state.chainService;
   }
   get allTransactions() {
     return Object.values(this.transactions);
@@ -81,6 +77,7 @@ class TransactionService {
       additionalValidator,
       address,
       chain,
+      chainType,
       extrinsicType
     } = validationResponse;
     const chainInfo = this.state.chainService.getChainInfoByKey(chain);
@@ -110,27 +107,32 @@ class TransactionService {
     const evmApi = this.state.chainService.getEvmApi(chainInfo.slug);
     const tonApi = this.state.chainService.getTonApi(chainInfo.slug);
     const cardanoApi = this.state.chainService.getCardanoApi(chainInfo.slug);
+    const bitcoinApi = this.state.chainService.getBitcoinApi(chainInfo.slug);
     // todo: should split into isEvmTx && isNoEvmApi. Because other chains type also has no Evm Api. Same to all blockchain.
     // todo: refactor check evmTransaction.
-    const isNoEvmApi = transaction && !(0, _helpers.isSubstrateTransaction)(transaction) && !(0, _helpers.isTonTransaction)(transaction) && !(0, _helpers.isCardanoTransaction)(transaction) && !evmApi;
+    const isNoEvmApi = transaction && !(0, _helpers.isSubstrateTransaction)(transaction) && !(0, _helpers.isTonTransaction)(transaction) && !(0, _helpers.isCardanoTransaction)(transaction) && !(0, _helpers.isBitcoinTransaction)(transaction) && !evmApi;
     const isNoTonApi = transaction && (0, _helpers.isTonTransaction)(transaction) && !tonApi;
     const isNoCardanoApi = transaction && (0, _helpers.isCardanoTransaction)(transaction) && !cardanoApi;
-    if (isNoEvmApi || isNoTonApi || isNoCardanoApi) {
+    const isNoBitcoinApi = transaction && (0, _helpers.isBitcoinTransaction)(transaction) && !bitcoinApi;
+    if (isNoEvmApi || isNoTonApi || isNoCardanoApi || isNoBitcoinApi) {
       validationResponse.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.CHAIN_DISCONNECTED, undefined));
     }
 
     // Estimate fee for transaction
     const id = (0, _getId.getId)();
-    const feeInfo = await this.state.feeService.subscribeChainFee(id, chain, 'evm');
+    const feeInfo = await this.state.feeService.subscribeChainFee(id, chain, chainType);
     const nativeTokenInfo = this.state.chainService.getNativeTokenInfo(chain);
     const tokenPayFeeSlug = transactionInput.tokenPayFeeSlug;
     const isNonNativeTokenPayFee = tokenPayFeeSlug && !(0, _utils2._isNativeTokenBySlug)(tokenPayFeeSlug);
-    const nonNativeTokenPayFeeInfo = isNonNativeTokenPayFee ? this.chainService.getAssetBySlug(tokenPayFeeSlug) : undefined;
+    const nonNativeTokenPayFeeInfo = isNonNativeTokenPayFee ? this.state.chainService.getAssetBySlug(tokenPayFeeSlug) : undefined;
     const priceMap = (await this.state.priceService.getPrice()).priceMap;
-    validationResponse.estimateFee = await (0, _transfer.estimateFeeForTransaction)(validationResponse, transaction, chainInfo, evmApi, substrateApi, priceMap, feeInfo, nativeTokenInfo, nonNativeTokenPayFeeInfo, transactionInput.isTransferLocalTokenAndPayThatTokenAsFee);
+    if (!transactionInput.skipFeeRecalculation) {
+      validationResponse.estimateFee = await (0, _transfer.estimateFeeForTransaction)(validationResponse, transaction, chainInfo, evmApi, substrateApi, priceMap, feeInfo, nativeTokenInfo, nonNativeTokenPayFeeInfo, transactionInput.isTransferLocalTokenAndPayThatTokenAsFee);
+    }
     const chainInfoMap = this.state.chainService.getChainInfoMap();
 
     // Check account signing transaction
+
     (0, _transfer.checkSigningAccountForTransaction)(validationResponse, chainInfoMap);
     const nativeTokenAvailable = await this.state.balanceService.getTransferableBalance(address, chain, nativeTokenInfo.slug, extrinsicType);
 
@@ -193,7 +195,7 @@ class TransactionService {
   }
   fillTransactionDefaultInfo(transaction) {
     const isInternal = !transaction.url;
-    const transactionId = (0, _helpers.getTransactionId)(transaction.chainType, transaction.chain, isInternal, (0, _helpers2.isWalletConnectRequest)(transaction.id));
+    const transactionId = transaction.id || (0, _helpers.getTransactionId)(transaction.chainType, transaction.chain, isInternal, (0, _helpers2.isWalletConnectRequest)(transaction.id));
     return {
       ...transaction,
       createdAt: new Date().getTime(),
@@ -307,6 +309,73 @@ class TransactionService {
     'eventsHandler' in validatedTransaction && delete validatedTransaction.eventsHandler;
     return validatedTransaction;
   }
+  async handleTransactionAfterConfirmation(transaction) {
+    const validatedTransaction = await this.validateTransaction(transaction);
+    const stopByErrors = validatedTransaction.errors.length > 0;
+    const stopByWarnings = validatedTransaction.warnings.length > 0 && !validatedTransaction.ignoreWarnings;
+    if (stopByErrors || stopByWarnings) {
+      // @ts-ignore
+      'transaction' in validatedTransaction && delete validatedTransaction.transaction;
+      'additionalValidator' in validatedTransaction && delete validatedTransaction.additionalValidator;
+      'eventsHandler' in validatedTransaction && delete validatedTransaction.eventsHandler;
+      return validatedTransaction;
+    }
+    validatedTransaction.warnings = [];
+    const transactionsSubject = this.transactions;
+    const emitter = new _eventemitter.default();
+
+    // Fill transaction default info
+    const transactionUpdated = this.fillTransactionDefaultInfo(validatedTransaction);
+
+    // Add Transaction
+    transactionsSubject[transactionUpdated.id] = {
+      ...transactionUpdated,
+      emitterTransaction: emitter
+    };
+    this.transactionSubject.next({
+      ...transactionsSubject
+    });
+    emitter.on('success', data => {
+      validatedTransaction.id = data.id;
+      validatedTransaction.extrinsicHash = data.extrinsicHash;
+      this.handlePostProcessing(data.id);
+      this.onSuccess(data);
+    });
+    emitter.on('signed', data => {
+      validatedTransaction.id = data.id;
+      validatedTransaction.extrinsicHash = data.extrinsicHash;
+      this.onSigned(data);
+    });
+    emitter.on('error', data => {
+      if (data.errors.length > 0) {
+        validatedTransaction.errors.push(...data.errors);
+      }
+      this.onFailed({
+        ...data,
+        errors: [...data.errors, new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)]
+      });
+    });
+    emitter.on('send', data => {
+      this.onSend(data);
+    });
+    emitter.on('extrinsicHash', data => {
+      this.onHasTransactionHash(data);
+    });
+    emitter.on('timeout', data => {
+      this.onTimeOut({
+        ...data,
+        errors: [...data.errors, new _TransactionError.TransactionError(_types.BasicTxErrorType.TIMEOUT)]
+      });
+    });
+
+    // @ts-ignore
+    'transaction' in validatedTransaction && delete validatedTransaction.transaction;
+    'additionalValidator' in validatedTransaction && delete validatedTransaction.additionalValidator;
+    'eventsHandler' in validatedTransaction && delete validatedTransaction.eventsHandler;
+    return {
+      ...validatedTransaction
+    };
+  }
   async handlePermitTransaction(transaction) {
     var _transaction$step;
     const transactionId = (0, _helpers.getTransactionId)(transaction.chainType, transaction.chain, true);
@@ -417,7 +486,7 @@ class TransactionService {
   }
   async sendTransaction(transaction) {
     // Send Transaction
-    const emitter = await (transaction.chainType === 'substrate' ? this.signAndSendSubstrateTransaction(transaction) : transaction.chainType === 'evm' ? this.signAndSendEvmTransaction(transaction) : transaction.chainType === 'cardano' ? this.signAndSendCardanoTransaction(transaction) : this.signAndSendTonTransaction(transaction));
+    const emitter = await (transaction.chainType === 'substrate' ? this.signAndSendSubstrateTransaction(transaction) : transaction.chainType === 'evm' ? this.signAndSendEvmTransaction(transaction) : transaction.chainType === 'cardano' ? this.signAndSendCardanoTransaction(transaction) : transaction.chainType === 'ton' ? this.signAndSendTonTransaction(transaction) : this.signAndSendBitcoinTransaction(transaction));
     const {
       eventsHandler,
       step
@@ -676,6 +745,7 @@ class TransactionService {
       extrinsicHash: transaction.extrinsicHash,
       time: transaction.createdAt,
       fee: transaction.estimateFee,
+      blockTime: undefined,
       blockNumber: 0,
       // Will be added in next step
       blockHash: '',
@@ -1065,6 +1135,24 @@ class TransactionService {
     if ([_KoniTypes.ExtrinsicType.STAKING_JOIN_POOL, _KoniTypes.ExtrinsicType.STAKING_BOND, _KoniTypes.ExtrinsicType.JOIN_YIELD_POOL, _KoniTypes.ExtrinsicType.MINT_LDOT, _KoniTypes.ExtrinsicType.MINT_QDOT, _KoniTypes.ExtrinsicType.MINT_SDOT, _KoniTypes.ExtrinsicType.MINT_STDOT, _KoniTypes.ExtrinsicType.MINT_VDOT, _KoniTypes.ExtrinsicType.MINT_VMANTA].includes(transaction.extrinsicType)) {
       this.handlePostEarningTransaction(id);
     }
+
+    // Trigger balance update for Bitcoin transactions after receiving extrinsicHash
+    if (_KoniTypes.ExtrinsicType.TRANSFER_BALANCE && transaction.chainType === 'bitcoin') {
+      const balanceService = this.state.balanceService;
+      const inputData = (0, _utils3.parseTransactionData)(transaction.data);
+      try {
+        const sender = _uiKeyring.default.getPair(inputData.from);
+        balanceService.refreshBalanceForAddress(sender.address, transaction.chain, inputData.tokenSlug, transaction.extrinsicType).catch(error => console.error('Failed to run balance subscription:', error));
+      } catch (e) {
+        console.error(e);
+      }
+      try {
+        const recipient = _uiKeyring.default.getPair(inputData.to);
+        balanceService.refreshBalanceForAddress(recipient.address, transaction.chain, inputData.tokenSlug, transaction.extrinsicType).catch(error => console.error('Failed to run balance subscription:', error));
+      } catch (e) {
+        console.error(e);
+      }
+    }
   }
   handlePostProcessing(id) {
     // must be done after success/failure to make sure the transaction is finalized
@@ -1104,6 +1192,7 @@ class TransactionService {
     let {
       blockHash,
       blockNumber,
+      blockTime,
       extrinsicHash,
       id
     } = _ref4;
@@ -1118,7 +1207,8 @@ class TransactionService {
       extrinsicHash,
       status: _KoniTypes.ExtrinsicStatus.SUCCESS,
       blockNumber: blockNumber || 0,
-      blockHash: blockHash || ''
+      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({
@@ -1193,14 +1283,14 @@ class TransactionService {
         errors,
         extrinsicHash
       });
-      this.historyService.updateHistoryByExtrinsicHash(transaction.extrinsicHash, {
+      this.state.historyService.updateHistoryByExtrinsicHash(transaction.extrinsicHash, {
         extrinsicHash: extrinsicHash || transaction.extrinsicHash,
         status: nextStatus,
         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.chainService.getChainInfoMap());
-      this.notificationService.notify({
+      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)('Transaction timed out'),
         message: (0, _i18next.t)('Transaction {{info}} timed out', {
@@ -1214,7 +1304,7 @@ class TransactionService {
         notifyViaBrowser: true
       });
     }
-    this.eventService.emit('transaction.timeout', transaction);
+    this.state.eventService.emit('transaction.timeout', transaction);
   }
   generateHashPayload(chain, transaction) {
     const chainInfo = this.state.chainService.getChainInfoByKey(chain);
@@ -1894,6 +1984,106 @@ class TransactionService {
     });
     return emitter;
   }
+  emitterEventTransaction = (emitter, eventData, chain, payload) => {
+    // Emit signed event
+    emitter.emit('signed', eventData);
+    // Add start info
+    emitter.emit('send', eventData);
+    const event = this.state.chainService.getBitcoinApi(chain).api.sendRawTransaction(payload);
+    event.on('extrinsicHash', txHash => {
+      eventData.extrinsicHash = txHash;
+      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));
+      emitter.emit('error', eventData);
+    });
+  };
+  signAndSendBitcoinTransaction(_ref22) {
+    let {
+      address,
+      chain,
+      id,
+      transaction,
+      url
+    } = _ref22;
+    const tx = transaction;
+    // const bitcoinApi = this.state.chainService.getBitcoinApi(chain);
+    // const chainInfo = this.state.chainService.getChainInfoByKey(chain);
+
+    const accountPair = _uiKeyring.default.getPair(address);
+    const account = (0, _utils4.pairToAccount)(accountPair);
+    const payload = {
+      payload: undefined,
+      payloadJson: undefined,
+      address,
+      canSign: true,
+      hashPayload: tx.toHex(),
+      id
+    };
+    const emitter = new _eventemitter.default();
+    const eventData = {
+      id,
+      errors: [],
+      warnings: [],
+      extrinsicHash: id
+    };
+    const isInjected = !!account.isInjected;
+    // const isExternal = !!account.isExternal;
+
+    if (isInjected) {
+      throw new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED);
+    } else {
+      this.state.requestService.addConfirmationBitcoin(id, url || _constants2.EXTENSION_REQUEST_URL, 'bitcoinSendTransactionRequest', payload, {}).then(_ref23 => {
+        let {
+          isApproved,
+          payload
+        } = _ref23;
+        if (isApproved) {
+          if (!payload) {
+            throw new Error('Bad signature');
+          }
+
+          // Emit signed event
+          emitter.emit('signed', eventData);
+          // Add start info
+          emitter.emit('send', eventData);
+          const bitcoinApi = this.state.chainService.getBitcoinApi(chain);
+          const event = bitcoinApi.api.sendRawTransaction(payload);
+          event.on('extrinsicHash', txHash => {
+            eventData.extrinsicHash = txHash;
+            emitter.emit('extrinsicHash', eventData);
+          });
+          event.on('success', 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));
+            emitter.emit('error', eventData);
+          });
+        } else {
+          this.removeTransaction(id);
+          eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.USER_REJECT_REQUEST));
+          emitter.emit('error', eventData);
+        }
+      }).catch(e => {
+        this.removeTransaction(id);
+        eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNABLE_TO_SIGN, e.message));
+        emitter.emit('error', eventData);
+      });
+    }
+    return emitter;
+  }
   handleTransactionTimeout(emitter, eventData) {
     const timeout = setTimeout(() => {
       const transaction = this.getTransaction(eventData.id);

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

@@ -37,8 +37,8 @@ function getBlockExplorerAccountRoute(explorerLink) {
   if (explorerLink.includes('statescan.io')) {
     return '#/accounts';
   }
-  if (explorerLink.includes('explorer.zkverify.io')) {
-    return 'account';
+  if (explorerLink.includes('explorer.gen6.app')) {
+    return '#/accounts';
   }
   if (explorerLink.includes('astral.autonomys')) {
     return 'accounts';
@@ -49,7 +49,7 @@ function getBlockExplorerAccountRoute(explorerLink) {
   return 'address';
 }
 function getBlockExplorerTxRoute(chainInfo) {
-  if ((0, _utils._isPureEvmChain)(chainInfo)) {
+  if ((0, _utils._isPureEvmChain)(chainInfo) || (0, _utils._isPureBitcoinChain)(chainInfo)) {
     return 'tx';
   }
   if ((0, _utils._isPureCardanoChain)(chainInfo)) {
@@ -58,6 +58,9 @@ function getBlockExplorerTxRoute(chainInfo) {
   if (['aventus', 'deeper_network'].includes(chainInfo.slug)) {
     return 'transaction';
   }
+  if (['gen6_public'].includes(chainInfo.slug)) {
+    return '#/extrinsics';
+  }
   const explorerLink = (0, _utils._getBlockExplorerFromChain)(chainInfo);
   if (explorerLink && explorerLink.includes('statescan.io')) {
     return '#/extrinsics';

package/cjs/strategy/api-request-strategy/context/base.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BaseApiRequestContext = void 0;
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+class BaseApiRequestContext {
+  callRate = 2; // limit per interval check
+  limitRate = 2; // max rate per interval check
+  intervalCheck = 1000; // interval check in ms
+  maxRetry = 9; // interval check in ms
+  rollbackRateTime = 30 * 1000; // rollback rate time in ms
+  timeoutRollbackRate = undefined;
+  constructor(options) {
+    this.callRate = (options === null || options === void 0 ? void 0 : options.limitRate) || this.callRate;
+    this.limitRate = (options === null || options === void 0 ? void 0 : options.limitRate) || this.limitRate;
+    this.intervalCheck = (options === null || options === void 0 ? void 0 : options.intervalCheck) || this.intervalCheck;
+    this.maxRetry = (options === null || options === void 0 ? void 0 : options.maxRetry) || this.maxRetry;
+  }
+  reduceLimitRate() {
+    clearTimeout(this.timeoutRollbackRate);
+    this.callRate = Math.ceil(this.limitRate / 2);
+    this.timeoutRollbackRate = setTimeout(() => {
+      this.callRate = this.limitRate;
+    }, this.rollbackRateTime);
+  }
+}
+exports.BaseApiRequestContext = BaseApiRequestContext;

package/cjs/strategy/api-request-strategy/index.js

@@ -0,0 +1,90 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BaseApiRequestStrategy = void 0;
+var _SWError = require("@subwallet/extension-base/background/errors/SWError");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+class BaseApiRequestStrategy {
+  nextId = 0;
+  isRunning = false;
+  requestMap = {};
+  processInterval = undefined;
+  getId() {
+    return this.nextId++;
+  }
+  constructor(context) {
+    this.context = context;
+  }
+  addRequest(run, ordinal) {
+    const newId = this.getId();
+    return new Promise((resolve, reject) => {
+      this.requestMap[newId] = {
+        id: newId,
+        status: 'pending',
+        retry: -1,
+        ordinal,
+        run,
+        resolve,
+        reject
+      };
+      if (!this.isRunning) {
+        this.process();
+      }
+    });
+  }
+  process() {
+    this.stop();
+    this.isRunning = true;
+    const maxRetry = this.context.maxRetry;
+    const interval = setInterval(() => {
+      const remainingRequests = Object.values(this.requestMap);
+      if (remainingRequests.length === 0) {
+        this.isRunning = false;
+        clearInterval(interval);
+        return;
+      }
+
+      // Get first this.limit requests base on id
+      const requests = remainingRequests.filter(request => request.status !== 'running').sort((a, b) => a.id - b.id).sort((a, b) => a.ordinal - b.ordinal).slice(0, this.context.callRate);
+
+      // Start requests
+      requests.forEach(request => {
+        request.status = 'running';
+        request.run().then(rs => {
+          request.resolve(rs);
+        }).catch(e => {
+          const isRateLimited = this.isRateLimited(e);
+
+          // Limit rate
+          if (isRateLimited) {
+            if (request.retry < maxRetry) {
+              request.status = 'pending';
+              request.retry++;
+              this.context.reduceLimitRate();
+            } else {
+              // Reject request
+              request.reject(new _SWError.SWError('MAX_RETRY', String(e)));
+            }
+          } else {
+            request.reject(new _SWError.SWError('UNKNOWN', String(e)));
+          }
+        });
+      });
+    }, this.context.intervalCheck);
+    this.processInterval = interval;
+  }
+  stop() {
+    clearInterval(this.processInterval);
+    this.processInterval = undefined;
+  }
+  setContext(context) {
+    this.stop();
+    this.context = context;
+    this.process();
+  }
+}
+exports.BaseApiRequestStrategy = BaseApiRequestStrategy;

package/cjs/strategy/api-request-strategy/types.js

@@ -0,0 +1 @@
+"use strict";

package/cjs/strategy/api-request-strategy/utils/index.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.postRequest = exports.getRequest = void 0;
+var _crossFetch = _interopRequireDefault(require("cross-fetch"));
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const postRequest = function (url, body, headers) {
+  let jsonBody = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+  return (0, _crossFetch.default)(url, {
+    method: 'POST',
+    headers: headers || {
+      'Content-Type': 'application/json'
+    },
+    body: jsonBody ? JSON.stringify(body) : body
+  });
+};
+exports.postRequest = postRequest;
+const getRequest = (url, params, headers) => {
+  const queryString = params ? Object.keys(params).map(key => `${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`).join('&') : '';
+  const _url = `${url}?${queryString}`;
+  return (0, _crossFetch.default)(_url, {
+    method: 'GET',
+    headers: headers || {
+      'Content-Type': 'application/json'
+    }
+  });
+};
+exports.getRequest = getRequest;

package/cjs/types/account/info/keyring.js

@@ -77,7 +77,7 @@ const ACCOUNT_CHAIN_TYPE_ORDINAL_MAP = {
   [AccountChainType.BITCOIN]: 5
 };
 exports.ACCOUNT_CHAIN_TYPE_ORDINAL_MAP = ACCOUNT_CHAIN_TYPE_ORDINAL_MAP;
-const SUPPORTED_ACCOUNT_CHAIN_TYPES = ['substrate', 'ethereum', 'ton', 'cardano'];
+const SUPPORTED_ACCOUNT_CHAIN_TYPES = [AccountChainType.SUBSTRATE, AccountChainType.ETHEREUM, AccountChainType.TON, AccountChainType.CARDANO, AccountChainType.BITCOIN];
 exports.SUPPORTED_ACCOUNT_CHAIN_TYPES = SUPPORTED_ACCOUNT_CHAIN_TYPES;
 let AccountActions;
 /**

package/cjs/types/bitcoin.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InsufficientFundsError = void 0;
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+// https://github.com/leather-wallet/extension/blob/dev/src/app/query/bitcoin/bitcoin-client.ts
+
+// https://github.com/leather-wallet/extension/blob/dev/src/app/common/transactions/bitcoin/coinselect/local-coin-selection.ts
+
+// https://github.com/leather-wallet/extension/blob/dev/src/app/common/transactions/bitcoin/coinselect/local-coin-selection.ts
+class InsufficientFundsError extends Error {
+  constructor() {
+    super('Insufficient funds');
+  }
+}
+// Source: https://github.com/Blockstream/esplora/blob/master/API.md#transaction-format
+// ---------------
+
+// ---------------
+exports.InsufficientFundsError = InsufficientFundsError;

package/cjs/types/fee/bitcoin.js

@@ -0,0 +1 @@
+"use strict";

package/cjs/types/fee/index.js

@@ -57,4 +57,15 @@ Object.keys(_substrate).forEach(function (key) {
       return _substrate[key];
     }
   });
+});
+var _bitcoin = require("./bitcoin");
+Object.keys(_bitcoin).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _bitcoin[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _bitcoin[key];
+    }
+  });
 });

package/cjs/types/index.js

@@ -167,4 +167,15 @@ Object.keys(_setting).forEach(function (key) {
       return _setting[key];
     }
   });
+});
+var _bitcoin = require("./bitcoin");
+Object.keys(_bitcoin).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _bitcoin[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _bitcoin[key];
+    }
+  });
 });

package/cjs/utils/account/analyze.js

@@ -7,6 +7,7 @@ exports._analyzeAddress = void 0;
 var _domain = require("@subwallet/extension-base/koni/api/dotsama/domain");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
 var _types = require("@subwallet/extension-base/types");
+var _keyring = require("@subwallet/keyring");
 var _utilCrypto = require("@polkadot/util-crypto");
 var _common = require("./common");
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
@@ -57,14 +58,13 @@ const _analyzeAddress = async (data, accountProxies, contacts, chainInfo, substr
   const chain = chainInfo.slug;
   const _data = data.trim().toLowerCase();
   const options = [];
-  const currentChainType = (0, _utils._chainInfoToChainType)(chainInfo);
   let current;
 
   // Filter account proxies
   for (const accountProxy of accountProxies) {
     const _name = accountProxy.name.trim().toLowerCase();
     const nameCondition = isNameValid(_data, _name);
-    const filterAccounts = accountProxy.accounts.filter(account => account.chainType === currentChainType);
+    const filterAccounts = accountProxy.accounts.filter(account => (0, _utils._isChainInfoCompatibleWithAccountInfo)(chainInfo, account.chainType, account.type));
     for (const account of filterAccounts) {
       const addressCondition = isStrValidWithAddress(_data, account, chainInfo);
       const condition = nameCondition !== 'invalid' ? nameCondition : addressCondition;
@@ -92,7 +92,7 @@ const _analyzeAddress = async (data, accountProxies, contacts, chainInfo, substr
       }
     }
   }
-  const filterContacts = contacts.filter(contact => contact.chainType === currentChainType);
+  const filterContacts = contacts.filter(contact => (0, _utils._isChainInfoCompatibleWithAccountInfo)(chainInfo, contact.chainType, (0, _keyring.getKeypairTypeByAddress)(contact.address)));
 
   // Filter address book addresses
   for (const contact of filterContacts) {