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

package/services/balance-service/index.js

@@ -32,6 +32,9 @@ export class BalanceService {
   stopPromiseHandler = createPromiseHandler();
   status = ServiceStatus.NOT_INITIALIZED;
   isReload = false;
+  get isStarted() {
+    return this.status === ServiceStatus.STARTED;
+  }
   detectAccountBalanceStore = new DetectAccountBalanceStore();
   balanceDetectSubject = new BehaviorSubject({});
   intervalTime = 3 * 60 * 1000;
@@ -57,7 +60,7 @@ export class BalanceService {
     this.status = 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));
@@ -143,7 +146,7 @@ export class BalanceService {
     }
     if (needReload) {
       addLazy('reloadBalanceByEvents', () => {
-        if (!this.isReload) {
+        if (!this.isReload && this.isStarted) {
           this.runSubscribeBalances().catch(console.error);
         }
       }, lazyTime, undefined, true);
@@ -194,8 +197,9 @@ export 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 = noop;
-      unsub = subscribeBalance([address], [chain], [tSlug], assetMap, chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, cardanoApiMap, result => {
+      unsub = subscribeBalance([address], [chain], [tSlug], assetMap, chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, cardanoApiMap, bitcoinApiMap, result => {
         const rs = result[0];
         let value;
         switch (balanceType) {
@@ -366,13 +370,14 @@ export 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 = subscribeBalance(addresses, activeChainSlugs, assets, assetMap, chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, cardanoApiMap, result => {
+    const unsub = subscribeBalance(addresses, activeChainSlugs, assets, assetMap, chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, cardanoApiMap, bitcoinApiMap, result => {
       !cancel && this.setBalanceItem(result);
     }, ExtrinsicType.TRANSFER_BALANCE);
     const unsub2 = this.state.subscribeMantaPayBalance();
@@ -382,6 +387,29 @@ export 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 = subscribeBalance([address], [chain], [asset], assetMap, chainInfoMap, substrateApiMap, evmApiMap, tonApiMap, cardanoApiMap, bitcoinApiMap, result => {
+        this.setBalanceItem(result);
+        unsub();
+        resolve();
+      }, extrinsicType || ExtrinsicType.TRANSFER_BALANCE);
+    });
+  }
 
   /** Unsubscribe balance subscription */
   runUnsubscribeBalances() {

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

@@ -0,0 +1,14 @@
+import { _BitcoinApi } from '@subwallet/extension-base/services/chain-service/types';
+import { FeeInfo, TransactionFee } from '@subwallet/extension-base/types';
+import { Network, Psbt } from 'bitcoinjs-lib';
+export interface TransferBitcoinProps extends TransactionFee {
+    bitcoinApi: _BitcoinApi;
+    chain: string;
+    from: string;
+    feeInfo: FeeInfo;
+    to: string;
+    transferAll: boolean;
+    value: string;
+    network: Network;
+}
+export declare function createBitcoinTransaction(params: TransferBitcoinProps): Promise<[Psbt, string, string | undefined]>;

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

@@ -0,0 +1,112 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { _BITCOIN_CHAIN_SLUG, _BITCOIN_NAME, _BITCOIN_TESTNET_NAME } from '@subwallet/extension-base/services/chain-service/constants';
+import { combineBitcoinFee, determineUtxosForSpend, determineUtxosForSpendAll, getTransferableBitcoinUtxos } from '@subwallet/extension-base/utils';
+import { BitcoinAddressType } from '@subwallet/keyring/types';
+import { getBitcoinAddressInfo } from '@subwallet/keyring/utils';
+import { keyring } from '@subwallet/ui-keyring';
+import BigN from 'bignumber.js';
+import { Psbt } from 'bitcoinjs-lib';
+export 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 = combineBitcoinFee(feeInfo, feeOption, feeCustom);
+  const utxos = await 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 ? determineUtxosForSpendAll(determineUtxosArgs) : determineUtxosForSpend(determineUtxosArgs);
+    const pair = keyring.getPair(from);
+    const tx = new Psbt({
+      network
+    });
+    let transferAmount = new BigN(0);
+    for (const input of inputs) {
+      const addressInfo = getBitcoinAddressInfo(pair.address);
+      if (addressInfo.type === BitcoinAddressType.p2pkh || addressInfo.type === 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 === 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 === 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) {
+      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 === _BITCOIN_CHAIN_SLUG) {
+    return _BITCOIN_NAME;
+  } else {
+    return _BITCOIN_TESTNET_NAME;
+  }
+}

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

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

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

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

package/services/base/types.d.ts

@@ -5,6 +5,8 @@ export declare enum ServiceStatus {
     INITIALIZED = "initialized",
     STARTED = "started",
     STARTING = "starting",
+    STARTED_FULL = "started_full",
+    STARTING_FULL = "starting_full",
     STOPPED = "stopped",
     STOPPING = "stopping"
 }

package/services/base/types.js

@@ -10,6 +10,8 @@ export let 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 || (ServiceStatus = {}));

package/services/buy-service/index.js

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

package/services/chain-service/constants.d.ts

@@ -72,6 +72,7 @@ export declare const _TRANSFER_CHAIN_GROUP: {
     pendulum: string[];
     centrifuge: string[];
     disable_transfer: string[];
+    truth: string[];
 };
 export declare const _BALANCE_PARSING_CHAIN_GROUP: {
     bobabeam: string[];
@@ -95,9 +96,14 @@ export declare const EVM_REFORMAT_DECIMALS: {
     acala: string[];
 };
 export declare const LATEST_CHAIN_DATA_FETCHING_INTERVAL = 120000;
+export declare const _BITCOIN_CHAIN_SLUG = "bitcoin";
+export declare const _BITCOIN_TESTNET_CHAIN_SLUG = "bitcoinTestnet";
+export declare const _BITCOIN_NAME = "Bitcoin";
+export declare const _BITCOIN_TESTNET_NAME = "Bitcoin Testnet";
 export declare const _CHAIN_INFO_SRC: string;
 export declare const _CHAIN_ASSET_SRC: string;
 export declare const _ASSET_REF_SRC: string;
 export declare const _MULTI_CHAIN_ASSET_SRC: string;
 export declare const _CHAIN_LOGO_MAP_SRC: string;
 export declare const _ASSET_LOGO_MAP_SRC: string;
+export declare const _BTC_SERVICE_TOKEN: string;

package/services/chain-service/constants.js

@@ -261,7 +261,8 @@ export 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']
 };
 export const _BALANCE_PARSING_CHAIN_GROUP = {
   bobabeam: ['bobabeam', 'bobabase']
@@ -302,9 +303,14 @@ export const LATEST_CHAIN_DATA_FETCHING_INTERVAL = 120000;
 
 // TODO: review
 const TARGET_BRANCH = process.env.NODE_ENV !== 'production' ? 'koni-dev' : 'master';
+export const _BITCOIN_CHAIN_SLUG = 'bitcoin';
+export const _BITCOIN_TESTNET_CHAIN_SLUG = 'bitcoinTestnet';
+export const _BITCOIN_NAME = 'Bitcoin';
+export const _BITCOIN_TESTNET_NAME = 'Bitcoin Testnet';
 export const _CHAIN_INFO_SRC = `https://raw.githubusercontent.com/Koniverse/SubWallet-Chain/${TARGET_BRANCH}/packages/chain-list/src/data/ChainInfo.json`;
 export const _CHAIN_ASSET_SRC = `https://raw.githubusercontent.com/Koniverse/SubWallet-Chain/${TARGET_BRANCH}/packages/chain-list/src/data/ChainAsset.json`;
 export const _ASSET_REF_SRC = `https://raw.githubusercontent.com/Koniverse/SubWallet-Chain/${TARGET_BRANCH}/packages/chain-list/src/data/AssetRef.json`;
 export const _MULTI_CHAIN_ASSET_SRC = `https://raw.githubusercontent.com/Koniverse/SubWallet-Chain/${TARGET_BRANCH}/packages/chain-list/src/data/MultiChainAsset.json`;
 export const _CHAIN_LOGO_MAP_SRC = `https://raw.githubusercontent.com/Koniverse/SubWallet-Chain/${TARGET_BRANCH}/packages/chain-list/src/data/ChainLogoMap.json`;
-export const _ASSET_LOGO_MAP_SRC = `https://raw.githubusercontent.com/Koniverse/SubWallet-Chain/${TARGET_BRANCH}/packages/chain-list/src/data/AssetLogoMap.json`;
+export const _ASSET_LOGO_MAP_SRC = `https://raw.githubusercontent.com/Koniverse/SubWallet-Chain/${TARGET_BRANCH}/packages/chain-list/src/data/AssetLogoMap.json`;
+export const _BTC_SERVICE_TOKEN = process.env.BTC_SERVICE_TOKEN || '';

package/services/chain-service/handler/bitcoin/BitcoinApi.d.ts

@@ -0,0 +1,31 @@
+import { BitcoinApiStrategy } from '@subwallet/extension-base/services/chain-service/handler/bitcoin/strategy/types';
+import { PromiseHandler } from '@subwallet/extension-base/utils/promise';
+import { BehaviorSubject } from 'rxjs';
+import { _ApiOptions } from '../../handler/types';
+import { _BitcoinApi, _ChainConnectionStatus } from '../../types';
+export declare class BitcoinApi implements _BitcoinApi {
+    chainSlug: string;
+    apiUrl: string;
+    apiError?: string;
+    apiRetry: number;
+    readonly isApiConnectedSubject: BehaviorSubject<boolean>;
+    readonly connectionStatusSubject: BehaviorSubject<_ChainConnectionStatus>;
+    isApiReady: boolean;
+    isApiReadyOnce: boolean;
+    isReadyHandler: PromiseHandler<_BitcoinApi>;
+    providerName: string;
+    api: BitcoinApiStrategy;
+    constructor(chainSlug: string, apiUrl: string, { providerName }?: _ApiOptions);
+    get isApiConnected(): boolean;
+    private createApiStrategy;
+    get connectionStatus(): _ChainConnectionStatus;
+    private updateConnectionStatus;
+    get isReady(): Promise<_BitcoinApi>;
+    updateApiUrl(apiUrl: string): Promise<void>;
+    recoverConnect(): Promise<void>;
+    connect(): void;
+    disconnect(): Promise<void>;
+    destroy(): Promise<void>;
+    onConnect(): void;
+    onDisconnect(): void;
+}

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

@@ -0,0 +1,98 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { BlockStreamTestnetRequestStrategy, MempoolTestnetRequestStrategy } from '@subwallet/extension-base/services/chain-service/handler/bitcoin/strategy/BlockStreamTestnet';
+import { SubWalletMainnetRequestStrategy } from '@subwallet/extension-base/services/chain-service/handler/bitcoin/strategy/SubWalletMainnet';
+import { createPromiseHandler } from '@subwallet/extension-base/utils/promise';
+import { BehaviorSubject } from 'rxjs';
+import { _ChainConnectionStatus } from "../../types.js";
+
+// 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/';
+
+export class BitcoinApi {
+  apiRetry = 0;
+  isApiConnectedSubject = new BehaviorSubject(false);
+  connectionStatusSubject = new BehaviorSubject(_ChainConnectionStatus.DISCONNECTED);
+  isApiReady = false;
+  isApiReadyOnce = false;
+  constructor(chainSlug, apiUrl, {
+    providerName
+  } = {}) {
+    this.chainSlug = chainSlug;
+    this.apiUrl = apiUrl;
+    this.providerName = providerName || 'unknown';
+    this.isReadyHandler = 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 BlockStreamTestnetRequestStrategy(apiUrl) : new MempoolTestnetRequestStrategy(apiUrl);
+    }
+    return new SubWalletMainnetRequestStrategy(apiUrl);
+  }
+  get connectionStatus() {
+    return this.connectionStatusSubject.getValue();
+  }
+  updateConnectionStatus(status) {
+    const isConnected = status === _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(_ChainConnectionStatus.CONNECTING);
+    this.onConnect();
+  }
+  async disconnect() {
+    this.onDisconnect();
+    this.updateConnectionStatus(_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(_ChainConnectionStatus.CONNECTED);
+  }
+  onDisconnect() {
+    this.updateConnectionStatus(_ChainConnectionStatus.DISCONNECTED);
+    if (this.isApiConnected) {
+      console.warn(`Disconnected from ${this.chainSlug} of ${this.apiUrl}`);
+      this.isApiReady = false;
+      this.isReadyHandler = createPromiseHandler();
+    }
+  }
+}

package/services/chain-service/handler/bitcoin/BitcoinChainHandler.d.ts

@@ -0,0 +1,16 @@
+import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import { AbstractChainHandler } from '../AbstractChainHandler';
+import { _ApiOptions } from '../types';
+import { BitcoinApi } from './BitcoinApi';
+export declare class BitcoinChainHandler extends AbstractChainHandler {
+    private apiMap;
+    constructor(parent?: ChainService);
+    getApiMap(): Record<string, BitcoinApi>;
+    getApiByChain(chain: string): BitcoinApi;
+    setApi(chainSlug: string, api: BitcoinApi): void;
+    initApi(chainSlug: string, apiUrl: string, { onUpdateStatus, providerName }?: Omit<_ApiOptions, 'metadata'>): Promise<BitcoinApi>;
+    recoverApi(chainSlug: string): Promise<void>;
+    destroyApi(chain: string): void;
+    sleep(): Promise<void>;
+    wakeUp(): Promise<void>;
+}

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

@@ -0,0 +1,70 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { AbstractChainHandler } from "../AbstractChainHandler.js";
+import { BitcoinApi } from "./BitcoinApi.js";
+export class BitcoinChainHandler extends 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, {
+    onUpdateStatus,
+    providerName
+  } = {}) {
+    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(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();
+  }
+}

package/services/chain-service/handler/bitcoin/strategy/BlockStreamTestnet/blockstream-testnet-strategy.d.ts

@@ -0,0 +1,28 @@
+import { BitcoinAddressSummaryInfo, BitcoinApiStrategy, BitcoinTransactionEventMap, BlockStreamTransactionDetail, BlockStreamTransactionStatus, Inscription, RunesInfoByAddress } from '@subwallet/extension-base/services/chain-service/handler/bitcoin/strategy/types';
+import { BaseApiRequestStrategy } from '@subwallet/extension-base/strategy/api-request-strategy';
+import { BitcoinFeeInfo, BitcoinTx, UtxoResponseItem } from '@subwallet/extension-base/types';
+import EventEmitter from 'eventemitter3';
+export declare class BlockStreamTestnetRequestStrategy extends BaseApiRequestStrategy implements BitcoinApiStrategy {
+    private readonly baseUrl;
+    private readonly isTestnet;
+    private timePerBlock;
+    constructor(url: string);
+    private headers;
+    isRateLimited(): boolean;
+    getUrl(path: string): string;
+    getBlockTime(): Promise<number>;
+    computeBlockTime(): Promise<number>;
+    getAddressSummaryInfo(address: string): Promise<BitcoinAddressSummaryInfo>;
+    getAddressTransaction(address: string, limit?: number): Promise<BitcoinTx[]>;
+    getTransactionStatus(txHash: string): Promise<BlockStreamTransactionStatus>;
+    getTransactionDetail(txHash: string): Promise<BlockStreamTransactionDetail>;
+    getFeeRate(): Promise<BitcoinFeeInfo>;
+    getRecommendedFeeRate(): Promise<BitcoinFeeInfo>;
+    getUtxos(address: string): Promise<UtxoResponseItem[]>;
+    sendRawTransaction(rawTransaction: string): EventEmitter<BitcoinTransactionEventMap, any>;
+    simpleSendRawTransaction(rawTransaction: string): Promise<string>;
+    getRunes(address: string): Promise<RunesInfoByAddress[]>;
+    getRuneUtxos(address: string): Promise<import("@subwallet/extension-base/services/chain-service/handler/bitcoin/strategy/types").RuneUtxo[]>;
+    getAddressInscriptions(address: string): Promise<Inscription[]>;
+    getTxHex(txHash: string): Promise<string>;
+}