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

package/types/bitcoin.d.ts

@@ -0,0 +1,93 @@
+export interface UtxoResponseItem {
+    txid: string;
+    vout: number;
+    status: {
+        confirmed: boolean;
+        block_height?: number;
+        block_hash?: string;
+        block_time?: number;
+    };
+    value: number;
+}
+export interface DetermineUtxosForSpendArgs {
+    sender: string;
+    amount: number;
+    feeRate: number;
+    recipient: string;
+    utxos: UtxoResponseItem[];
+}
+interface DetermineUtxosOutput {
+    value: number;
+    address?: string;
+}
+export interface DetermineUtxosForSpendResult {
+    filteredUtxos: UtxoResponseItem[];
+    inputs: UtxoResponseItem[];
+    outputs: DetermineUtxosOutput[];
+    size: number;
+    fee: number;
+}
+export declare class InsufficientFundsError extends Error {
+    constructor();
+}
+interface BitcoinTransactionIssuance {
+    asset_id: string;
+    is_reissuance: boolean;
+    asset_blinding_nonce: number;
+    asset_entropy: number;
+    contract_hash: string;
+    assetamount?: number;
+    assetamountcommitment?: number;
+    tokenamount?: number;
+    tokenamountcommitment?: number;
+}
+interface BitcoinTransactionPegOut {
+    genesis_hash: string;
+    scriptpubkey: string;
+    scriptpubkey_asm: string;
+    scriptpubkey_address: string;
+}
+export interface BitcoinTransactionStatus {
+    confirmed: boolean;
+    block_height?: number | null;
+    block_hash?: string | null;
+    block_time?: number | null;
+}
+export interface BitcoinTransactionVectorOutput {
+    scriptpubkey: string;
+    scriptpubkey_asm: string;
+    scriptpubkey_type: string;
+    scriptpubkey_address: string;
+    value: number;
+    valuecommitment?: number;
+    asset?: string;
+    assetcommitment?: number;
+    pegout?: BitcoinTransactionPegOut | null;
+}
+export interface BitcoinTransactionVectorInput {
+    inner_redeemscript_asm?: string;
+    inner_witnessscript_asm?: string;
+    is_coinbase: boolean;
+    is_pegin?: boolean;
+    issuance?: BitcoinTransactionIssuance | null;
+    prevout: BitcoinTransactionVectorOutput;
+    scriptsig: string;
+    scriptsig_asm: string;
+    sequence: number;
+    txid: string;
+    vout: number;
+    witness: string[];
+}
+export interface BitcoinTx {
+    fee: number;
+    locktime: number;
+    size: number;
+    status: BitcoinTransactionStatus;
+    tx_type?: string;
+    txid: string;
+    version: number;
+    vin: BitcoinTransactionVectorInput[];
+    vout: BitcoinTransactionVectorOutput[];
+    weight: number;
+}
+export {};

package/types/bitcoin.js

@@ -0,0 +1,17 @@
+// 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
+export class InsufficientFundsError extends Error {
+  constructor() {
+    super('Insufficient funds');
+  }
+}
+// Source: https://github.com/Blockstream/esplora/blob/master/API.md#transaction-format
+// ---------------
+
+// ---------------

package/types/fee/base.d.ts

@@ -1,4 +1,4 @@
-export declare type FeeChainType = 'evm' | 'substrate' | 'ton' | 'cardano';
+export declare type FeeChainType = 'evm' | 'substrate' | 'ton' | 'cardano' | 'bitcoin';
 export interface BaseFeeInfo {
     busyNetwork: boolean;
     type: FeeChainType;
@@ -6,3 +6,6 @@ export interface BaseFeeInfo {
 export interface BaseFeeDetail {
     estimatedFee: string;
 }
+export interface BaseFeeTime {
+    time: number;
+}

package/types/fee/bitcoin.d.ts

@@ -0,0 +1,18 @@
+import { BaseFeeDetail, BaseFeeInfo, BaseFeeTime } from './base';
+import { FeeDefaultOption } from './option';
+export interface BitcoinFeeRate {
+    feeRate: number;
+}
+export declare type BitcoinFeeRateDetail = BitcoinFeeRate & BaseFeeTime;
+export interface BitcoinFeeInfo extends BaseFeeInfo {
+    type: 'bitcoin';
+    options: {
+        slow: BitcoinFeeRateDetail;
+        average: BitcoinFeeRateDetail;
+        fast: BitcoinFeeRateDetail;
+        default: FeeDefaultOption;
+    };
+}
+export interface BitcoinFeeDetail extends BitcoinFeeInfo, BaseFeeDetail {
+    vSize: number;
+}

package/types/fee/bitcoin.js

@@ -0,0 +1 @@
+export {};

package/types/fee/index.d.ts

@@ -3,3 +3,4 @@ export * from './evm';
 export * from './option';
 export * from './subscription';
 export * from './substrate';
+export * from './bitcoin';

package/types/fee/index.js

@@ -5,4 +5,5 @@ export * from "./base.js";
 export * from "./evm.js";
 export * from "./option.js";
 export * from "./subscription.js";
-export * from "./substrate.js";
+export * from "./substrate.js";
+export * from "./bitcoin.js";

package/types/fee/subscription.d.ts

@@ -1,11 +1,12 @@
+import { BitcoinFeeDetail, BitcoinFeeInfo, BitcoinFeeRate } from '@subwallet/extension-base/types';
 import { BehaviorSubject } from 'rxjs';
 import { CardanoFeeDetail, CardanoFeeInfo, CardanoTipInfo } from './cardano';
 import { EvmEIP1559FeeOption, EvmFeeDetail, EvmFeeInfo } from './evm';
 import { SubstrateFeeDetail, SubstrateFeeInfo, SubstrateTipInfo } from './substrate';
 import { TonFeeDetail, TonFeeInfo, TonTipInfo } from './ton';
-export declare type FeeInfo = EvmFeeInfo | SubstrateFeeInfo | TonFeeInfo | CardanoFeeInfo;
-export declare type FeeDetail = EvmFeeDetail | SubstrateFeeDetail | TonFeeDetail | CardanoFeeDetail;
-export declare type FeeCustom = EvmEIP1559FeeOption | SubstrateTipInfo | TonTipInfo | CardanoTipInfo;
+export declare type FeeInfo = EvmFeeInfo | SubstrateFeeInfo | TonFeeInfo | CardanoFeeInfo | BitcoinFeeInfo;
+export declare type FeeDetail = EvmFeeDetail | SubstrateFeeDetail | TonFeeDetail | CardanoFeeDetail | BitcoinFeeDetail;
+export declare type FeeCustom = EvmEIP1559FeeOption | SubstrateTipInfo | TonTipInfo | CardanoTipInfo | BitcoinFeeRate;
 export interface FeeSubscription {
     observer: BehaviorSubject<FeeInfo | undefined>;
     subscription: Record<string, VoidFunction>;

package/types/index.d.ts

@@ -23,3 +23,4 @@ export * from './swap';
 export * from './transaction';
 export * from './yield';
 export * from './setting';
+export * from './bitcoin';

package/types/index.js

@@ -16,4 +16,5 @@ export * from "./swap/index.js";
 export * from "./transaction/index.js";
 export * from "./yield/index.js";
 export * from "./setting.js";
+export * from "./bitcoin.js";
 export {};

package/utils/account/analyze.js

@@ -2,8 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { resolveAzeroAddressToDomain, resolveAzeroDomainToAddress } from '@subwallet/extension-base/koni/api/dotsama/domain';
-import { _chainInfoToChainType, _getChainSubstrateAddressPrefix } from '@subwallet/extension-base/services/chain-service/utils';
+import { _getChainSubstrateAddressPrefix, _isChainInfoCompatibleWithAccountInfo } from '@subwallet/extension-base/services/chain-service/utils';
 import { AccountChainType, AnalyzedGroup } from '@subwallet/extension-base/types';
+import { getKeypairTypeByAddress } from '@subwallet/keyring';
 import { isAddress } from '@polkadot/util-crypto';
 import { _reformatAddressWithChain, reformatAddress } from "./common.js";
 // TODO: Re-confirm to compare without
@@ -51,14 +52,13 @@ export const _analyzeAddress = async (data, accountProxies, contacts, chainInfo,
   const chain = chainInfo.slug;
   const _data = data.trim().toLowerCase();
   const options = [];
-  const currentChainType = _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 => _isChainInfoCompatibleWithAccountInfo(chainInfo, account.chainType, account.type));
     for (const account of filterAccounts) {
       const addressCondition = isStrValidWithAddress(_data, account, chainInfo);
       const condition = nameCondition !== 'invalid' ? nameCondition : addressCondition;
@@ -86,7 +86,7 @@ export const _analyzeAddress = async (data, accountProxies, contacts, chainInfo,
       }
     }
   }
-  const filterContacts = contacts.filter(contact => contact.chainType === currentChainType);
+  const filterContacts = contacts.filter(contact => _isChainInfoCompatibleWithAccountInfo(chainInfo, contact.chainType, getKeypairTypeByAddress(contact.address)));
 
   // Filter address book addresses
   for (const contact of filterContacts) {

package/utils/account/common.d.ts

@@ -6,15 +6,14 @@ export declare function isAccountAll(address?: string): boolean;
 export declare function reformatAddress(address: string, networkPrefix?: number, isEthereum?: boolean): string;
 export declare const _reformatAddressWithChain: (address: string, chainInfo: _ChainInfo) => string;
 export declare const getAccountChainTypeForAddress: (address: string) => AccountChainType;
-interface AddressesByChainType {
-    [ChainType.SUBSTRATE]: string[];
-    [ChainType.EVM]: string[];
-    [ChainType.BITCOIN]: string[];
-    [ChainType.TON]: string[];
-    [ChainType.CARDANO]: string[];
+declare type AddressesByChainType = {
+    [key in ChainType]: string[];
+};
+interface ExtendAddressesByChainType extends AddressesByChainType {
+    _bitcoin: string[];
 }
-export declare function getAddressesByChainType(addresses: string[], chainTypes: ChainType[]): string[];
-export declare function getAddressesByChainTypeMap(addresses: string[]): AddressesByChainType;
+export declare function getAddressesByChainType(addresses: string[], chainTypes: ChainType[], chainInfo?: _ChainInfo): string[];
+export declare function getAddressesByChainTypeMap(addresses: string[], chainInfo?: _ChainInfo): ExtendAddressesByChainType;
 export declare function quickFormatAddressToCompare(address?: string): string | undefined;
 /** @deprecated */
 export declare const modifyAccountName: (type: KeypairType, name: string, modify: boolean) => string;

package/utils/account/common.js

@@ -1,12 +1,12 @@
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { ChainType } from '@subwallet/extension-base/background/KoniTypes';
 import { ALL_ACCOUNT_KEY } from '@subwallet/extension-base/constants';
 import { _chainInfoToChainType, _getChainSubstrateAddressPrefix } from '@subwallet/extension-base/services/chain-service/utils';
 import { AccountChainType } from '@subwallet/extension-base/types';
 import { getAccountChainTypeFromKeypairType } from '@subwallet/extension-base/utils';
 import { decodeAddress, encodeAddress, getKeypairTypeByAddress, isAddress, isBitcoinAddress, isCardanoAddress, isTonAddress } from '@subwallet/keyring';
+import { getBitcoinAddressInfo } from '@subwallet/keyring/utils/address/validate';
 import { ethereumEncode, isEthereumAddress } from '@polkadot/util-crypto';
 export function isAccountAll(address) {
   return address === ALL_ACCOUNT_KEY;
@@ -52,20 +52,22 @@ export const getAccountChainTypeForAddress = address => {
   const type = getKeypairTypeByAddress(address);
   return getAccountChainTypeFromKeypairType(type);
 };
-export function getAddressesByChainType(addresses, chainTypes) {
-  const addressByChainTypeMap = getAddressesByChainTypeMap(addresses);
+// TODO: Recheck the usage of this function for Bitcoin; it is currently applied to history.
+export function getAddressesByChainType(addresses, chainTypes, chainInfo) {
+  const addressByChainTypeMap = getAddressesByChainTypeMap(addresses, chainInfo);
   return chainTypes.map(chainType => {
     return addressByChainTypeMap[chainType];
   }).flat(); // todo: recheck
 }
 
-export function getAddressesByChainTypeMap(addresses) {
+export function getAddressesByChainTypeMap(addresses, chainInfo) {
   const addressByChainType = {
     substrate: [],
     evm: [],
     bitcoin: [],
     ton: [],
-    cardano: []
+    cardano: [],
+    _bitcoin: []
   };
   addresses.forEach(address => {
     if (isEthereumAddress(address)) {
@@ -73,7 +75,15 @@ export function getAddressesByChainTypeMap(addresses) {
     } else if (isTonAddress(address)) {
       addressByChainType.ton.push(address);
     } else if (isBitcoinAddress(address)) {
-      addressByChainType.bitcoin.push(address);
+      const addressInfo = getBitcoinAddressInfo(address);
+      if (chainInfo !== null && chainInfo !== void 0 && chainInfo.bitcoinInfo) {
+        const isNetworkMatch = addressInfo.network === chainInfo.bitcoinInfo.bitcoinNetwork;
+        if (isNetworkMatch) {
+          addressByChainType.bitcoin.push(address);
+        } else {
+          addressByChainType._bitcoin.push(address);
+        }
+      }
     } else if (isCardanoAddress(address)) {
       addressByChainType.cardano.push(address);
     } else {

package/utils/account/derive/info/solo.js

@@ -2,32 +2,55 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { getDerivePath } from '@subwallet/keyring';
-import { EthereumKeypairTypes, SubstrateKeypairTypes } from '@subwallet/keyring/types';
+import { BitcoinKeypairTypes, EthereumKeypairTypes, SubstrateKeypairTypes } from '@subwallet/keyring/types';
 import { keyring } from '@subwallet/ui-keyring';
 import { t } from 'i18next';
 import { assert } from '@polkadot/util';
-import { validateCardanoDerivationPath, validateEvmDerivationPath, validateOtherSubstrateDerivationPath, validateSr25519DerivationPath, validateTonDerivationPath, validateUnifiedDerivationPath } from "../validate.js";
+import { validateBitcoinDerivationPath, validateCardanoDerivationPath, validateEvmDerivationPath, validateOtherSubstrateDerivationPath, validateSr25519DerivationPath, validateTonDerivationPath, validateUnifiedDerivationPath } from "../validate.js";
+const bitPathLv1 = "m/{proposal}'/{slip44}'/{firstIndex}'/0/0";
+const bitPathLv2 = "m/{proposal}'/{slip44}'/{firstIndex}'/0/0/{secondIndex}";
+const getBitLv1DerivePathFunction = (slip44, proposal) => {
+  return bitPathLv1.replace('{proposal}', proposal.toString()).replace('{slip44}', slip44.toString());
+};
+const getBitLv2DerivePathFunction = (slip44, proposal) => {
+  return bitPathLv2.replace('{proposal}', proposal.toString()).replace('{slip44}', slip44.toString());
+};
+const level1DerivationPathMap = {
+  ethereum: "m/44'/60'/0'/0/{firstIndex}",
+  ton: "m/44'/607'/{firstIndex}'",
+  cardano: "m/1852'/1815'/{firstIndex}'",
+  'bitcoin-44': getBitLv1DerivePathFunction(0, 44),
+  'bitcoin-84': getBitLv1DerivePathFunction(0, 84),
+  'bitcoin-86': getBitLv1DerivePathFunction(0, 86),
+  'bittest-44': getBitLv1DerivePathFunction(1, 44),
+  'bittest-84': getBitLv1DerivePathFunction(1, 84),
+  'bittest-86': getBitLv1DerivePathFunction(1, 86)
+};
+const level2DerivationPathMap = {
+  ethereum: "m/44'/60'/0'/0/{firstIndex}/{secondIndex}",
+  ton: "m/44'/607'/{firstIndex}'/{secondIndex}'",
+  cardano: "m/1852'/1815'/{firstIndex}'/{secondIndex}'",
+  'bitcoin-44': getBitLv2DerivePathFunction(0, 44),
+  'bitcoin-84': getBitLv2DerivePathFunction(0, 84),
+  'bitcoin-86': getBitLv2DerivePathFunction(0, 86),
+  'bittest-44': getBitLv2DerivePathFunction(1, 44),
+  'bittest-84': getBitLv2DerivePathFunction(1, 84),
+  'bittest-86': getBitLv2DerivePathFunction(1, 86)
+};
 export const parseUnifiedSuriToDerivationPath = (suri, type) => {
   const reg = /^\/\/(\d+)(\/\/\d+)?$/;
   if (suri.match(reg)) {
     const [, firstIndex, secondData] = suri.match(reg);
-    const first = parseInt(firstIndex, 10);
     if (secondData) {
       const [, secondIndex] = secondData.match(/\/\/(\d+)/);
-      if (type === 'ethereum') {
-        return `m/44'/60'/0'/0/${first}/${secondIndex}`;
-      } else if (type === 'ton') {
-        return `m/44'/607'/${first}'/${secondIndex}'`;
-      } else if (type === 'cardano') {
-        return `m/1852'/1815'/${first}'/${secondIndex}'`;
+      const path = level2DerivationPathMap[type];
+      if (path) {
+        return path.replace('{firstIndex}', firstIndex).replace('{secondIndex}', secondIndex);
       }
     } else {
-      if (type === 'ethereum') {
-        return `m/44'/60'/0'/0/${first}`;
-      } else if (type === 'ton') {
-        return `m/44'/607'/${first}'`;
-      } else if (type === 'cardano') {
-        return `m/1852'/1815'/${first}'`;
+      const path = level1DerivationPathMap[type];
+      if (path) {
+        return path.replace('{firstIndex}', firstIndex);
       }
     }
     if (SubstrateKeypairTypes.includes(type)) {
@@ -36,6 +59,33 @@ export const parseUnifiedSuriToDerivationPath = (suri, type) => {
   }
   return '';
 };
+const validateNonSubstrateDerivationPath = (derivePath, type) => {
+  let validateTypeRs;
+  switch (type) {
+    case 'ethereum':
+      validateTypeRs = validateEvmDerivationPath(derivePath);
+      break;
+    case 'ton':
+      validateTypeRs = validateTonDerivationPath(derivePath);
+      break;
+    case 'cardano':
+      validateTypeRs = validateCardanoDerivationPath(derivePath);
+      break;
+    case 'bitcoin-44':
+    case 'bitcoin-84':
+    case 'bitcoin-86':
+    case 'bittest-44':
+    case 'bittest-84':
+    case 'bittest-86':
+      validateTypeRs = validateBitcoinDerivationPath(derivePath);
+      break;
+  }
+  if (validateTypeRs && validateTypeRs.type === type) {
+    return validateTypeRs;
+  } else {
+    return undefined;
+  }
+};
 export const getSoloDerivationInfo = (type, metadata = {}) => {
   const {
     derivationPath: derivePath,
@@ -44,8 +94,7 @@ export const getSoloDerivationInfo = (type, metadata = {}) => {
   } = metadata;
   if (suri) {
     if (derivePath) {
-      const validateTypeFunc = type === 'ethereum' ? validateEvmDerivationPath : type === 'ton' ? validateTonDerivationPath : type === 'cardano' ? validateCardanoDerivationPath : () => undefined;
-      const validateTypeRs = validateTypeFunc(derivePath);
+      const validateTypeRs = validateNonSubstrateDerivationPath(derivePath, type);
       if (validateTypeRs) {
         return {
           suri: validateTypeRs.suri,
@@ -101,8 +150,7 @@ export const getSoloDerivationInfo = (type, metadata = {}) => {
     }
   } else {
     if (derivePath) {
-      const validateTypeFunc = type === 'ethereum' ? validateEvmDerivationPath : type === 'ton' ? validateTonDerivationPath : type === 'cardano' ? validateCardanoDerivationPath : () => undefined;
-      const validateTypeRs = validateTypeFunc(derivePath);
+      const validateTypeRs = validateNonSubstrateDerivationPath(derivePath, type);
       if (validateTypeRs) {
         return {
           suri: validateTypeRs.suri,
@@ -215,6 +263,7 @@ export const derivePair = (parentPair, name, suri, derivationPath) => {
   const isEvm = EthereumKeypairTypes.includes(parentPair.type);
   const isTon = parentPair.type === 'ton';
   const isCardano = parentPair.type === 'cardano';
+  const isBitcoin = BitcoinKeypairTypes.includes(parentPair.type);
   const meta = {
     name,
     parentAddress: parentPair.address,
@@ -225,8 +274,8 @@ export const derivePair = (parentPair, name, suri, derivationPath) => {
   if (isTon && (_parentPair$ton = parentPair.ton) !== null && _parentPair$ton !== void 0 && _parentPair$ton.contractVersion) {
     meta.tonContractVersion = parentPair.ton.contractVersion;
   }
-  if (derivationPath && (isEvm || isTon || isCardano)) {
-    return isEvm ? parentPair.evm.deriveCustom(derivationPath, meta) : isTon ? parentPair.ton.deriveCustom(derivationPath, meta) : parentPair.cardano.deriveCustom(derivationPath, meta);
+  if (derivationPath && (isEvm || isTon || isCardano || isBitcoin)) {
+    return isEvm ? parentPair.evm.deriveCustom(derivationPath, meta) : isTon ? parentPair.ton.deriveCustom(derivationPath, meta) : isCardano ? parentPair.cardano.deriveCustom(derivationPath, meta) : parentPair.bitcoin.deriveCustom(derivationPath, meta);
   } else {
     return parentPair.substrate.derive(suri, meta);
   }

package/utils/account/derive/info/unified.js

@@ -88,6 +88,8 @@ export const findUnifiedNextDerive = (proxyId, accounts) => {
       index++;
     } else if (currentDepth === 0 && deriveIndex === 0 && index > deriveIndex) {
       // Special case for the first account on the root
+    } else if (deriveIndex === index - 1) {
+      // Special case, increased index before that, ex: 1/0, 1/1, 1/2
     } else {
       break;
     }

package/utils/account/derive/validate.d.ts

@@ -3,6 +3,7 @@ import { KeypairType, SubstrateKeypairType } from '@subwallet/keyring/types';
 export declare const validateUnifiedDerivationPath: (raw: string) => DerivePathInfo | undefined;
 export declare const validateEvmDerivationPath: (raw: string) => IDerivePathInfo_ | undefined;
 export declare const validateTonDerivationPath: (raw: string) => IDerivePathInfo_ | undefined;
+export declare const validateBitcoinDerivationPath: (raw: string) => IDerivePathInfo_ | undefined;
 export declare const validateCardanoDerivationPath: (raw: string) => IDerivePathInfo_ | undefined;
 export declare const validateSr25519DerivationPath: (raw: string) => IDerivePathInfo_ | undefined;
 export declare const validateOtherSubstrateDerivationPath: (raw: string, type: Exclude<SubstrateKeypairType, 'sr25519'>) => IDerivePathInfo_ | undefined;

package/utils/account/derive/validate.js

@@ -1,6 +1,7 @@
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import { BitcoinKeypairTypes } from '@subwallet/keyring/types';
 export const validateUnifiedDerivationPath = raw => {
   const reg = /^\/\/(\d+)(\/\/\d+)?$/;
   if (raw.match(reg)) {
@@ -96,6 +97,66 @@ export const validateTonDerivationPath = raw => {
     return undefined;
   }
 };
+export const validateBitcoinDerivationPath = raw => {
+  const reg = /^m\/(44|84|86)'\/([01])'\/(\d+)'\/0\/0(\/\d+)?$/;
+  if (raw.match(reg)) {
+    const [, proposal, slip44, firstIndex, secondData] = raw.match(reg);
+    const first = parseInt(firstIndex, 10);
+    const autoIndexes = [first];
+    let depth;
+    let suri = `//${first}`;
+    let type;
+    if (slip44 === '0') {
+      switch (proposal) {
+        case '44':
+          type = 'bitcoin-44';
+          break;
+        case '84':
+          type = 'bitcoin-84';
+          break;
+        case '86':
+          type = 'bitcoin-86';
+          break;
+      }
+    } else if (slip44 === '1') {
+      switch (proposal) {
+        case '44':
+          type = 'bittest-44';
+          break;
+        case '84':
+          type = 'bittest-84';
+          break;
+        case '86':
+          type = 'bittest-86';
+          break;
+      }
+    }
+    if (!type) {
+      return undefined;
+    }
+    if (first === 0) {
+      depth = 0;
+    } else {
+      depth = 1;
+    }
+    if (secondData) {
+      const [, secondIndex] = secondData.match(/\/(\d+)/);
+      const second = parseInt(secondIndex, 10);
+      autoIndexes.push(second);
+      depth = 2;
+      suri += `//${second}`;
+    }
+    return {
+      depth,
+      type,
+      suri,
+      derivationPath: raw,
+      autoIndexes
+    };
+  } else {
+    return undefined;
+  }
+};
 export const validateCardanoDerivationPath = raw => {
   const reg = /^m\/1852'\/1815'\/(\d+)'(\/\d+')?$/;
   if (raw.match(reg)) {
@@ -189,10 +250,16 @@ export const validateDerivationPath = (raw, type) => {
       return validateOtherSubstrateDerivationPath(raw, type);
     } else if (type === 'cardano') {
       return validateCardanoDerivationPath(raw);
+    } else if (BitcoinKeypairTypes.includes(type)) {
+      const rs = validateBitcoinDerivationPath(raw);
+      if (rs && rs.type === type) {
+        return rs;
+      }
+      return undefined;
     } else {
       return undefined;
     }
   } else {
-    return validateUnifiedDerivationPath(raw) || validateEvmDerivationPath(raw) || validateTonDerivationPath(raw) || validateSr25519DerivationPath(raw) || validateCardanoDerivationPath(raw);
+    return validateUnifiedDerivationPath(raw) || validateEvmDerivationPath(raw) || validateTonDerivationPath(raw) || validateSr25519DerivationPath(raw) || validateCardanoDerivationPath(raw) || validateBitcoinDerivationPath(raw);
   }
 };

package/utils/account/transform.d.ts

@@ -5,7 +5,7 @@ import { KeypairType, KeyringPair, KeyringPair$Meta } from '@subwallet/keyring/t
 import { SingleAddress, SubjectInfo } from '@subwallet/ui-keyring/observable/types';
 export declare const createAccountProxyId: (_suri: string, derivationPath?: string) => `0x${string}`;
 export declare const getAccountChainTypeFromKeypairType: (type: KeypairType) => AccountChainType;
-export declare const getDefaultKeypairTypeFromAccountChainType: (type: AccountChainType) => KeypairType;
+export declare const getDefaultKeypairTypeFromAccountChainType: (type: AccountChainType) => KeypairType[];
 export declare const getAccountSignMode: (address: string, _meta?: KeyringPair$Meta) => AccountSignMode;
 export declare const getAccountActions: (signMode: AccountSignMode, networkType: AccountChainType, type: KeypairType, _meta?: KeyringPair$Meta, parentAccount?: AccountJson) => AccountActions[];
 export declare const getAccountTransactionActions: (signMode: AccountSignMode, networkType: AccountChainType, type?: KeypairType, _meta?: KeyringPair$Meta, _specialNetwork?: string) => ExtrinsicType[];

package/utils/account/transform.js

@@ -37,15 +37,15 @@ export const getAccountChainTypeFromKeypairType = type => {
 };
 export const getDefaultKeypairTypeFromAccountChainType = type => {
   if (type === AccountChainType.ETHEREUM) {
-    return 'ethereum';
+    return ['ethereum'];
   } else if (type === AccountChainType.TON) {
-    return 'ton';
+    return ['ton'];
   } else if (type === AccountChainType.BITCOIN) {
-    return 'bitcoin-84';
+    return ['bitcoin-44', 'bitcoin-84', 'bitcoin-86', 'bittest-44', 'bittest-84', 'bittest-86'];
   } else if (type === AccountChainType.CARDANO) {
-    return 'cardano';
+    return ['cardano'];
   } else {
-    return 'sr25519';
+    return ['sr25519'];
   }
 };
 export const getAccountSignMode = (address, _meta) => {
@@ -162,6 +162,8 @@ export const getAccountTransactionActions = (signMode, networkType, type, _meta,
         return [...BASE_TRANSFER_ACTIONS];
       case AccountChainType.CARDANO:
         return [...BASE_TRANSFER_ACTIONS];
+      case AccountChainType.BITCOIN:
+        return [...BASE_TRANSFER_ACTIONS];
     }
   } else if (signMode === AccountSignMode.QR) {
     switch (networkType) {
@@ -173,6 +175,8 @@ export const getAccountTransactionActions = (signMode, networkType, type, _meta,
         return [];
       case AccountChainType.CARDANO:
         return [];
+      case AccountChainType.BITCOIN:
+        return [];
     }
   } else if (signMode === AccountSignMode.GENERIC_LEDGER) {
     switch (networkType) {
@@ -190,6 +194,8 @@ export const getAccountTransactionActions = (signMode, networkType, type, _meta,
         return [...BASE_TRANSFER_ACTIONS];
       case AccountChainType.CARDANO:
         return [];
+      case AccountChainType.BITCOIN:
+        return [];
     }
   } else if (signMode === AccountSignMode.LEGACY_LEDGER) {
     // Only for Substrate

package/utils/bitcoin/common.d.ts

@@ -0,0 +1,22 @@
+import { _BitcoinApi } from '@subwallet/extension-base/services/chain-service/types';
+import { UtxoResponseItem } from '@subwallet/extension-base/types';
+import BigN from 'bignumber.js';
+export declare function getSizeInfo(payload: {
+    inputLength: number;
+    recipients: string[];
+    sender: string;
+}): {
+    txVBytes: number;
+    txBytes: number;
+    txWeight: number;
+};
+export declare function getSpendableAmount({ feeRate, recipients, sender, utxos }: {
+    utxos: UtxoResponseItem[];
+    feeRate: number;
+    recipients: string[];
+    sender: string;
+}): {
+    spendableAmount: BigN;
+    fee: number;
+};
+export declare const getTransferableBitcoinUtxos: (bitcoinApi: _BitcoinApi, address: string) => Promise<UtxoResponseItem[]>;