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

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