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

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/auth.js

@@ -2,14 +2,15 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { getKeypairTypeByAddress } from '@subwallet/keyring';
-import { CardanoKeypairTypes, EthereumKeypairTypes, SubstrateKeypairTypes, TonKeypairTypes } from '@subwallet/keyring/types';
+import { BitcoinKeypairTypes, CardanoKeypairTypes, EthereumKeypairTypes, SubstrateKeypairTypes, TonKeypairTypes } from '@subwallet/keyring/types';
 export const isAddressValidWithAuthType = (address, accountAuthTypes) => {
   const keypairType = getKeypairTypeByAddress(address);
   const validTypes = {
     evm: EthereumKeypairTypes,
     substrate: SubstrateKeypairTypes,
     ton: TonKeypairTypes,
-    cardano: CardanoKeypairTypes
+    cardano: CardanoKeypairTypes,
+    bitcoin: BitcoinKeypairTypes
   };
   return !!(accountAuthTypes !== null && accountAuthTypes !== void 0 && accountAuthTypes.some(authType => {
     var _validTypes$authType;

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[]>;

package/utils/bitcoin/common.js

@@ -0,0 +1,88 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { filteredOutTxsUtxos, getInscriptionUtxos, getRuneUtxos } from '@subwallet/extension-base/utils';
+import { BitcoinAddressType } from '@subwallet/keyring/types';
+import { BtcSizeFeeEstimator, getBitcoinAddressInfo, validateBitcoinAddress } from '@subwallet/keyring/utils';
+import BigN from 'bignumber.js';
+
+// Source: https://github.com/leather-wallet/extension/blob/dev/src/app/common/transactions/bitcoin/utils.ts
+export function getSizeInfo(payload) {
+  const {
+    inputLength,
+    recipients,
+    sender
+  } = payload;
+  const senderInfo = validateBitcoinAddress(sender) ? getBitcoinAddressInfo(sender) : null;
+  const inputAddressTypeWithFallback = senderInfo ? senderInfo.type : BitcoinAddressType.p2wpkh;
+  const outputMap = {};
+  for (const recipient of recipients) {
+    const recipientInfo = validateBitcoinAddress(recipient) ? getBitcoinAddressInfo(recipient) : null;
+    const outputAddressTypeWithFallback = recipientInfo ? recipientInfo.type : BitcoinAddressType.p2wpkh;
+    const outputKey = outputAddressTypeWithFallback + '_output_count';
+    if (outputMap[outputKey]) {
+      outputMap[outputKey]++;
+    } else {
+      outputMap[outputKey] = 1;
+    }
+  }
+  const txSizer = new 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
+export function getSpendableAmount({
+  feeRate,
+  recipients,
+  sender,
+  utxos
+}) {
+  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 BigN(balance);
+  return {
+    spendableAmount: BigN.max(0, bigNumberBalance.minus(fee)),
+    fee
+  };
+}
+export 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 [];
+    }), getRuneUtxos(bitcoinApi, address).catch(error => {
+      console.log('Error fetching Rune UTXOs:', error);
+      return [];
+    }), 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 = filteredOutTxsUtxos(utxos, runeTxsUtxos);
+
+    // filter out dust utxos
+    // filter out inscription utxos
+    filteredUtxos = filteredOutTxsUtxos(utxos, inscriptionUtxos);
+    return filteredUtxos;
+  } catch (error) {
+    console.log('Error while fetching Bitcoin balances', error);
+    return [];
+  }
+};

package/utils/bitcoin/fee.d.ts

@@ -0,0 +1,2 @@
+import { BitcoinFeeInfo, BitcoinFeeRate, FeeOption } from '@subwallet/extension-base/types';
+export declare const combineBitcoinFee: (feeInfo: BitcoinFeeInfo, feeOptions?: FeeOption, feeCustom?: BitcoinFeeRate) => BitcoinFeeRate;

package/utils/bitcoin/fee.js

@@ -0,0 +1,14 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+export 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];
+  }
+};

package/utils/bitcoin/index.d.ts

@@ -0,0 +1,3 @@
+export * from './common';
+export * from './fee';
+export * from './utxo-management';

package/utils/bitcoin/index.js

@@ -0,0 +1,6 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+export * from "./common.js";
+export * from "./fee.js";
+export * from "./utxo-management.js";

package/utils/bitcoin/utxo-management.d.ts

@@ -0,0 +1,33 @@
+import { _BitcoinApi } from '@subwallet/extension-base/services/chain-service/types';
+import { DetermineUtxosForSpendArgs, UtxoResponseItem } from '@subwallet/extension-base/types';
+export declare function filterUneconomicalUtxos({ feeRate, recipients, sender, utxos }: {
+    utxos: UtxoResponseItem[];
+    feeRate: number;
+    sender: string;
+    recipients: string[];
+}): UtxoResponseItem[];
+export declare function determineUtxosForSpendAll({ feeRate, recipient, sender, utxos }: DetermineUtxosForSpendArgs): {
+    inputs: UtxoResponseItem[];
+    outputs: {
+        value: number;
+        address: string;
+    }[];
+    size: number;
+    fee: number;
+    isCustomFeeRate: boolean;
+};
+export declare function determineUtxosForSpend({ amount, feeRate, recipient, sender, utxos }: DetermineUtxosForSpendArgs): {
+    filteredUtxos: UtxoResponseItem[];
+    inputs: UtxoResponseItem[];
+    outputs: {
+        value: number;
+        address: string;
+    }[];
+    size: number;
+    fee: number;
+    isCustomFeeRate: boolean;
+};
+export declare function filterOutPendingTxsUtxos(utxos: UtxoResponseItem[]): UtxoResponseItem[];
+export declare function filteredOutTxsUtxos(allTxsUtxos: UtxoResponseItem[], filteredOutTxsUtxos: UtxoResponseItem[]): UtxoResponseItem[];
+export declare function getRuneUtxos(bitcoinApi: _BitcoinApi, address: string): Promise<UtxoResponseItem[]>;
+export declare function getInscriptionUtxos(bitcoinApi: _BitcoinApi, address: string): Promise<UtxoResponseItem[]>;