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

package/cjs/services/balance-service/helpers/subscribe/bitcoin.js

@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.subscribeBitcoinBalance = subscribeBitcoinBalance;
+var _types = require("@subwallet/chain-list/types");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _constants = require("@subwallet/extension-base/constants");
+var _utils = require("@subwallet/extension-base/utils");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+function getDefaultBalanceResult() {
+  return {
+    balance: '0',
+    bitcoinBalanceMetadata: {
+      inscriptionCount: 0,
+      runeBalance: '0',
+      inscriptionBalance: '0'
+    }
+  };
+}
+async function getBitcoinBalance(bitcoinApi, addresses) {
+  return await Promise.all(addresses.map(async address => {
+    try {
+      const [addressSummaryInfo] = await Promise.all([bitcoinApi.api.getAddressSummaryInfo(address)]);
+      if (Number(addressSummaryInfo.balance) < 0) {
+        return getDefaultBalanceResult();
+      }
+      const bitcoinBalanceMetadata = {
+        inscriptionCount: addressSummaryInfo.total_inscription,
+        runeBalance: addressSummaryInfo.balance_rune,
+        inscriptionBalance: addressSummaryInfo.balance_inscription
+      };
+      return {
+        balance: addressSummaryInfo.balance.toString(),
+        bitcoinBalanceMetadata: bitcoinBalanceMetadata
+      };
+    } catch (error) {
+      console.log('Error while fetching Bitcoin balances', error);
+      return getDefaultBalanceResult();
+    }
+  }));
+}
+function subscribeBitcoinBalance(params) {
+  var _Object$values$;
+  const {
+    addresses,
+    assetMap,
+    bitcoinApi,
+    callback,
+    chainInfo
+  } = params;
+  const chain = chainInfo.slug;
+  const nativeTokenInfo = (0, _utils.filterAssetsByChainAndType)(assetMap, chain, [_types._AssetType.NATIVE]);
+  const nativeTokenSlug = ((_Object$values$ = Object.values(nativeTokenInfo)[0]) === null || _Object$values$ === void 0 ? void 0 : _Object$values$.slug) || '';
+  const getBalance = () => {
+    getBitcoinBalance(bitcoinApi, addresses).then(balances => {
+      return balances.map((_ref, index) => {
+        let {
+          balance,
+          bitcoinBalanceMetadata
+        } = _ref;
+        return {
+          address: addresses[index],
+          tokenSlug: nativeTokenSlug,
+          state: _KoniTypes.APIItemState.READY,
+          free: balance,
+          locked: (parseInt(bitcoinBalanceMetadata.runeBalance.toString()) + parseInt(bitcoinBalanceMetadata.inscriptionBalance.toString())).toString(),
+          metadata: bitcoinBalanceMetadata
+        };
+      });
+    }).catch(e => {
+      console.error('Error on get Bitcoin balance with token bitcoin', e);
+      return addresses.map(address => {
+        return {
+          address: address,
+          tokenSlug: nativeTokenSlug,
+          state: _KoniTypes.APIItemState.READY,
+          free: '0',
+          locked: '0'
+        };
+      });
+    }).then(items => {
+      callback(items);
+    }).catch(console.error);
+  };
+  const interval = setInterval(getBalance, _constants.BITCOIN_REFRESH_BALANCE_INTERVAL);
+  getBalance();
+  return () => {
+    clearInterval(interval);
+  };
+}

package/cjs/services/balance-service/helpers/subscribe/index.js

@@ -8,6 +8,7 @@ exports.getAccountJsonByAddress = void 0;
 exports.subscribeBalance = subscribeBalance;
 var _types = require("@subwallet/chain-list/types");
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _bitcoin2 = require("@subwallet/extension-base/services/balance-service/helpers/subscribe/bitcoin");
 var _cardano = require("@subwallet/extension-base/services/balance-service/helpers/subscribe/cardano");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
 var _utils2 = require("@subwallet/extension-base/utils");
@@ -45,20 +46,21 @@ const getAccountJsonByAddress = address => {
 exports.getAccountJsonByAddress = getAccountJsonByAddress;
 const filterAddress = (addresses, chainInfo) => {
   const {
+    _bitcoin,
     bitcoin,
     cardano,
     evm,
     substrate,
     ton
-  } = (0, _utils2.getAddressesByChainTypeMap)(addresses);
+  } = (0, _utils2.getAddressesByChainTypeMap)(addresses, chainInfo);
   if ((0, _utils._isChainEvmCompatible)(chainInfo)) {
-    return [evm, [...bitcoin, ...substrate, ...ton, ...cardano]];
+    return [evm, [bitcoin, substrate, ton, cardano, _bitcoin].flat()];
   } else if ((0, _utils._isChainBitcoinCompatible)(chainInfo)) {
-    return [bitcoin, [...evm, ...substrate, ...ton, ...cardano]];
+    return [bitcoin, [evm, substrate, ton, cardano, _bitcoin].flat()];
   } else if ((0, _utils._isChainTonCompatible)(chainInfo)) {
-    return [ton, [...bitcoin, ...evm, ...substrate, ...cardano]];
+    return [ton, [bitcoin, evm, substrate, cardano, _bitcoin].flat()];
   } else if ((0, _utils._isChainCardanoCompatible)(chainInfo)) {
-    return [cardano, [...bitcoin, ...evm, ...substrate, ...ton]];
+    return [cardano, [bitcoin, evm, substrate, ton, _bitcoin].flat()];
   } else {
     const fetchList = [];
     const unfetchList = [];
@@ -84,7 +86,7 @@ const filterAddress = (addresses, chainInfo) => {
         fetchList.push(address);
       }
     });
-    return [fetchList, [...unfetchList, ...bitcoin, ...evm, ...ton, ...cardano]];
+    return [fetchList, [unfetchList, bitcoin, evm, ton, cardano, _bitcoin].flat()];
   }
 };
 const handleUnsupportedOrPendingAddresses = (addresses, chainSlug, chainAssetMap, state, callback) => {
@@ -104,7 +106,7 @@ const handleUnsupportedOrPendingAddresses = (addresses, chainSlug, chainAssetMap
 };
 
 // main subscription, use for multiple chains, multiple addresses and multiple tokens
-function subscribeBalance(addresses, chains, tokens, _chainAssetMap, _chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, cardanoApiMap, callback, extrinsicType) {
+function subscribeBalance(addresses, chains, tokens, _chainAssetMap, _chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, cardanoApiMap, bitcoinApiMap, callback, extrinsicType) {
   // Filter chain and token
   const chainAssetMap = Object.fromEntries(Object.entries(_chainAssetMap).filter(_ref => {
     let [token] = _ref;
@@ -152,6 +154,16 @@ function subscribeBalance(addresses, chains, tokens, _chainAssetMap, _chainInfoM
         cardanoApi
       });
     }
+    const bitcoinApi = bitcoinApiMap[chainSlug];
+    if ((0, _utils._isPureBitcoinChain)(chainInfo)) {
+      return (0, _bitcoin2.subscribeBitcoinBalance)({
+        addresses: useAddresses,
+        assetMap: chainAssetMap,
+        bitcoinApi,
+        callback,
+        chainInfo
+      });
+    }
 
     // If the chain is not ready, return pending state
     if (!substrateApiMap[chainSlug].isApiReady) {

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

@@ -38,6 +38,9 @@ class BalanceService {
   stopPromiseHandler = (0, _utils2.createPromiseHandler)();
   status = _types.ServiceStatus.NOT_INITIALIZED;
   isReload = false;
+  get isStarted() {
+    return this.status === _types.ServiceStatus.STARTED;
+  }
   detectAccountBalanceStore = new _DetectAccountBalance.default();
   balanceDetectSubject = new _rxjs.BehaviorSubject({});
   intervalTime = 3 * 60 * 1000;
@@ -63,7 +66,7 @@ class BalanceService {
     this.status = _types.ServiceStatus.INITIALIZED;
 
     // Start service
-    await this.start();
+    // await this.start(); // Commented out to avoid auto start when app not fully initialized
 
     // Handle events
     this.state.eventService.onLazy(this.handleEvents.bind(this));
@@ -149,7 +152,7 @@ class BalanceService {
     }
     if (needReload) {
       (0, _utils2.addLazy)('reloadBalanceByEvents', () => {
-        if (!this.isReload) {
+        if (!this.isReload && this.isStarted) {
           this.runSubscribeBalances().catch(console.error);
         }
       }, lazyTime, undefined, true);
@@ -203,8 +206,9 @@ class BalanceService {
       const substrateApiMap = this.state.chainService.getSubstrateApiMap();
       const tonApiMap = this.state.chainService.getTonApiMap();
       const cardanoApiMap = this.state.chainService.getCardanoApiMap();
+      const bitcoinApiMap = this.state.chainService.getBitcoinApiMap();
       let unsub = _util.noop;
-      unsub = (0, _helpers.subscribeBalance)([address], [chain], [tSlug], assetMap, chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, cardanoApiMap, result => {
+      unsub = (0, _helpers.subscribeBalance)([address], [chain], [tSlug], assetMap, chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, cardanoApiMap, bitcoinApiMap, result => {
         const rs = result[0];
         let value;
         switch (balanceType) {
@@ -375,13 +379,14 @@ class BalanceService {
     const substrateApiMap = this.state.chainService.getSubstrateApiMap();
     const tonApiMap = this.state.chainService.getTonApiMap();
     const cardanoApiMap = this.state.chainService.getCardanoApiMap();
+    const bitcoinApiMap = this.state.chainService.getBitcoinApiMap();
     const activeChainSlugs = Object.keys(this.state.getActiveChainInfoMap());
     const assetState = this.state.chainService.subscribeAssetSettings().value;
     const assets = Object.values(assetMap).filter(asset => {
       var _assetState$asset$slu;
       return activeChainSlugs.includes(asset.originChain) && ((_assetState$asset$slu = assetState[asset.slug]) === null || _assetState$asset$slu === void 0 ? void 0 : _assetState$asset$slu.visible);
     }).map(asset => asset.slug);
-    const unsub = (0, _helpers.subscribeBalance)(addresses, activeChainSlugs, assets, assetMap, chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, cardanoApiMap, result => {
+    const unsub = (0, _helpers.subscribeBalance)(addresses, activeChainSlugs, assets, assetMap, chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, cardanoApiMap, bitcoinApiMap, result => {
       !cancel && this.setBalanceItem(result);
     }, _KoniTypes.ExtrinsicType.TRANSFER_BALANCE);
     const unsub2 = this.state.subscribeMantaPayBalance();
@@ -391,6 +396,29 @@ class BalanceService {
       unsub2 && unsub2();
     };
   }
+  async refreshBalanceForAddress(address, chain, asset, extrinsicType) {
+    // Check if address and chain are valid
+    const chainInfoMap = this.state.chainService.getChainInfoMap();
+    if (!chainInfoMap[chain]) {
+      console.warn(`Chain ${chain} is not supported`);
+      return;
+    }
+
+    // Get necessary data
+    const assetMap = this.state.chainService.getAssetRegistry();
+    const evmApiMap = this.state.chainService.getEvmApiMap();
+    const substrateApiMap = this.state.chainService.getSubstrateApiMap();
+    const tonApiMap = this.state.chainService.getTonApiMap();
+    const cardanoApiMap = this.state.chainService.getCardanoApiMap();
+    const bitcoinApiMap = this.state.chainService.getBitcoinApiMap();
+    return new Promise(resolve => {
+      const unsub = (0, _helpers.subscribeBalance)([address], [chain], [asset], assetMap, chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, cardanoApiMap, bitcoinApiMap, result => {
+        this.setBalanceItem(result);
+        unsub();
+        resolve();
+      }, extrinsicType || _KoniTypes.ExtrinsicType.TRANSFER_BALANCE);
+    });
+  }
 
   /** Unsubscribe balance subscription */
   runUnsubscribeBalances() {

package/cjs/services/balance-service/transfer/bitcoin-transfer.js

@@ -0,0 +1,119 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createBitcoinTransaction = createBitcoinTransaction;
+var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
+var _constants = require("@subwallet/extension-base/services/chain-service/constants");
+var _utils = require("@subwallet/extension-base/utils");
+var _types = require("@subwallet/keyring/types");
+var _utils2 = require("@subwallet/keyring/utils");
+var _uiKeyring = require("@subwallet/ui-keyring");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _bitcoinjsLib = require("bitcoinjs-lib");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+async function createBitcoinTransaction(params) {
+  const {
+    bitcoinApi,
+    chain,
+    feeCustom: _feeCustom,
+    feeInfo: _feeInfo,
+    feeOption,
+    from,
+    network,
+    to,
+    transferAll,
+    value
+  } = params;
+  const feeCustom = _feeCustom;
+  const feeInfo = _feeInfo;
+  const bitcoinFee = (0, _utils.combineBitcoinFee)(feeInfo, feeOption, feeCustom);
+  const utxos = await (0, _utils.getTransferableBitcoinUtxos)(bitcoinApi, from);
+  try {
+    const amountValue = parseFloat(value);
+    const determineUtxosArgs = {
+      amount: amountValue,
+      feeRate: bitcoinFee.feeRate,
+      recipient: to,
+      sender: from,
+      utxos
+    };
+    const {
+      fee,
+      inputs,
+      isCustomFeeRate,
+      outputs,
+      size
+    } = transferAll ? (0, _utils.determineUtxosForSpendAll)(determineUtxosArgs) : (0, _utils.determineUtxosForSpend)(determineUtxosArgs);
+    const pair = _uiKeyring.keyring.getPair(from);
+    const tx = new _bitcoinjsLib.Psbt({
+      network
+    });
+    let transferAmount = new _bignumber.default(0);
+    for (const input of inputs) {
+      const addressInfo = (0, _utils2.getBitcoinAddressInfo)(pair.address);
+      if (addressInfo.type === _types.BitcoinAddressType.p2pkh || addressInfo.type === _types.BitcoinAddressType.p2sh) {
+        // BIP-44 (Legacy)
+        const hex = await bitcoinApi.api.getTxHex(input.txid);
+        tx.addInput({
+          hash: input.txid,
+          index: input.vout,
+          nonWitnessUtxo: Buffer.from(hex, 'hex')
+        });
+      } else if (addressInfo.type === _types.BitcoinAddressType.p2wpkh) {
+        // BIP-84 (Native SegWit)
+        tx.addInput({
+          hash: input.txid,
+          index: input.vout,
+          witnessUtxo: {
+            script: pair.bitcoin.output,
+            value: input.value
+          }
+        });
+      } else if (addressInfo.type === _types.BitcoinAddressType.p2tr) {
+        // BIP-86 (Taproot)
+        tx.addInput({
+          hash: input.txid,
+          index: input.vout,
+          witnessUtxo: {
+            script: pair.bitcoin.output,
+            value: input.value // UTXO value in satoshis
+          },
+
+          tapInternalKey: pair.bitcoin.internalPubkey // X-only public key (32 bytes)
+        });
+      } else {
+        throw new Error(`Unsupported address type: ${addressInfo.type}`);
+      }
+    }
+    for (const output of outputs) {
+      tx.addOutput({
+        address: output.address || from,
+        value: output.value
+      });
+      if (output.address === to) {
+        transferAmount = transferAmount.plus(output.value);
+      }
+    }
+    const customFeeRate = fee / size;
+    const customFeeRateResult = isCustomFeeRate ? customFeeRate.toString() : undefined;
+    return [tx, transferAmount.toString(), customFeeRateResult];
+  } catch (e) {
+    if (e instanceof _TransactionError.TransactionError) {
+      throw e;
+    }
+    console.warn('Failed to create Bitcoin transaction:', e);
+    throw new Error(`You don’t have enough BTC (${convertChainToSymbol(chain)}) for the transaction. Lower your BTC amount and try again`);
+  }
+}
+function convertChainToSymbol(chain) {
+  if (chain === _constants._BITCOIN_CHAIN_SLUG) {
+    return _constants._BITCOIN_NAME;
+  } else {
+    return _constants._BITCOIN_TESTNET_NAME;
+  }
+}

package/cjs/services/balance-service/transfer/token.js

@@ -116,6 +116,8 @@ const createSubstrateExtrinsic = async _ref => {
         transfer = api.tx.balances.transfer(to, new _util.BN(value));
       }
     }
+  } else if (_constants._TRANSFER_CHAIN_GROUP.truth.includes(networkKey)) {
+    transfer = api.tx.assetManager.transfer(to, (0, _utils3._getTokenOnChainInfo)(tokenInfo), value);
   }
   return [transfer, transferAmount || value];
 };

package/cjs/services/base/types.js

@@ -15,6 +15,8 @@ exports.ServiceStatus = ServiceStatus;
   ServiceStatus["INITIALIZED"] = "initialized";
   ServiceStatus["STARTED"] = "started";
   ServiceStatus["STARTING"] = "starting";
+  ServiceStatus["STARTED_FULL"] = "started_full";
+  ServiceStatus["STARTING_FULL"] = "starting_full";
   ServiceStatus["STOPPED"] = "stopped";
   ServiceStatus["STOPPING"] = "stopping";
 })(ServiceStatus || (exports.ServiceStatus = ServiceStatus = {}));

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

@@ -12,7 +12,18 @@ var _constants = require("./constants");
 // SPDX-License-Identifier: Apache-2.0
 
 const convertSupportType = support => {
-  return support === 'ETHEREUM' ? _types.AccountChainType.ETHEREUM : _types.AccountChainType.SUBSTRATE;
+  switch (support) {
+    case 'ETHEREUM':
+      return _types.AccountChainType.ETHEREUM;
+    case 'SUBSTRATE':
+      return _types.AccountChainType.SUBSTRATE;
+    case 'CARDANO':
+      return _types.AccountChainType.CARDANO;
+    case 'TON':
+      return _types.AccountChainType.TON;
+    default:
+      return null;
+  }
 };
 class BuyService {
   #state;
@@ -35,11 +46,15 @@ class BuyService {
     const data = await (0, _fetchStaticData.fetchStaticData)('buy-token-configs');
     const result = {};
     for (const datum of data) {
+      const support = convertSupportType(datum.support);
+      if (!support) {
+        continue;
+      }
       const temp = {
         serviceInfo: {
           ..._constants.DEFAULT_SERVICE_INFO
         },
-        support: convertSupportType(datum.support),
+        support,
         services: [],
         slug: datum.slug,
         symbol: datum.symbol,

package/cjs/services/chain-service/constants.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports._ZK_ASSET_PREFIX = exports._XCM_TYPE = exports._XCM_CHAIN_GROUP = exports._TRANSFER_NOT_SUPPORTED_CHAINS = exports._TRANSFER_CHAIN_GROUP = exports._SUBSTRATE_DEFAULT_INFLATION_PARAMS = exports._STAKING_ERA_LENGTH_MAP = exports._PURE_EVM_CHAINS = exports._PREDEFINED_SINGLE_MODES = exports._PARACHAIN_INFLATION_DISTRIBUTION = exports._NFT_CHAIN_GROUP = exports._MULTI_CHAIN_ASSET_SRC = exports._MANTA_ZK_CHAIN_GROUP = exports._KNOWN_CHAIN_INFLATION_PARAMS = exports._EXPECTED_BLOCK_TIME = exports._DEFAULT_MANTA_ZK_CHAIN = exports._DEFAULT_ACTIVE_CHAINS = exports._CHAIN_LOGO_MAP_SRC = exports._CHAIN_INFO_SRC = exports._CHAIN_ASSET_SRC = exports._BALANCE_TOKEN_GROUP = exports._BALANCE_PARSING_CHAIN_GROUP = exports._BALANCE_CHAIN_GROUP = exports._ASSET_REF_SRC = exports._ASSET_LOGO_MAP_SRC = exports._API_OPTIONS_CHAIN_GROUP = exports.LATEST_CHAIN_DATA_FETCHING_INTERVAL = exports.EVM_REFORMAT_DECIMALS = exports.EVM_PASS_CONNECT_STATUS = exports.API_MAX_RETRY = exports.API_CONNECT_TIMEOUT = exports.API_AUTO_CONNECT_MS = void 0;
+exports._ZK_ASSET_PREFIX = exports._XCM_TYPE = exports._XCM_CHAIN_GROUP = exports._TRANSFER_NOT_SUPPORTED_CHAINS = exports._TRANSFER_CHAIN_GROUP = exports._SUBSTRATE_DEFAULT_INFLATION_PARAMS = exports._STAKING_ERA_LENGTH_MAP = exports._PURE_EVM_CHAINS = exports._PREDEFINED_SINGLE_MODES = exports._PARACHAIN_INFLATION_DISTRIBUTION = exports._NFT_CHAIN_GROUP = exports._MULTI_CHAIN_ASSET_SRC = exports._MANTA_ZK_CHAIN_GROUP = exports._KNOWN_CHAIN_INFLATION_PARAMS = exports._EXPECTED_BLOCK_TIME = exports._DEFAULT_MANTA_ZK_CHAIN = exports._DEFAULT_ACTIVE_CHAINS = exports._CHAIN_LOGO_MAP_SRC = exports._CHAIN_INFO_SRC = exports._CHAIN_ASSET_SRC = exports._BTC_SERVICE_TOKEN = exports._BITCOIN_TESTNET_NAME = exports._BITCOIN_TESTNET_CHAIN_SLUG = exports._BITCOIN_NAME = exports._BITCOIN_CHAIN_SLUG = exports._BALANCE_TOKEN_GROUP = exports._BALANCE_PARSING_CHAIN_GROUP = exports._BALANCE_CHAIN_GROUP = exports._ASSET_REF_SRC = exports._ASSET_LOGO_MAP_SRC = exports._API_OPTIONS_CHAIN_GROUP = exports.LATEST_CHAIN_DATA_FETCHING_INTERVAL = exports.EVM_REFORMAT_DECIMALS = exports.EVM_PASS_CONNECT_STATUS = exports.API_MAX_RETRY = exports.API_CONNECT_TIMEOUT = exports.API_AUTO_CONNECT_MS = void 0;
 var _chainList = require("@subwallet/chain-list");
 var _types = require("@subwallet/chain-list/types");
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
@@ -279,7 +279,8 @@ const _TRANSFER_CHAIN_GROUP = {
   avail: ['kate', 'goldberg_testnet'],
   pendulum: ['pendulum', 'amplitude', 'amplitude_test', 'hydradx_main', 'bifrost', 'bifrost_dot', 'jamton'],
   centrifuge: ['centrifuge'],
-  disable_transfer: ['crab', 'pangolin']
+  disable_transfer: ['crab', 'pangolin'],
+  truth: ['truth_network']
 };
 exports._TRANSFER_CHAIN_GROUP = _TRANSFER_CHAIN_GROUP;
 const _BALANCE_PARSING_CHAIN_GROUP = {
@@ -328,6 +329,14 @@ const LATEST_CHAIN_DATA_FETCHING_INTERVAL = 120000;
 // TODO: review
 exports.LATEST_CHAIN_DATA_FETCHING_INTERVAL = LATEST_CHAIN_DATA_FETCHING_INTERVAL;
 const TARGET_BRANCH = process.env.NODE_ENV !== 'production' ? 'koni-dev' : 'master';
+const _BITCOIN_CHAIN_SLUG = 'bitcoin';
+exports._BITCOIN_CHAIN_SLUG = _BITCOIN_CHAIN_SLUG;
+const _BITCOIN_TESTNET_CHAIN_SLUG = 'bitcoinTestnet';
+exports._BITCOIN_TESTNET_CHAIN_SLUG = _BITCOIN_TESTNET_CHAIN_SLUG;
+const _BITCOIN_NAME = 'Bitcoin';
+exports._BITCOIN_NAME = _BITCOIN_NAME;
+const _BITCOIN_TESTNET_NAME = 'Bitcoin Testnet';
+exports._BITCOIN_TESTNET_NAME = _BITCOIN_TESTNET_NAME;
 const _CHAIN_INFO_SRC = `https://raw.githubusercontent.com/Koniverse/SubWallet-Chain/${TARGET_BRANCH}/packages/chain-list/src/data/ChainInfo.json`;
 exports._CHAIN_INFO_SRC = _CHAIN_INFO_SRC;
 const _CHAIN_ASSET_SRC = `https://raw.githubusercontent.com/Koniverse/SubWallet-Chain/${TARGET_BRANCH}/packages/chain-list/src/data/ChainAsset.json`;
@@ -339,4 +348,6 @@ exports._MULTI_CHAIN_ASSET_SRC = _MULTI_CHAIN_ASSET_SRC;
 const _CHAIN_LOGO_MAP_SRC = `https://raw.githubusercontent.com/Koniverse/SubWallet-Chain/${TARGET_BRANCH}/packages/chain-list/src/data/ChainLogoMap.json`;
 exports._CHAIN_LOGO_MAP_SRC = _CHAIN_LOGO_MAP_SRC;
 const _ASSET_LOGO_MAP_SRC = `https://raw.githubusercontent.com/Koniverse/SubWallet-Chain/${TARGET_BRANCH}/packages/chain-list/src/data/AssetLogoMap.json`;
-exports._ASSET_LOGO_MAP_SRC = _ASSET_LOGO_MAP_SRC;
+exports._ASSET_LOGO_MAP_SRC = _ASSET_LOGO_MAP_SRC;
+const _BTC_SERVICE_TOKEN = process.env.BTC_SERVICE_TOKEN || '';
+exports._BTC_SERVICE_TOKEN = _BTC_SERVICE_TOKEN;

package/cjs/services/chain-service/handler/bitcoin/BitcoinApi.js

@@ -0,0 +1,105 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BitcoinApi = void 0;
+var _BlockStreamTestnet = require("@subwallet/extension-base/services/chain-service/handler/bitcoin/strategy/BlockStreamTestnet");
+var _SubWalletMainnet = require("@subwallet/extension-base/services/chain-service/handler/bitcoin/strategy/SubWalletMainnet");
+var _promise = require("@subwallet/extension-base/utils/promise");
+var _rxjs = require("rxjs");
+var _types = require("../../types");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// const isBlockStreamProvider = (apiUrl: string): boolean => apiUrl === 'https://blockstream-testnet.openbit.app' || apiUrl === 'https://electrs.openbit.app';
+// const BLOCKSTREAM_TESTNET_API_URL = 'https://blockstream.info/testnet/api/';
+// const MEMPOOL_TESTNET_V4_API_URL = 'https://mempool.space/testnet4/api/';
+
+class BitcoinApi {
+  apiRetry = 0;
+  isApiConnectedSubject = new _rxjs.BehaviorSubject(false);
+  connectionStatusSubject = new _rxjs.BehaviorSubject(_types._ChainConnectionStatus.DISCONNECTED);
+  isApiReady = false;
+  isApiReadyOnce = false;
+  constructor(chainSlug, apiUrl) {
+    let {
+      providerName
+    } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    this.chainSlug = chainSlug;
+    this.apiUrl = apiUrl;
+    this.providerName = providerName || 'unknown';
+    this.isReadyHandler = (0, _promise.createPromiseHandler)();
+    this.api = this.createApiStrategy(apiUrl);
+    this.connect();
+  }
+  get isApiConnected() {
+    return this.isApiConnectedSubject.getValue();
+  }
+  createApiStrategy(apiUrl) {
+    const isTestnet = apiUrl.includes('testnet');
+    const isBlockstreamUrl = apiUrl.includes('blockstream');
+    if (isTestnet) {
+      return isBlockstreamUrl ? new _BlockStreamTestnet.BlockStreamTestnetRequestStrategy(apiUrl) : new _BlockStreamTestnet.MempoolTestnetRequestStrategy(apiUrl);
+    }
+    return new _SubWalletMainnet.SubWalletMainnetRequestStrategy(apiUrl);
+  }
+  get connectionStatus() {
+    return this.connectionStatusSubject.getValue();
+  }
+  updateConnectionStatus(status) {
+    const isConnected = status === _types._ChainConnectionStatus.CONNECTED;
+    if (isConnected !== this.isApiConnectedSubject.value) {
+      this.isApiConnectedSubject.next(isConnected);
+    }
+    if (status !== this.connectionStatusSubject.value) {
+      this.connectionStatusSubject.next(status);
+    }
+  }
+  get isReady() {
+    return this.isReadyHandler.promise;
+  }
+  async updateApiUrl(apiUrl) {
+    if (this.apiUrl === apiUrl) {
+      return;
+    }
+    await this.disconnect();
+    this.apiUrl = apiUrl;
+    this.api = this.createApiStrategy(apiUrl);
+    this.connect();
+  }
+  async recoverConnect() {
+    await this.isReadyHandler.promise;
+  }
+  connect() {
+    this.updateConnectionStatus(_types._ChainConnectionStatus.CONNECTING);
+    this.onConnect();
+  }
+  async disconnect() {
+    this.onDisconnect();
+    this.updateConnectionStatus(_types._ChainConnectionStatus.DISCONNECTED);
+    return Promise.resolve();
+  }
+  destroy() {
+    return this.disconnect();
+  }
+  onConnect() {
+    if (!this.isApiConnected) {
+      console.log(`Connected to ${this.chainSlug} at ${this.apiUrl}`);
+      this.isApiReady = true;
+      if (this.isApiReadyOnce) {
+        this.isReadyHandler.resolve(this);
+      }
+    }
+    this.updateConnectionStatus(_types._ChainConnectionStatus.CONNECTED);
+  }
+  onDisconnect() {
+    this.updateConnectionStatus(_types._ChainConnectionStatus.DISCONNECTED);
+    if (this.isApiConnected) {
+      console.warn(`Disconnected from ${this.chainSlug} of ${this.apiUrl}`);
+      this.isApiReady = false;
+      this.isReadyHandler = (0, _promise.createPromiseHandler)();
+    }
+  }
+}
+exports.BitcoinApi = BitcoinApi;

package/cjs/services/chain-service/handler/bitcoin/BitcoinChainHandler.js

@@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BitcoinChainHandler = void 0;
+var _AbstractChainHandler = require("../AbstractChainHandler");
+var _BitcoinApi = require("./BitcoinApi");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class BitcoinChainHandler extends _AbstractChainHandler.AbstractChainHandler {
+  apiMap = {};
+
+  // eslint-disable-next-line no-useless-constructor
+  constructor(parent) {
+    super(parent);
+  }
+  getApiMap() {
+    return this.apiMap;
+  }
+  getApiByChain(chain) {
+    return this.apiMap[chain];
+  }
+  setApi(chainSlug, api) {
+    this.apiMap[chainSlug] = api;
+  }
+  async initApi(chainSlug, apiUrl) {
+    let {
+      onUpdateStatus,
+      providerName
+    } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    const existed = this.getApiByChain(chainSlug);
+    if (existed) {
+      existed.connect();
+      if (apiUrl !== existed.apiUrl) {
+        existed.updateApiUrl(apiUrl).catch(console.error);
+      }
+      return existed;
+    }
+    const apiObject = new _BitcoinApi.BitcoinApi(chainSlug, apiUrl, {
+      providerName
+    });
+    apiObject.connectionStatusSubject.subscribe(this.handleConnection.bind(this, chainSlug));
+    apiObject.connectionStatusSubject.subscribe(onUpdateStatus);
+    return Promise.resolve(apiObject);
+  }
+  async recoverApi(chainSlug) {
+    const existed = this.getApiByChain(chainSlug);
+    if (existed && !existed.isApiReadyOnce) {
+      console.log(`Reconnect ${existed.providerName || existed.chainSlug} at ${existed.apiUrl}`);
+      return existed.recoverConnect();
+    }
+  }
+  destroyApi(chain) {
+    const api = this.getApiByChain(chain);
+    api === null || api === void 0 ? void 0 : api.destroy().catch(console.error);
+  }
+  async sleep() {
+    this.isSleeping = true;
+    this.cancelAllRecover();
+    await Promise.all(Object.values(this.getApiMap()).map(evmApi => {
+      return evmApi.disconnect().catch(console.error);
+    }));
+    return Promise.resolve();
+  }
+  wakeUp() {
+    var _this$parent;
+    this.isSleeping = false;
+    const activeChains = ((_this$parent = this.parent) === null || _this$parent === void 0 ? void 0 : _this$parent.getActiveChains()) || [];
+    for (const chain of activeChains) {
+      const api = this.getApiByChain(chain);
+      api === null || api === void 0 ? void 0 : api.connect();
+    }
+    return Promise.resolve();
+  }
+}
+exports.BitcoinChainHandler = BitcoinChainHandler;