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

package/koni/background/handlers/Tabs.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="chrome" />
-import { RequestAddPspToken } from '@subwallet/extension-base/background/KoniTypes';
+import { BitcoinRequestGetAddressesResult, RequestAddPspToken } from '@subwallet/extension-base/background/KoniTypes';
 import { MessageTypes, RequestTypes, ResponseTypes } from '@subwallet/extension-base/background/types';
 import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
 import { AuthUrlInfo, AuthUrls } from '@subwallet/extension-base/services/request-service/types';
@@ -42,7 +42,6 @@ export default class KoniTabs {
     private checkAndHandleProviderStatus;
     private getEvmProvider;
     private performWeb3Method;
-    canUseAccount(address: string, url: string): Promise<boolean>;
     private evmSign;
     evmSendTransaction(id: string, url: string, { params }: RequestArguments): Promise<string>;
     private handleEvmRequest;
@@ -60,5 +59,11 @@ export default class KoniTabs {
     private cardanoSignData;
     private cardanoSignTransaction;
     private cardanoSubmitTransaction;
+    isBitcoinPublicRequest(type: string, request: RequestArguments): boolean;
+    bitcoinGetAddresses(url: string): Promise<BitcoinRequestGetAddressesResult>;
+    private bitcoinSign;
+    private bitcoinSignPspt;
+    private bitcoinSendTransfer;
+    private handleBitcoinRequest;
     handle<TMessageType extends MessageTypes>(id: string, type: TMessageType, request: RequestTypes[TMessageType], url: string, port: chrome.runtime.Port): Promise<ResponseTypes[keyof ResponseTypes]>;
 }

package/koni/background/handlers/Tabs.js

@@ -3,11 +3,12 @@
 
 import * as CardanoWasm from '@emurgo/cardano-serialization-lib-nodejs';
 import { _AssetType } from '@subwallet/chain-list/types';
+import { BitcoinProviderError } from '@subwallet/extension-base/background/errors/BitcoinProviderError';
 import { CardanoProviderError } from '@subwallet/extension-base/background/errors/CardanoProviderError';
 import { EvmProviderError } from '@subwallet/extension-base/background/errors/EvmProviderError';
 import { withErrorLog } from '@subwallet/extension-base/background/handlers/helpers';
 import { createSubscription, unsubscribe } from '@subwallet/extension-base/background/handlers/subscriptions';
-import { CardanoProviderErrorType, EvmProviderErrorType } from '@subwallet/extension-base/background/KoniTypes';
+import { BitcoinProviderErrorType, CardanoProviderErrorType, EvmProviderErrorType } from '@subwallet/extension-base/background/KoniTypes';
 import RequestBytesSign from '@subwallet/extension-base/background/RequestBytesSign';
 import RequestExtrinsicSign from '@subwallet/extension-base/background/RequestExtrinsicSign';
 import { ALL_ACCOUNT_KEY, CRON_GET_API_MAP_STATUS, MAX_COLLATERAL_AMOUNT, PERMISSIONS_TO_REVOKE } from '@subwallet/extension-base/constants';
@@ -18,11 +19,12 @@ import { _generateCustomProviderKey } from '@subwallet/extension-base/services/c
 import { hasSufficientCardanoValue } from '@subwallet/extension-base/services/request-service/helper';
 import { DEFAULT_CHAIN_PATROL_ENABLE } from '@subwallet/extension-base/services/setting-service/constants';
 import { convertCardanoAddressToHex, getEVMChainInfo, reformatAddress, stripUrl } from '@subwallet/extension-base/utils';
-import { CardanoKeypairTypes, EthereumKeypairTypes, SubstrateKeypairTypes, TonKeypairTypes } from '@subwallet/keyring/types';
+import { BitcoinKeypairTypes, CardanoKeypairTypes, EthereumKeypairTypes, SubstrateKeypairTypes, TonKeypairTypes } from '@subwallet/keyring/types';
+import { getBitcoinAddressInfo } from '@subwallet/keyring/utils';
 import { keyring } from '@subwallet/ui-keyring';
 import Web3 from 'web3';
 import { checkIfDenied } from '@polkadot/phishing';
-import { isArray, isNumber } from '@polkadot/util';
+import { hexStripPrefix, isArray, isNumber, u8aToHex } from '@polkadot/util';
 import { isEthereumAddress } from '@polkadot/util-crypto';
 function transformAccountsV2(accounts, anyType = false, authInfo, accountAuthTypes) {
   const accountSelected = authInfo ? authInfo.isAllowed ? Object.keys(authInfo.isAllowedMap).filter(address => authInfo.isAllowedMap[address]) : [] : [];
@@ -38,7 +40,8 @@ function transformAccountsV2(accounts, anyType = false, authInfo, accountAuthTyp
         evm: EthereumKeypairTypes,
         substrate: SubstrateKeypairTypes,
         ton: TonKeypairTypes,
-        cardano: CardanoKeypairTypes
+        cardano: CardanoKeypairTypes,
+        bitcoin: BitcoinKeypairTypes
       };
       const isValidTypes = accountAuthTypes.some(authType => {
         var _validTypes$authType;
@@ -911,10 +914,6 @@ export default class KoniTabs {
       });
     });
   }
-  async canUseAccount(address, url) {
-    const allowedAccounts = await this.getCurrentAccount(url, 'evm');
-    return !!allowedAccounts.find(acc => acc.toLowerCase() === address.toLowerCase());
-  }
   async evmSign(id, url, {
     method,
     params
@@ -1276,6 +1275,113 @@ export default class KoniTabs {
       throw new CardanoProviderError(CardanoProviderErrorType.INTERNAL_ERROR, 'Failed to submit transaction');
     }
   }
+
+  /// Bitcoin
+
+  isBitcoinPublicRequest(type, request) {
+    return type === 'bitcoin(request)' && ['getAddresses'].includes(request === null || request === void 0 ? void 0 : request.method);
+  }
+  async bitcoinGetAddresses(url) {
+    try {
+      const isCompleted = await this.#koniState.authorizeUrlV2(url, {
+        origin: url,
+        accountAuthTypes: ['bitcoin']
+      });
+      const result = [];
+      if (!isCompleted) {
+        return result;
+      }
+      const authInfo = await this.getAuthInfo(url);
+      if (!authInfo || !authInfo.isAllowedMap || !authInfo.isAllowed) {
+        return result;
+      }
+      const addressesAllowed = await this.getCurrentAccount(url, 'bitcoin');
+      const addressResults = [];
+      addressesAllowed.forEach(address => {
+        const pair = keyring.getPair(address);
+        if (pair.meta.noPublicKey) {
+          return;
+        }
+        const addressInfo = getBitcoinAddressInfo(address);
+        const item = {
+          address,
+          type: addressInfo.type,
+          isTestnet: addressInfo.network === 'testnet'
+        };
+        item.derivationPath = pair.meta.derivationPath;
+        item.publicKey = hexStripPrefix(u8aToHex(pair.publicKey));
+        if (pair.publicKey.length !== 32) {
+          item.tweakedPublicKey = hexStripPrefix(u8aToHex(pair.publicKey.slice(1, 33)));
+        }
+        addressResults.push(item);
+      });
+      return addressResults;
+    } catch (e) {
+      throw new BitcoinProviderError(BitcoinProviderErrorType.USER_REJECTED_REQUEST);
+    }
+  }
+  async bitcoinSign(id, url, {
+    method,
+    params
+  }) {
+    const signResult = await this.#koniState.bitcoinSign(id, url, method, params);
+    if (signResult) {
+      return signResult;
+    } else {
+      throw new BitcoinProviderError(BitcoinProviderErrorType.INVALID_PARAMS, 'Failed to sign message');
+    }
+  }
+  async bitcoinSignPspt(id, url, {
+    method,
+    params
+  }) {
+    const psbtParams = params;
+    const signResult = await this.#koniState.bitcoinSignPspt(id, url, psbtParams);
+    if (signResult) {
+      return signResult;
+    } else {
+      throw new BitcoinProviderError(BitcoinProviderErrorType.INVALID_PARAMS, 'Failed to sign message');
+    }
+  }
+  async bitcoinSendTransfer(id, url, {
+    params
+  }) {
+    const transactionParams = params;
+    const transactionHash = await this.#koniState.bitcoinSendTransaction(id, url, transactionParams);
+    if (!transactionHash) {
+      throw new BitcoinProviderError(BitcoinProviderErrorType.USER_REJECTED_REQUEST);
+    }
+    return {
+      txid: transactionHash
+    };
+  }
+  async handleBitcoinRequest(id, url, request, port) {
+    const {
+      method
+    } = request;
+    try {
+      switch (method) {
+        case 'getAddresses':
+          return await this.bitcoinGetAddresses(url);
+        case 'signMessage':
+          return await this.bitcoinSign(id, url, request);
+        case 'signPsbt':
+          return await this.bitcoinSignPspt(id, url, request);
+        case 'sendTransfer':
+          return await this.bitcoinSendTransfer(id, url, request);
+        default:
+          throw new Error(`Method ${method} is not supported by SubWalletBitcoin provider`);
+      }
+    } catch (e) {
+      // @ts-ignore
+      if (e.code) {
+        throw e;
+      } else {
+        console.error(e);
+        throw new BitcoinProviderError(BitcoinProviderErrorType.INTERNAL_ERROR, e === null || e === void 0 ? void 0 : e.toString());
+      }
+    }
+  }
   async handle(id, type, request, url, port) {
     if (type === 'pub(phishing.redirectIfDenied)') {
       return this.redirectIfPhishing(url);
@@ -1286,7 +1392,7 @@ export default class KoniTabs {
 
     // Wait for account ready and chain ready
     await Promise.all([this.#koniState.eventService.waitAccountReady, this.#koniState.eventService.waitChainReady]);
-    if (!['pub(authorize.tabV2)', 'pub(accounts.subscribeV2)'].includes(type) && !this.isEvmPublicRequest(type, request)) {
+    if (!['pub(authorize.tabV2)', 'pub(accounts.subscribeV2)'].includes(type) && !this.isEvmPublicRequest(type, request) && !this.isBitcoinPublicRequest(type, request)) {
       await this.#koniState.ensureUrlAuthorizedV2(url).catch(e => {
         if (type.startsWith('evm')) {
           throw new EvmProviderError(EvmProviderErrorType.INTERNAL_ERROR, e.message);
@@ -1357,6 +1463,10 @@ export default class KoniTabs {
         return await this.cardanoSignTransaction(id, url, request);
       case 'cardano(transaction.submit)':
         return await this.cardanoSubmitTransaction(id, url, request);
+
+      // Bitcoin
+      case 'bitcoin(request)':
+        return await this.handleBitcoinRequest(id, url, request, port);
       default:
         throw new Error(`Unable to handle message of type ${type}`);
     }

package/package.json

@@ -17,7 +17,7 @@
     "./cjs/detectPackage.js"
   ],
   "type": "module",
-  "version": "1.3.42-0",
+  "version": "1.3.44-0",
   "main": "./cjs/index.js",
   "module": "./index.js",
   "types": "./index.d.ts",
@@ -609,6 +609,11 @@
       "require": "./cjs/page/index.js",
       "default": "./page/index.js"
     },
+    "./page/bitcoin": {
+      "types": "./page/bitcoin/index.d.ts",
+      "require": "./cjs/page/bitcoin/index.js",
+      "default": "./page/bitcoin/index.js"
+    },
     "./page/cardano": {
       "types": "./page/cardano/index.d.ts",
       "require": "./cjs/page/cardano/index.js",
@@ -2850,12 +2855,12 @@
     "@sora-substrate/type-definitions": "^1.17.7",
     "@substrate/connect": "^0.8.9",
     "@subwallet/chain-list": "0.2.107",
-    "@subwallet/extension-base": "^1.3.42-0",
-    "@subwallet/extension-chains": "^1.3.42-0",
-    "@subwallet/extension-dapp": "^1.3.42-0",
-    "@subwallet/extension-inject": "^1.3.42-0",
+    "@subwallet/extension-base": "^1.3.44-0",
+    "@subwallet/extension-chains": "^1.3.44-0",
+    "@subwallet/extension-dapp": "^1.3.44-0",
+    "@subwallet/extension-inject": "^1.3.44-0",
     "@subwallet/keyring": "^0.1.12",
-    "@subwallet/subwallet-api-sdk": "^1.3.42-0",
+    "@subwallet/subwallet-api-sdk": "^1.3.44-0",
     "@subwallet/ui-keyring": "^0.1.12",
     "@ton/core": "^0.56.3",
     "@ton/crypto": "^3.2.0",

package/packageInfo.js

@@ -7,5 +7,5 @@ export const packageInfo = {
   name: '@subwallet/extension-base',
   path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto',
   type: 'esm',
-  version: '1.3.42-0'
+  version: '1.3.44-0'
 };

package/page/bitcoin/index.d.ts

@@ -0,0 +1,17 @@
+import { SendRequest } from '@subwallet/extension-base/page/types';
+import { BitcoinProvider } from '@subwallet/extension-inject/types';
+export default class SubWalletBitcoinProvider {
+    readonly name: string;
+    readonly version: string;
+    protected sendMessage: SendRequest;
+    private isSubWallet;
+    constructor(sendMessage: SendRequest);
+    private requestAccounts;
+    private getAccounts;
+    private signMessage;
+    private signPsbt;
+    private sendTransfer;
+    private request;
+    private getProductInfo;
+    get apis(): BitcoinProvider;
+}

package/page/bitcoin/index.js

@@ -0,0 +1,60 @@
+// Copyright 2019-2022 @subwallet/extension authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const WALLET_NAME = 'SubWallet';
+const WALLET_VERSION = process.env.PKG_VERSION;
+export default class SubWalletBitcoinProvider {
+  name = WALLET_NAME;
+  version = WALLET_VERSION;
+  isSubWallet = true;
+  constructor(sendMessage) {
+    this.sendMessage = sendMessage;
+  }
+  async requestAccounts() {
+    return await this.request('getAccounts');
+  }
+  async getAccounts() {
+    return await this.request('getAccounts');
+  }
+  async signMessage(params) {
+    return await this.request('signMessage', params);
+  }
+  async signPsbt(params) {
+    return await this.request('signPsbt', params);
+  }
+  async sendTransfer(params) {
+    return await this.request('sendTransfer', params);
+  }
+  request(method, params) {
+    // Implement this method
+    return new Promise((resolve, reject) => {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      this.sendMessage('bitcoin(request)', {
+        method,
+        params
+      }).then(result => {
+        resolve(result);
+      }).catch(e => {
+        reject(e);
+      });
+    });
+  }
+  getProductInfo() {
+    return {
+      name: this.name,
+      version: this.version
+    };
+  }
+  get apis() {
+    return {
+      isSubWallet: this.isSubWallet,
+      request: (method, params) => this.request(method, params),
+      getAccounts: () => this.getAccounts(),
+      signMessage: params => this.signMessage(params),
+      signPsbt: params => this.signPsbt(params),
+      sendTransfer: params => this.sendTransfer(params),
+      requestAccounts: () => this.requestAccounts(),
+      getProductInfo: () => this.getProductInfo()
+    };
+  }
+}

package/page/index.d.ts

@@ -1,6 +1,6 @@
 import type { MessageTypes, MessageTypesWithNoSubscriptions, MessageTypesWithNullRequest, MessageTypesWithSubscriptions, RequestTypes, ResponseTypes, SubscriptionMessageTypes, TransportResponseMessage } from '../background/types';
 import Injected from '@subwallet/extension-base/page/substrate';
-import { AuthRequestOption, CardanoProvider, EvmProvider } from '@subwallet/extension-inject/types';
+import { AuthRequestOption, BitcoinProvider, CardanoProvider, EvmProvider } from '@subwallet/extension-inject/types';
 export interface Handler {
     resolve: (data?: any) => void;
     reject: (error: Error) => void;
@@ -16,3 +16,4 @@ export declare function handleResponse<TMessageType extends MessageTypes>(data:
 }): void;
 export declare function initEvmProvider(version: string): EvmProvider;
 export declare function initCardanoProvider(): CardanoProvider;
+export declare function initBitcoinProvider(): BitcoinProvider;

package/page/index.js

@@ -3,6 +3,7 @@
 
 import { ProviderError } from '@subwallet/extension-base/background/errors/ProviderError';
 import { ProviderErrorType } from '@subwallet/extension-base/background/KoniTypes';
+import SubWalletBitcoinProvider from '@subwallet/extension-base/page/bitcoin';
 import SubWalletCardanoProvider from '@subwallet/extension-base/page/cardano';
 import SubWalletEvmProvider from '@subwallet/extension-base/page/evm';
 import Injected from '@subwallet/extension-base/page/substrate';
@@ -72,4 +73,7 @@ export function initEvmProvider(version) {
 }
 export function initCardanoProvider() {
   return new SubWalletCardanoProvider(sendMessage);
+}
+export function initBitcoinProvider() {
+  return new SubWalletBitcoinProvider(sendMessage).apis;
 }

package/services/balance-service/transfer/cardano-transfer.d.ts

@@ -1,4 +1,5 @@
 import { _ChainAsset } from '@subwallet/chain-list/types';
+import { ErrorValidation } from '@subwallet/extension-base/background/KoniTypes';
 import { _CardanoApi } from '@subwallet/extension-base/services/chain-service/types';
 export interface CardanoTransactionConfigProps {
     tokenInfo: _ChainAsset;
@@ -20,5 +21,6 @@ export interface CardanoTransactionConfig {
     cardanoTtlOffset: number;
     estimateCardanoFee: string;
     cardanoPayload: string;
+    errors?: ErrorValidation[];
 }
 export declare function createCardanoTransaction(params: CardanoTransactionConfigProps): Promise<[CardanoTransactionConfig | null, string]>;

package/services/buy-service/index.js

@@ -6,7 +6,18 @@ import { fetchStaticData } from '@subwallet/extension-base/utils/fetchStaticData
 import { BehaviorSubject } from 'rxjs';
 import { DEFAULT_SERVICE_INFO } from "./constants/index.js";
 const convertSupportType = support => {
-  return support === 'ETHEREUM' ? AccountChainType.ETHEREUM : AccountChainType.SUBSTRATE;
+  switch (support) {
+    case 'ETHEREUM':
+      return AccountChainType.ETHEREUM;
+    case 'SUBSTRATE':
+      return AccountChainType.SUBSTRATE;
+    case 'CARDANO':
+      return AccountChainType.CARDANO;
+    case 'TON':
+      return AccountChainType.TON;
+    default:
+      return null;
+  }
 };
 export default class BuyService {
   #state;
@@ -29,11 +40,15 @@ export default class BuyService {
     const data = await fetchStaticData('buy-token-configs');
     const result = {};
     for (const datum of data) {
+      const support = convertSupportType(datum.support);
+      if (!support) {
+        continue;
+      }
       const temp = {
         serviceInfo: {
           ...DEFAULT_SERVICE_INFO
         },
-        support: convertSupportType(datum.support),
+        support,
         services: [],
         slug: datum.slug,
         symbol: datum.symbol,

package/services/earning-service/handlers/native-staking/para-chain.js

@@ -426,6 +426,10 @@ export default class ParaNativeStakingPoolHandler extends BaseParaNativeStakingP
     const apiPromise = await this.substrateApi.isReady;
     const binaryAmount = new BN(amount);
     const selectedCollatorInfo = selectedValidators[0];
+    const {
+      address: selectedCollatorAddress,
+      nominatorCount: selectedCollatorNominatorCount
+    } = selectedCollatorInfo;
 
     // eslint-disable-next-line @typescript-eslint/require-await
     const compoundResult = async extrinsic => {
@@ -440,8 +444,17 @@ export default class ParaNativeStakingPoolHandler extends BaseParaNativeStakingP
       }];
     };
     if (!positionInfo) {
-      const extrinsic = apiPromise.api.tx.parachainStaking.delegate(selectedCollatorInfo.address, binaryAmount, new BN(selectedCollatorInfo.nominatorCount), 0);
-      return compoundResult(extrinsic);
+      var _apiPromise$api;
+      const isTxSupportedDelegate = !!((_apiPromise$api = apiPromise.api) !== null && _apiPromise$api !== void 0 && _apiPromise$api.tx.parachainStaking.delegate);
+      if (isTxSupportedDelegate) {
+        const extrinsic = apiPromise.api.tx.parachainStaking.delegate(selectedCollatorAddress, binaryAmount, new BN(selectedCollatorNominatorCount), 0);
+        return compoundResult(extrinsic);
+      } else {
+        var _apiPromise$api$query, _apiPromise$api$query2;
+        const autoCompoundingDelegation = await ((_apiPromise$api$query = apiPromise.api.query) === null || _apiPromise$api$query === void 0 ? void 0 : (_apiPromise$api$query2 = _apiPromise$api$query.parachainStaking) === null || _apiPromise$api$query2 === void 0 ? void 0 : _apiPromise$api$query2.autoCompoundingDelegations(selectedCollatorAddress));
+        const extrinsic = apiPromise.api.tx.parachainStaking.delegateWithAutoCompound(selectedCollatorAddress, binaryAmount, 100, new BN(selectedCollatorNominatorCount), new BN(autoCompoundingDelegation.length), 0);
+        return compoundResult(extrinsic);
+      }
     }
     const {
       bondedValidators,
@@ -449,10 +462,19 @@ export default class ParaNativeStakingPoolHandler extends BaseParaNativeStakingP
     } = getBondedValidators(positionInfo.nominations);
     const parsedSelectedCollatorAddress = reformatAddress(selectedCollatorInfo.address, 0);
     if (!bondedValidators.includes(parsedSelectedCollatorAddress)) {
-      const extrinsic = apiPromise.api.tx.parachainStaking.delegate(selectedCollatorInfo.address, binaryAmount, new BN(selectedCollatorInfo.nominatorCount), nominationCount);
-      return compoundResult(extrinsic);
+      var _apiPromise$api2;
+      const isTxSupportedDelegate = !!((_apiPromise$api2 = apiPromise.api) !== null && _apiPromise$api2 !== void 0 && _apiPromise$api2.tx.parachainStaking.delegate);
+      if (isTxSupportedDelegate) {
+        const extrinsic = apiPromise.api.tx.parachainStaking.delegate(selectedCollatorAddress, binaryAmount, new BN(selectedCollatorNominatorCount), nominationCount);
+        return compoundResult(extrinsic);
+      } else {
+        var _apiPromise$api$query3, _apiPromise$api$query4;
+        const autoCompoundingDelegation = await ((_apiPromise$api$query3 = apiPromise.api.query) === null || _apiPromise$api$query3 === void 0 ? void 0 : (_apiPromise$api$query4 = _apiPromise$api$query3.parachainStaking) === null || _apiPromise$api$query4 === void 0 ? void 0 : _apiPromise$api$query4.autoCompoundingDelegations(selectedCollatorAddress));
+        const extrinsic = apiPromise.api.tx.parachainStaking.delegateWithAutoCompound(selectedCollatorAddress, binaryAmount, 100, new BN(selectedCollatorNominatorCount), new BN(autoCompoundingDelegation.length), nominationCount);
+        return compoundResult(extrinsic);
+      }
     } else {
-      const extrinsic = apiPromise.api.tx.parachainStaking.delegatorBondMore(selectedCollatorInfo.address, binaryAmount);
+      const extrinsic = apiPromise.api.tx.parachainStaking.delegatorBondMore(selectedCollatorAddress, binaryAmount);
       return compoundResult(extrinsic);
     }
   }

package/services/request-service/handler/AuthRequestHandler.js

@@ -2,12 +2,13 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { ALL_ACCOUNT_AUTH_TYPES } from '@subwallet/extension-base/constants';
-import { _isChainCardanoCompatible, _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
+import { _isChainBitcoinCompatible, _isChainCardanoCompatible, _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
 import { DAPP_CONNECT_BOTH_TYPE_ACCOUNT_URL, PREDEFINED_CHAIN_DAPP_CHAIN_MAP, WEB_APP_URL } from '@subwallet/extension-base/services/request-service/constants';
 import AuthorizeStore from '@subwallet/extension-base/stores/Authorize';
 import { createPromiseHandler, getDomainFromUrl, stripUrl } from '@subwallet/extension-base/utils';
 import { getId } from '@subwallet/extension-base/utils/getId';
 import { isCardanoAddress, isSubstrateAddress, isTonAddress } from '@subwallet/keyring';
+import { isBitcoinAddress } from '@subwallet/keyring/utils/address/validate';
 import { BehaviorSubject } from 'rxjs';
 import { isEthereumAddress } from '@polkadot/util-crypto';
 const AUTH_URLS_KEY = 'authUrls';
@@ -166,6 +167,18 @@ export default class AuthRequestHandler {
         }
       }
     }
+    if (options.accessType === 'bitcoin') {
+      const bitcoinChains = Object.values(chainInfoMaps).filter(_isChainBitcoinCompatible);
+      chainInfo = (defaultChain ? chainInfoMaps[defaultChain] : chainInfoMaps.bitcoin) || bitcoinChains[0]; // auto active cardano mainnet chain, because dont support switch network yet
+
+      if (options.autoActive) {
+        var _chainInfo5;
+        if (!needEnableChains.includes((_chainInfo5 = chainInfo) === null || _chainInfo5 === void 0 ? void 0 : _chainInfo5.slug)) {
+          var _chainInfo6;
+          needEnableChains.push((_chainInfo6 = chainInfo) === null || _chainInfo6 === void 0 ? void 0 : _chainInfo6.slug);
+        }
+      }
+    }
     needEnableChains = needEnableChains.filter(slug => {
       var _chainStateMap$slug;
       return !((_chainStateMap$slug = chainStateMap[slug]) !== null && _chainStateMap$slug !== void 0 && _chainStateMap$slug.active);
@@ -217,6 +230,9 @@ export default class AuthRequestHandler {
           if (isCardanoAddress(a) && !accountAuthTypes.includes('cardano')) {
             return true;
           }
+          if (isBitcoinAddress(a) && !accountAuthTypes.includes('bitcoin')) {
+            return true;
+          }
           return false;
         });
         backupAllowed.forEach(acc => {
@@ -365,6 +381,8 @@ export default class AuthRequestHandler {
           list.push(...allowedListByRequestType.filter(a => isTonAddress(a)));
         } else if (accountAuthType === 'cardano') {
           list.push(...allowedListByRequestType.filter(a => isCardanoAddress(a)));
+        } else if (accountAuthType === 'bitcoin') {
+          list.push(...allowedListByRequestType.filter(a => isBitcoinAddress(a)));
         }
         return list;
       }, []);

package/services/request-service/handler/BitcoinRequestHandler.d.ts

@@ -1,6 +1,5 @@
-import { ConfirmationDefinitionsBitcoin, ConfirmationsQueueBitcoin, ConfirmationsQueueItemOptions, ConfirmationTypeBitcoin, RequestConfirmationCompleteBitcoin, SignMessageBitcoinResult } from '@subwallet/extension-base/background/KoniTypes';
+import { BitcoinSignMessageResult, ConfirmationDefinitionsBitcoin, ConfirmationsQueueBitcoin, ConfirmationsQueueItemOptions, ConfirmationTypeBitcoin, RequestConfirmationCompleteBitcoin } from '@subwallet/extension-base/background/KoniTypes';
 import { ChainService } from '@subwallet/extension-base/services/chain-service';
-import FeeService from '@subwallet/extension-base/services/fee-service/service';
 import RequestService from '@subwallet/extension-base/services/request-service';
 import TransactionService from '@subwallet/extension-base/services/transaction-service';
 import { BehaviorSubject } from 'rxjs';
@@ -8,12 +7,12 @@ export default class BitcoinRequestHandler {
     #private;
     private readonly confirmationsQueueSubjectBitcoin;
     private readonly confirmationsPromiseMap;
-    constructor(requestService: RequestService, chainService: ChainService, feeService: FeeService, transactionService: TransactionService);
+    constructor(requestService: RequestService, chainService: ChainService, transactionService: TransactionService);
     get numBitcoinRequests(): number;
     getConfirmationsQueueSubjectBitcoin(): BehaviorSubject<ConfirmationsQueueBitcoin>;
     addConfirmationBitcoin<CT extends ConfirmationTypeBitcoin>(id: string, url: string, type: CT, payload: ConfirmationDefinitionsBitcoin[CT][0]['payload'], options?: ConfirmationsQueueItemOptions, validator?: (input: ConfirmationDefinitionsBitcoin[CT][1]) => Error | undefined): Promise<ConfirmationDefinitionsBitcoin[CT][1]>;
     updateConfirmationBitcoin<CT extends ConfirmationTypeBitcoin>(id: string, type: CT, payload: ConfirmationDefinitionsBitcoin[CT][0]['payload'], options?: ConfirmationsQueueItemOptions, validator?: (input: ConfirmationDefinitionsBitcoin[CT][1]) => Error | undefined): void;
-    signMessageBitcoin(confirmation: ConfirmationDefinitionsBitcoin['bitcoinSignatureRequest'][0]): SignMessageBitcoinResult;
+    signMessageBitcoin(confirmation: ConfirmationDefinitionsBitcoin['bitcoinSignatureRequest'][0]): BitcoinSignMessageResult;
     private signTransactionBitcoin;
     private signTransactionBitcoinWithPayload;
     private signPsbt;