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

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;

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

@@ -0,0 +1,371 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BlockStreamTestnetRequestStrategy = void 0;
+var _SWError = require("@subwallet/extension-base/background/errors/SWError");
+var _hiroService = require("@subwallet/extension-base/services/hiro-service");
+var _runeService = require("@subwallet/extension-base/services/rune-service");
+var _apiRequestStrategy = require("@subwallet/extension-base/strategy/api-request-strategy");
+var _base = require("@subwallet/extension-base/strategy/api-request-strategy/context/base");
+var _utils = require("@subwallet/extension-base/strategy/api-request-strategy/utils");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _eventemitter = _interopRequireDefault(require("eventemitter3"));
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+class BlockStreamTestnetRequestStrategy extends _apiRequestStrategy.BaseApiRequestStrategy {
+  timePerBlock = 0; // in milliseconds
+
+  constructor(url) {
+    const context = new _base.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 (0, _utils.getRequest)(this.getUrl('blocks'), undefined, this.headers);
+      const blocks = await response.json();
+      if (!response.ok) {
+        throw new _SWError.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 (0, _utils.getRequest)(this.getUrl(`address/${address}`), undefined, this.headers);
+      if (!response.ok) {
+        throw new _SWError.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) {
+    let limit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 100;
+    return this.addRequest(async () => {
+      const response = await (0, _utils.getRequest)(this.getUrl(`address/${address}/txs`), {
+        limit: `${limit}`
+      }, this.headers);
+      if (!response.ok) {
+        throw new _SWError.SWError('BlockStreamTestnetRequestStrategy.getAddressTransaction', 'Failed to fetch transactions');
+      }
+      return await response.json();
+    }, 1);
+  }
+  getTransactionStatus(txHash) {
+    return this.addRequest(async () => {
+      const response = await (0, _utils.getRequest)(this.getUrl(`tx/${txHash}/status`), undefined, {});
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new _SWError.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 (0, _utils.getRequest)(this.getUrl(`tx/${txHash}`), undefined, this.headers);
+      if (!response.ok) {
+        throw new _SWError.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 (0, _utils.getRequest)(this.getUrl('fee-estimates'), undefined, this.headers);
+      const estimates = await response.json();
+      if (!response.ok) {
+        throw new _SWError.SWError('BlockStreamTestnetRequestStrategy.getFeeRate', 'Failed to fetch fee estimates');
+      }
+      const low = 6;
+      const average = 3;
+      const fast = 1;
+      const convertFee = fee => parseFloat(new _bignumber.default(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 (0, _utils.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 _bignumber.default(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 (0, _utils.getRequest)(this.getUrl(`address/${address}/utxo`), undefined, {});
+      const rs = await response.json();
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new _SWError.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.default();
+    this.addRequest(async () => {
+      const response = await (0, _utils.postRequest)(this.getUrl('tx'), rawTransaction, {
+        'Content-Type': 'text/plain'
+      }, false);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new _SWError.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 (0, _utils.postRequest)(this.getUrl('tx'), rawTransaction, {
+        'Content-Type': 'text/plain'
+      }, false);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new _SWError.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 = _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 = _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.SWError('BlockStreamTestnetRequestStrategy.getRuneUtxos', `Failed to get ${address} rune utxos: ${errorMessage}`);
+    }
+  }
+  async getAddressInscriptions(address) {
+    const inscriptionsFullList = [];
+    const pageSize = 60;
+    let offset = 0;
+    const hiroService = _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.SWError('BlockStreamTestnetRequestStrategy.getAddressInscriptions', `Failed to get ${address} inscriptions: ${errorMessage}`);
+    }
+  }
+  getTxHex(txHash) {
+    return this.addRequest(async () => {
+      const response = await (0, _utils.getRequest)(this.getUrl(`tx/${txHash}/hex`), undefined, this.headers);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new _SWError.SWError('BlockStreamTestnetRequestStrategy.getTxHex', `Failed to fetch transaction hex: ${errorText}`);
+      }
+      return await response.text();
+    }, 0);
+  }
+}
+exports.BlockStreamTestnetRequestStrategy = BlockStreamTestnetRequestStrategy;

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

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "BlockStreamTestnetRequestStrategy", {
+  enumerable: true,
+  get: function () {
+    return _blockstreamTestnetStrategy.BlockStreamTestnetRequestStrategy;
+  }
+});
+Object.defineProperty(exports, "MempoolTestnetRequestStrategy", {
+  enumerable: true,
+  get: function () {
+    return _mempoolTestnetStrategy.MempoolTestnetRequestStrategy;
+  }
+});
+var _mempoolTestnetStrategy = require("./mempool-testnet-strategy");
+var _blockstreamTestnetStrategy = require("./blockstream-testnet-strategy");