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

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>;
+}

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

@@ -0,0 +1,362 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { SWError } from '@subwallet/extension-base/background/errors/SWError';
+import { HiroService } from '@subwallet/extension-base/services/hiro-service';
+import { RunesService } from '@subwallet/extension-base/services/rune-service';
+import { BaseApiRequestStrategy } from '@subwallet/extension-base/strategy/api-request-strategy';
+import { BaseApiRequestContext } from '@subwallet/extension-base/strategy/api-request-strategy/context/base';
+import { getRequest, postRequest } from '@subwallet/extension-base/strategy/api-request-strategy/utils';
+import BigN from 'bignumber.js';
+import EventEmitter from 'eventemitter3';
+export class BlockStreamTestnetRequestStrategy extends BaseApiRequestStrategy {
+  timePerBlock = 0; // in milliseconds
+
+  constructor(url) {
+    const context = new BaseApiRequestContext();
+    super(context);
+    this.baseUrl = url;
+    this.isTestnet = url.includes('testnet');
+  }
+  headers = {
+    'Content-Type': 'application/json'
+  };
+  isRateLimited() {
+    return false;
+  }
+  getUrl(path) {
+    return `${this.baseUrl}/${path}`;
+  }
+  getBlockTime() {
+    return this.addRequest(async () => {
+      const response = await getRequest(this.getUrl('blocks'), undefined, this.headers);
+      const blocks = await response.json();
+      if (!response.ok) {
+        throw new SWError('BlockStreamTestnetRequestStrategy.getBlockTime', 'Failed to fetch blocks');
+      }
+      const length = blocks.length;
+      const sortedBlocks = blocks.sort((a, b) => b.timestamp - a.timestamp);
+      const time = (sortedBlocks[0].timestamp - sortedBlocks[length - 1].timestamp) * 1000;
+      return time / length;
+    }, 0);
+  }
+  async computeBlockTime() {
+    let blockTime = this.timePerBlock;
+    if (blockTime > 0) {
+      return blockTime;
+    }
+    try {
+      blockTime = await this.getBlockTime();
+      this.timePerBlock = blockTime;
+    } catch (e) {
+      console.error('Failed to compute block time', e);
+      blockTime = (this.isTestnet ? 5 * 60 : 10 * 60) * 1000; // Default to 10 minutes if failed
+    }
+
+    // Cache block time in 60 seconds
+    setTimeout(() => {
+      this.timePerBlock = 0;
+    }, 60000);
+    return blockTime;
+  }
+  getAddressSummaryInfo(address) {
+    return this.addRequest(async () => {
+      const response = await getRequest(this.getUrl(`address/${address}`), undefined, this.headers);
+      if (!response.ok) {
+        throw new SWError('BlockStreamTestnetRequestStrategy.getAddressSummaryInfo', 'Failed to fetch address info');
+      }
+      const rsRaw = await response.json();
+      const chainBalance = rsRaw.chain_stats.funded_txo_sum - rsRaw.chain_stats.spent_txo_sum;
+      const pendingLocked = rsRaw.mempool_stats.spent_txo_sum; // Only consider spent UTXOs in mempool
+      const mempoolReceived = rsRaw.mempool_stats.funded_txo_sum; // Funds received in mempool (e.g., change)
+      const availableBalance = Math.max(0, chainBalance - pendingLocked + mempoolReceived); // Ensure balance is non-negative
+
+      const rs = {
+        address: rsRaw.address,
+        chain_stats: {
+          funded_txo_count: rsRaw.chain_stats.funded_txo_count,
+          funded_txo_sum: rsRaw.chain_stats.funded_txo_sum,
+          spent_txo_count: rsRaw.chain_stats.spent_txo_count,
+          spent_txo_sum: rsRaw.chain_stats.spent_txo_sum,
+          tx_count: rsRaw.chain_stats.tx_count
+        },
+        mempool_stats: {
+          funded_txo_count: rsRaw.mempool_stats.funded_txo_count,
+          funded_txo_sum: rsRaw.mempool_stats.funded_txo_sum,
+          spent_txo_count: rsRaw.mempool_stats.spent_txo_count,
+          spent_txo_sum: rsRaw.mempool_stats.spent_txo_sum,
+          tx_count: rsRaw.mempool_stats.tx_count
+        },
+        balance: availableBalance,
+        total_inscription: 0,
+        balance_rune: '0',
+        balance_inscription: '0'
+      };
+      return rs;
+    }, 0);
+  }
+  getAddressTransaction(address, limit = 100) {
+    return this.addRequest(async () => {
+      const response = await getRequest(this.getUrl(`address/${address}/txs`), {
+        limit: `${limit}`
+      }, this.headers);
+      if (!response.ok) {
+        throw new SWError('BlockStreamTestnetRequestStrategy.getAddressTransaction', 'Failed to fetch transactions');
+      }
+      return await response.json();
+    }, 1);
+  }
+  getTransactionStatus(txHash) {
+    return this.addRequest(async () => {
+      const response = await getRequest(this.getUrl(`tx/${txHash}/status`), undefined, {});
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new SWError('BlockStreamTestnetRequestStrategy.getTransactionStatus', `Failed to fetch transaction status: ${errorText}`);
+      }
+
+      // Blockstream API trả về object thô
+      const data = await response.json();
+      return {
+        confirmed: data.confirmed || false,
+        block_time: data.block_time || 0,
+        block_height: data.block_height,
+        block_hash: data.block_hash
+      };
+    }, 1);
+  }
+  getTransactionDetail(txHash) {
+    return this.addRequest(async () => {
+      const response = await getRequest(this.getUrl(`tx/${txHash}`), undefined, this.headers);
+      if (!response.ok) {
+        throw new SWError('BlockStreamTestnetRequestStrategy.getTransactionDetail', 'Failed to fetch transaction detail');
+      }
+      return await response.json();
+    }, 1);
+  }
+
+  // TODO: NOTE: Currently not in use. Recheck the response if you want to use it.
+  async getFeeRate() {
+    const blockTime = await this.computeBlockTime();
+    return await this.addRequest(async () => {
+      const response = await getRequest(this.getUrl('fee-estimates'), undefined, this.headers);
+      const estimates = await response.json();
+      if (!response.ok) {
+        throw new SWError('BlockStreamTestnetRequestStrategy.getFeeRate', 'Failed to fetch fee estimates');
+      }
+      const low = 6;
+      const average = 3;
+      const fast = 1;
+      const convertFee = fee => parseFloat(new BigN(fee).toFixed(2));
+      return {
+        type: 'bitcoin',
+        busyNetwork: false,
+        options: {
+          slow: {
+            feeRate: convertFee(estimates[low] || 10),
+            time: blockTime * low
+          },
+          average: {
+            feeRate: convertFee(estimates[average || 12]),
+            time: blockTime * average
+          },
+          fast: {
+            feeRate: convertFee(estimates[fast] || 15),
+            time: blockTime * fast
+          },
+          default: 'slow'
+        }
+      };
+    }, 0);
+  }
+  getRecommendedFeeRate() {
+    return this.addRequest(async () => {
+      const convertTimeMilisec = {
+        fastestFee: 10 * 60000,
+        halfHourFee: 30 * 60000,
+        hourFee: 60 * 60000
+      };
+      const defaultFeeInfo = {
+        type: 'bitcoin',
+        busyNetwork: false,
+        options: {
+          slow: {
+            feeRate: 1.5,
+            time: convertTimeMilisec.hourFee
+          },
+          average: {
+            feeRate: 1.5,
+            time: convertTimeMilisec.halfHourFee
+          },
+          fast: {
+            feeRate: 1.5,
+            time: convertTimeMilisec.fastestFee
+          },
+          default: 'slow'
+        }
+      };
+      try {
+        const response = await getRequest(this.getUrl('/fee-estimates'), undefined, this.headers);
+        if (!response.ok) {
+          console.warn(`Failed to fetch fee estimates: ${response.statusText}`);
+          return defaultFeeInfo;
+        }
+        const estimates = await response.json();
+        const convertFee = fee => {
+          const adjustedFee = parseInt(new BigN(fee).toFixed(), 10);
+          return Math.max(adjustedFee, 1.5);
+        };
+        return {
+          type: 'bitcoin',
+          busyNetwork: false,
+          options: {
+            slow: {
+              feeRate: convertFee(estimates['6'] || 1),
+              time: this.timePerBlock * 6
+            },
+            // 6 block
+            average: {
+              feeRate: convertFee(estimates['3'] || 1),
+              time: this.timePerBlock * 3
+            },
+            // 3 block
+            fast: {
+              feeRate: convertFee(estimates['1'] || 1),
+              time: this.timePerBlock
+            },
+            // 1 block
+            default: 'slow'
+          }
+        };
+      } catch {
+        return defaultFeeInfo;
+      }
+    }, 0);
+  }
+  getUtxos(address) {
+    return this.addRequest(async () => {
+      const response = await getRequest(this.getUrl(`address/${address}/utxo`), undefined, {});
+      const rs = await response.json();
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new SWError('BlockStreamTestnetRequestStrategy.getUtxos', `Failed to fetch UTXOs: ${errorText}`);
+      }
+      return rs.map(item => ({
+        txid: item.txid,
+        vout: item.vout,
+        value: item.value,
+        status: item.status
+      }));
+    }, 0);
+  }
+  sendRawTransaction(rawTransaction) {
+    const eventEmitter = new EventEmitter();
+    this.addRequest(async () => {
+      const response = await postRequest(this.getUrl('tx'), rawTransaction, {
+        'Content-Type': 'text/plain'
+      }, false);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new SWError('BlockStreamTestnetRequestStrategy.sendRawTransaction', `Failed to broadcast transaction: ${errorText}`);
+      }
+      return await response.text();
+    }, 0).then(extrinsicHash => {
+      eventEmitter.emit('extrinsicHash', extrinsicHash);
+
+      // Check transaction status
+      const interval = setInterval(() => {
+        this.getTransactionStatus(extrinsicHash).then(transactionStatus => {
+          if (transactionStatus.confirmed && transactionStatus.block_time > 0) {
+            clearInterval(interval);
+            eventEmitter.emit('success', transactionStatus);
+          }
+        }).catch(console.error);
+      }, 30000);
+    }).catch(error => {
+      eventEmitter.emit('error', error.message);
+    });
+    return eventEmitter;
+  }
+  simpleSendRawTransaction(rawTransaction) {
+    return this.addRequest(async () => {
+      const response = await postRequest(this.getUrl('tx'), rawTransaction, {
+        'Content-Type': 'text/plain'
+      }, false);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new SWError('BlockStreamTestnetRequestStrategy.simpleSendRawTransaction', `Failed to broadcast transaction: ${errorText}`);
+      }
+      return await response.text();
+    }, 0);
+  }
+  async getRunes(address) {
+    const runesFullList = [];
+    const pageSize = 60;
+    let offset = 0;
+    const runeService = RunesService.getInstance(this.isTestnet);
+    try {
+      while (true) {
+        const response = await runeService.getAddressRunesInfo(address, {
+          limit: String(pageSize),
+          offset: String(offset)
+        });
+        const runes = response.runes;
+        if (runes.length !== 0) {
+          runesFullList.push(...runes);
+          offset += pageSize;
+        } else {
+          break;
+        }
+      }
+      return runesFullList;
+    } catch (error) {
+      console.error(`Failed to get ${address} balances`, error);
+      throw error;
+    }
+  }
+  async getRuneUtxos(address) {
+    const runeService = RunesService.getInstance(this.isTestnet);
+    try {
+      const responseRuneUtxos = await runeService.getAddressRuneUtxos(address);
+      return responseRuneUtxos.results;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new SWError('BlockStreamTestnetRequestStrategy.getRuneUtxos', `Failed to get ${address} rune utxos: ${errorMessage}`);
+    }
+  }
+  async getAddressInscriptions(address) {
+    const inscriptionsFullList = [];
+    const pageSize = 60;
+    let offset = 0;
+    const hiroService = HiroService.getInstance(this.isTestnet);
+    try {
+      while (true) {
+        const response = await hiroService.getAddressInscriptionsInfo({
+          limit: String(pageSize),
+          offset: String(offset),
+          address: String(address)
+        });
+        const inscriptions = response.results;
+        if (inscriptions.length !== 0) {
+          inscriptionsFullList.push(...inscriptions);
+          offset += pageSize;
+        } else {
+          break;
+        }
+      }
+      return inscriptionsFullList;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new SWError('BlockStreamTestnetRequestStrategy.getAddressInscriptions', `Failed to get ${address} inscriptions: ${errorMessage}`);
+    }
+  }
+  getTxHex(txHash) {
+    return this.addRequest(async () => {
+      const response = await getRequest(this.getUrl(`tx/${txHash}/hex`), undefined, this.headers);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new SWError('BlockStreamTestnetRequestStrategy.getTxHex', `Failed to fetch transaction hex: ${errorText}`);
+      }
+      return await response.text();
+    }, 0);
+  }
+}

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

@@ -0,0 +1,2 @@
+export { MempoolTestnetRequestStrategy } from './mempool-testnet-strategy';
+export { BlockStreamTestnetRequestStrategy } from './blockstream-testnet-strategy';

package/services/chain-service/handler/bitcoin/strategy/BlockStreamTestnet/index.js

@@ -0,0 +1,5 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export { MempoolTestnetRequestStrategy } from "./mempool-testnet-strategy.js";
+export { BlockStreamTestnetRequestStrategy } from "./blockstream-testnet-strategy.js";

package/services/chain-service/handler/bitcoin/strategy/BlockStreamTestnet/mempool-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 MempoolTestnetRequestStrategy 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>;
+}