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

package/cjs/utils/account/common.js

@@ -10,12 +10,12 @@ exports.isAccountAll = isAccountAll;
 exports.modifyAccountName = void 0;
 exports.quickFormatAddressToCompare = quickFormatAddressToCompare;
 exports.reformatAddress = reformatAddress;
-var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
 var _constants = require("@subwallet/extension-base/constants");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
 var _types = require("@subwallet/extension-base/types");
 var _utils2 = require("@subwallet/extension-base/utils");
 var _keyring = require("@subwallet/keyring");
+var _validate = require("@subwallet/keyring/utils/address/validate");
 var _utilCrypto = require("@polkadot/util-crypto");
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
@@ -68,20 +68,22 @@ const getAccountChainTypeForAddress = address => {
   return (0, _utils2.getAccountChainTypeFromKeypairType)(type);
 };
 exports.getAccountChainTypeForAddress = getAccountChainTypeForAddress;
-function getAddressesByChainType(addresses, chainTypes) {
-  const addressByChainTypeMap = getAddressesByChainTypeMap(addresses);
+// TODO: Recheck the usage of this function for Bitcoin; it is currently applied to history.
+function getAddressesByChainType(addresses, chainTypes, chainInfo) {
+  const addressByChainTypeMap = getAddressesByChainTypeMap(addresses, chainInfo);
   return chainTypes.map(chainType => {
     return addressByChainTypeMap[chainType];
   }).flat(); // todo: recheck
 }
 
-function getAddressesByChainTypeMap(addresses) {
+function getAddressesByChainTypeMap(addresses, chainInfo) {
   const addressByChainType = {
     substrate: [],
     evm: [],
     bitcoin: [],
     ton: [],
-    cardano: []
+    cardano: [],
+    _bitcoin: []
   };
   addresses.forEach(address => {
     if ((0, _utilCrypto.isEthereumAddress)(address)) {
@@ -89,7 +91,15 @@ function getAddressesByChainTypeMap(addresses) {
     } else if ((0, _keyring.isTonAddress)(address)) {
       addressByChainType.ton.push(address);
     } else if ((0, _keyring.isBitcoinAddress)(address)) {
-      addressByChainType.bitcoin.push(address);
+      const addressInfo = (0, _validate.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 ((0, _keyring.isCardanoAddress)(address)) {
       addressByChainType.cardano.push(address);
     } else {

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

@@ -13,27 +13,50 @@ var _validate = require("../validate");
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+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)
+};
 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 (_types.SubstrateKeypairTypes.includes(type)) {
@@ -43,6 +66,33 @@ const parseUnifiedSuriToDerivationPath = (suri, type) => {
   return '';
 };
 exports.parseUnifiedSuriToDerivationPath = parseUnifiedSuriToDerivationPath;
+const validateNonSubstrateDerivationPath = (derivePath, type) => {
+  let validateTypeRs;
+  switch (type) {
+    case 'ethereum':
+      validateTypeRs = (0, _validate.validateEvmDerivationPath)(derivePath);
+      break;
+    case 'ton':
+      validateTypeRs = (0, _validate.validateTonDerivationPath)(derivePath);
+      break;
+    case 'cardano':
+      validateTypeRs = (0, _validate.validateCardanoDerivationPath)(derivePath);
+      break;
+    case 'bitcoin-44':
+    case 'bitcoin-84':
+    case 'bitcoin-86':
+    case 'bittest-44':
+    case 'bittest-84':
+    case 'bittest-86':
+      validateTypeRs = (0, _validate.validateBitcoinDerivationPath)(derivePath);
+      break;
+  }
+  if (validateTypeRs && validateTypeRs.type === type) {
+    return validateTypeRs;
+  } else {
+    return undefined;
+  }
+};
 const getSoloDerivationInfo = function (type) {
   let metadata = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   const {
@@ -52,8 +102,7 @@ const getSoloDerivationInfo = function (type) {
   } = metadata;
   if (suri) {
     if (derivePath) {
-      const validateTypeFunc = type === 'ethereum' ? _validate.validateEvmDerivationPath : type === 'ton' ? _validate.validateTonDerivationPath : type === 'cardano' ? _validate.validateCardanoDerivationPath : () => undefined;
-      const validateTypeRs = validateTypeFunc(derivePath);
+      const validateTypeRs = validateNonSubstrateDerivationPath(derivePath, type);
       if (validateTypeRs) {
         return {
           suri: validateTypeRs.suri,
@@ -109,8 +158,7 @@ const getSoloDerivationInfo = function (type) {
     }
   } else {
     if (derivePath) {
-      const validateTypeFunc = type === 'ethereum' ? _validate.validateEvmDerivationPath : type === 'ton' ? _validate.validateTonDerivationPath : type === 'cardano' ? _validate.validateCardanoDerivationPath : () => undefined;
-      const validateTypeRs = validateTypeFunc(derivePath);
+      const validateTypeRs = validateNonSubstrateDerivationPath(derivePath, type);
       if (validateTypeRs) {
         return {
           suri: validateTypeRs.suri,
@@ -229,6 +277,7 @@ const derivePair = (parentPair, name, suri, derivationPath) => {
   const isEvm = _types.EthereumKeypairTypes.includes(parentPair.type);
   const isTon = parentPair.type === 'ton';
   const isCardano = parentPair.type === 'cardano';
+  const isBitcoin = _types.BitcoinKeypairTypes.includes(parentPair.type);
   const meta = {
     name,
     parentAddress: parentPair.address,
@@ -239,8 +288,8 @@ 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/cjs/utils/account/derive/info/unified.js

@@ -97,6 +97,8 @@ 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/cjs/utils/account/derive/validate.js

@@ -3,7 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.validateUnifiedDerivationPath = exports.validateTonDerivationPath = exports.validateSr25519DerivationPath = exports.validateOtherSubstrateDerivationPath = exports.validateEvmDerivationPath = exports.validateDerivationPath = exports.validateCardanoDerivationPath = void 0;
+exports.validateUnifiedDerivationPath = exports.validateTonDerivationPath = exports.validateSr25519DerivationPath = exports.validateOtherSubstrateDerivationPath = exports.validateEvmDerivationPath = exports.validateDerivationPath = exports.validateCardanoDerivationPath = exports.validateBitcoinDerivationPath = void 0;
+var _types = require("@subwallet/keyring/types");
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
@@ -105,6 +106,67 @@ const validateTonDerivationPath = raw => {
   }
 };
 exports.validateTonDerivationPath = validateTonDerivationPath;
+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;
+  }
+};
+exports.validateBitcoinDerivationPath = validateBitcoinDerivationPath;
 const validateCardanoDerivationPath = raw => {
   const reg = /^m\/1852'\/1815'\/(\d+)'(\/\d+')?$/;
   if (raw.match(reg)) {
@@ -201,11 +263,17 @@ const validateDerivationPath = (raw, type) => {
       return validateOtherSubstrateDerivationPath(raw, type);
     } else if (type === 'cardano') {
       return validateCardanoDerivationPath(raw);
+    } else if (_types.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);
   }
 };
 exports.validateDerivationPath = validateDerivationPath;

package/cjs/utils/account/transform.js

@@ -45,15 +45,15 @@ const getAccountChainTypeFromKeypairType = type => {
 exports.getAccountChainTypeFromKeypairType = getAccountChainTypeFromKeypairType;
 const getDefaultKeypairTypeFromAccountChainType = type => {
   if (type === _types2.AccountChainType.ETHEREUM) {
-    return 'ethereum';
+    return ['ethereum'];
   } else if (type === _types2.AccountChainType.TON) {
-    return 'ton';
+    return ['ton'];
   } else if (type === _types2.AccountChainType.BITCOIN) {
-    return 'bitcoin-84';
+    return ['bitcoin-44', 'bitcoin-84', 'bitcoin-86', 'bittest-44', 'bittest-84', 'bittest-86'];
   } else if (type === _types2.AccountChainType.CARDANO) {
-    return 'cardano';
+    return ['cardano'];
   } else {
-    return 'sr25519';
+    return ['sr25519'];
   }
 };
 exports.getDefaultKeypairTypeFromAccountChainType = getDefaultKeypairTypeFromAccountChainType;
@@ -173,6 +173,8 @@ const getAccountTransactionActions = (signMode, networkType, type, _meta, _speci
         return [...BASE_TRANSFER_ACTIONS];
       case _types2.AccountChainType.CARDANO:
         return [...BASE_TRANSFER_ACTIONS];
+      case _types2.AccountChainType.BITCOIN:
+        return [...BASE_TRANSFER_ACTIONS];
     }
   } else if (signMode === _types2.AccountSignMode.QR) {
     switch (networkType) {
@@ -184,6 +186,8 @@ const getAccountTransactionActions = (signMode, networkType, type, _meta, _speci
         return [];
       case _types2.AccountChainType.CARDANO:
         return [];
+      case _types2.AccountChainType.BITCOIN:
+        return [];
     }
   } else if (signMode === _types2.AccountSignMode.GENERIC_LEDGER) {
     switch (networkType) {
@@ -201,6 +205,8 @@ const getAccountTransactionActions = (signMode, networkType, type, _meta, _speci
         return [...BASE_TRANSFER_ACTIONS];
       case _types2.AccountChainType.CARDANO:
         return [];
+      case _types2.AccountChainType.BITCOIN:
+        return [];
     }
   } else if (signMode === _types2.AccountSignMode.LEGACY_LEDGER) {
     // Only for Substrate

package/cjs/utils/auth.js

@@ -15,7 +15,8 @@ const isAddressValidWithAuthType = (address, accountAuthTypes) => {
     evm: _types.EthereumKeypairTypes,
     substrate: _types.SubstrateKeypairTypes,
     ton: _types.TonKeypairTypes,
-    cardano: _types.CardanoKeypairTypes
+    cardano: _types.CardanoKeypairTypes,
+    bitcoin: _types.BitcoinKeypairTypes
   };
   return !!(accountAuthTypes !== null && accountAuthTypes !== void 0 && accountAuthTypes.some(authType => {
     var _validTypes$authType;

package/cjs/utils/bitcoin/common.js

@@ -0,0 +1,98 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSizeInfo = getSizeInfo;
+exports.getSpendableAmount = getSpendableAmount;
+exports.getTransferableBitcoinUtxos = void 0;
+var _utils = require("@subwallet/extension-base/utils");
+var _types = require("@subwallet/keyring/types");
+var _utils2 = require("@subwallet/keyring/utils");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+// Source: https://github.com/leather-wallet/extension/blob/dev/src/app/common/transactions/bitcoin/utils.ts
+function getSizeInfo(payload) {
+  const {
+    inputLength,
+    recipients,
+    sender
+  } = payload;
+  const senderInfo = (0, _utils2.validateBitcoinAddress)(sender) ? (0, _utils2.getBitcoinAddressInfo)(sender) : null;
+  const inputAddressTypeWithFallback = senderInfo ? senderInfo.type : _types.BitcoinAddressType.p2wpkh;
+  const outputMap = {};
+  for (const recipient of recipients) {
+    const recipientInfo = (0, _utils2.validateBitcoinAddress)(recipient) ? (0, _utils2.getBitcoinAddressInfo)(recipient) : null;
+    const outputAddressTypeWithFallback = recipientInfo ? recipientInfo.type : _types.BitcoinAddressType.p2wpkh;
+    const outputKey = outputAddressTypeWithFallback + '_output_count';
+    if (outputMap[outputKey]) {
+      outputMap[outputKey]++;
+    } else {
+      outputMap[outputKey] = 1;
+    }
+  }
+  const txSizer = new _utils2.BtcSizeFeeEstimator();
+  return txSizer.calcTxSize({
+    input_script: inputAddressTypeWithFallback,
+    input_count: inputLength,
+    ...outputMap
+  });
+}
+
+// https://github.com/leather-wallet/extension/blob/dev/src/app/common/transactions/bitcoin/utils.ts
+function getSpendableAmount(_ref) {
+  let {
+    feeRate,
+    recipients,
+    sender,
+    utxos
+  } = _ref;
+  const balance = utxos.map(utxo => utxo.value).reduce((prevVal, curVal) => prevVal + curVal, 0);
+  const size = getSizeInfo({
+    inputLength: utxos.length,
+    recipients,
+    sender
+  });
+  const fee = Math.ceil(size.txVBytes * feeRate);
+  const bigNumberBalance = new _bignumber.default(balance);
+  return {
+    spendableAmount: _bignumber.default.max(0, bigNumberBalance.minus(fee)),
+    fee
+  };
+}
+const getTransferableBitcoinUtxos = async (bitcoinApi, address) => {
+  try {
+    const [utxos, runeTxsUtxos, inscriptionUtxos] = await Promise.all([bitcoinApi.api.getUtxos(address).catch(error => {
+      console.log('Error fetching UTXOs:', error);
+      return [];
+    }), (0, _utils.getRuneUtxos)(bitcoinApi, address).catch(error => {
+      console.log('Error fetching Rune UTXOs:', error);
+      return [];
+    }), (0, _utils.getInscriptionUtxos)(bitcoinApi, address).catch(error => {
+      console.log('Error fetching Inscription UTXOs:', error);
+      return [];
+    })]);
+    let filteredUtxos;
+    if (!utxos || !utxos.length) {
+      return [];
+    }
+
+    // filter out pending utxos
+    // filteredUtxos = filterOutPendingTxsUtxos(utxos);
+
+    // filter out rune utxos
+    filteredUtxos = (0, _utils.filteredOutTxsUtxos)(utxos, runeTxsUtxos);
+
+    // filter out dust utxos
+    // filter out inscription utxos
+    filteredUtxos = (0, _utils.filteredOutTxsUtxos)(utxos, inscriptionUtxos);
+    return filteredUtxos;
+  } catch (error) {
+    console.log('Error while fetching Bitcoin balances', error);
+    return [];
+  }
+};
+exports.getTransferableBitcoinUtxos = getTransferableBitcoinUtxos;

package/cjs/utils/bitcoin/fee.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.combineBitcoinFee = void 0;
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const combineBitcoinFee = (feeInfo, feeOptions, feeCustom) => {
+  if (feeOptions && feeOptions !== 'custom') {
+    var _feeInfo$options;
+    return (_feeInfo$options = feeInfo.options) === null || _feeInfo$options === void 0 ? void 0 : _feeInfo$options[feeOptions];
+  } else if (feeOptions === 'custom' && feeCustom) {
+    return feeCustom;
+  } else {
+    var _feeInfo$options2;
+    return (_feeInfo$options2 = feeInfo.options) === null || _feeInfo$options2 === void 0 ? void 0 : _feeInfo$options2[feeInfo.options.default];
+  }
+};
+exports.combineBitcoinFee = combineBitcoinFee;

package/cjs/utils/bitcoin/index.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _common = require("./common");
+Object.keys(_common).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _common[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _common[key];
+    }
+  });
+});
+var _fee = require("./fee");
+Object.keys(_fee).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _fee[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _fee[key];
+    }
+  });
+});
+var _utxoManagement = require("./utxo-management");
+Object.keys(_utxoManagement).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _utxoManagement[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _utxoManagement[key];
+    }
+  });
+});