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

package/cjs/services/request-service/handler/BitcoinRequestHandler.js

@@ -0,0 +1,440 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _BitcoinProviderError = require("@subwallet/extension-base/background/errors/BitcoinProviderError");
+var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _bitcoinTransfer = require("@subwallet/extension-base/services/balance-service/transfer/bitcoin-transfer");
+var _types = require("@subwallet/extension-base/types");
+var _utils = require("@subwallet/extension-base/utils");
+var _getId = require("@subwallet/extension-base/utils/getId");
+var _request = require("@subwallet/extension-base/utils/request");
+var _uiKeyring = _interopRequireDefault(require("@subwallet/ui-keyring"));
+var bitcoin = _interopRequireWildcard(require("bitcoinjs-lib"));
+var _i18next = require("i18next");
+var _rxjs = require("rxjs");
+var _util = require("@polkadot/util");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class BitcoinRequestHandler {
+  #requestService;
+  #chainService;
+  #transactionService;
+  #feeService;
+  #logger;
+  confirmationsQueueSubjectBitcoin = new _rxjs.BehaviorSubject({
+    bitcoinSignatureRequest: {},
+    bitcoinSendTransactionRequest: {},
+    bitcoinWatchTransactionRequest: {},
+    bitcoinSendTransactionRequestAfterConfirmation: {},
+    bitcoinSignPsbtRequest: {}
+  });
+  confirmationsPromiseMap = {};
+  constructor(requestService, chainService, feeService, transactionService) {
+    this.#requestService = requestService;
+    this.#chainService = chainService;
+    this.#feeService = feeService;
+    this.#transactionService = transactionService;
+    this.#logger = (0, _util.logger)('BitcoinRequestHandler');
+  }
+  get numBitcoinRequests() {
+    let count = 0;
+    Object.values(this.confirmationsQueueSubjectBitcoin.getValue()).forEach(x => {
+      count += Object.keys(x).length;
+    });
+    return count;
+  }
+  getConfirmationsQueueSubjectBitcoin() {
+    return this.confirmationsQueueSubjectBitcoin;
+  }
+  async addConfirmationBitcoin(id, url, type, payload) {
+    let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+    let validator = arguments.length > 5 ? arguments[5] : undefined;
+    const confirmations = this.confirmationsQueueSubjectBitcoin.getValue();
+    const confirmationType = confirmations[type];
+    const payloadJson = JSON.stringify(payload);
+    const isInternal = (0, _request.isInternalRequest)(url);
+    if (['bitcoinSignatureRequest', 'bitcoinSendTransactionRequest', 'bitcoinSendTransactionRequestAfterConfirmation'].includes(type)) {
+      const isAlwaysRequired = await this.#requestService.settingService.isAlwaysRequired;
+      if (isAlwaysRequired) {
+        this.#requestService.keyringService.lock();
+      }
+    }
+
+    // Check duplicate request
+    const duplicated = Object.values(confirmationType).find(c => c.url === url && c.payloadJson === payloadJson);
+    if (duplicated) {
+      throw new Error('Duplicate request');
+    }
+    confirmationType[id] = {
+      id,
+      url,
+      isInternal,
+      payload,
+      payloadJson,
+      ...options
+    };
+    const promise = new Promise((resolve, reject) => {
+      this.confirmationsPromiseMap[id] = {
+        validator: validator,
+        resolver: {
+          resolve: resolve,
+          reject: reject
+        }
+      };
+    });
+    this.confirmationsQueueSubjectBitcoin.next(confirmations);
+    if (!isInternal) {
+      this.#requestService.popupOpen();
+    }
+    this.#requestService.updateIconV2();
+    return promise;
+  }
+  updateConfirmationBitcoin(id, type, payload) {
+    let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+    let validator = arguments.length > 4 ? arguments[4] : undefined;
+    const confirmations = this.confirmationsQueueSubjectBitcoin.getValue();
+    const confirmationType = confirmations[type];
+
+    // Check duplicate request
+    const exists = confirmationType[id];
+    if (!exists) {
+      throw new Error('Request does not exist');
+    }
+    const payloadJson = JSON.stringify(payload);
+    confirmationType[id] = {
+      ...exists,
+      payload,
+      payloadJson,
+      ...options
+    };
+    if (validator) {
+      this.confirmationsPromiseMap[id].validator = validator;
+    }
+    this.confirmationsQueueSubjectBitcoin.next(confirmations);
+  }
+  signMessageBitcoin(confirmation) {
+    const {
+      account,
+      payload
+    } = confirmation.payload;
+    const address = account.address;
+    const pair = _uiKeyring.default.getPair(address);
+    if (pair.isLocked) {
+      _uiKeyring.default.unlockPair(pair.address);
+    }
+
+    // Check if payload is a string
+    if (typeof payload === 'string') {
+      // Assume BitcoinSigner is an instance that implements the BitcoinSigner interface
+      return {
+        signature: pair.bitcoin.signMessage(payload),
+        message: payload,
+        address
+      }; // Assuming compressed = false
+    } else if (payload instanceof Uint8Array) {
+      // Check if payload is a byte array (Uint8Array)
+      // Convert Uint8Array to string
+      const payloadString = Buffer.from(payload).toString('hex');
+
+      // Assume BitcoinSigner is an instance that implements the BitcoinSigner interface
+      return {
+        signature: pair.bitcoin.signMessage(payloadString),
+        message: payload.toString(),
+        address
+      }; // Assuming compressed = false
+    } else {
+      // Handle the case where payload is invalid
+      throw new Error('Invalid payload type');
+    }
+  }
+  signTransactionBitcoin(request) {
+    // Extract necessary information from the BitcoinSendTransactionRequest
+    const {
+      account,
+      hashPayload
+    } = request.payload;
+    const address = account.address;
+    const pair = _uiKeyring.default.getPair(address);
+
+    // Unlock the pair if it is locked
+    if (pair.isLocked) {
+      _uiKeyring.default.unlockPair(pair.address);
+    }
+    const psbt = bitcoin.Psbt.fromHex(hashPayload);
+
+    // Finalize all inputs in the Psbt
+    // Sign the Psbt using the pair's bitcoin object
+    const signedTransaction = pair.bitcoin.signTransaction(psbt, psbt.txInputs.map((v, i) => i));
+    signedTransaction.finalizeAllInputs();
+    return signedTransaction.extractTransaction().toHex();
+  }
+  async signTransactionBitcoinWithPayload(request) {
+    const transaction = this.#transactionService.getTransaction(request.id);
+    const {
+      chain,
+      emitterTransaction,
+      feeCustom,
+      feeOption,
+      id
+    } = transaction;
+    const {
+      from,
+      to,
+      value
+    } = transaction.data;
+    if (!emitterTransaction) {
+      throw new _BitcoinProviderError.BitcoinProviderError(_KoniTypes.BitcoinProviderErrorType.INTERNAL_ERROR);
+    }
+    const chainInfo = this.#chainService.getChainInfoByKey(chain);
+    const bitcoinApi = this.#chainService.getBitcoinApi(chain);
+    const eventData = {
+      id,
+      errors: [],
+      warnings: [],
+      extrinsicHash: id
+    };
+    const network = chainInfo.isTestnet ? bitcoin.networks.testnet : bitcoin.networks.bitcoin;
+    const feeInfo = await this.#feeService.subscribeChainFee((0, _getId.getId)(), chain, 'bitcoin');
+    const [psbt] = await (0, _bitcoinTransfer.createBitcoinTransaction)({
+      bitcoinApi,
+      chain,
+      from,
+      feeCustom,
+      feeOption,
+      feeInfo,
+      to,
+      transferAll: false,
+      value: value || '0',
+      network
+    });
+    const pair = _uiKeyring.default.getPair(from);
+
+    // Unlock the pair if it is locked
+    if (pair.isLocked) {
+      _uiKeyring.default.unlockPair(pair.address);
+    }
+
+    // Finalize all inputs in the Psbt
+
+    // Sign the Psbt using the pair's bitcoin object
+    const signedTransaction = pair.bitcoin.signTransaction(psbt, psbt.txInputs.map((v, i) => i));
+    signedTransaction.finalizeAllInputs();
+    const signature = signedTransaction.extractTransaction().toHex();
+    this.#transactionService.emitterEventTransaction(emitterTransaction, eventData, chainInfo.slug, signature);
+    const {
+      promise,
+      reject,
+      resolve
+    } = (0, _utils.createPromiseHandler)();
+    emitterTransaction.on('extrinsicHash', data => {
+      if (!data.extrinsicHash) {
+        reject(_KoniTypes.BitcoinProviderErrorType.INTERNAL_ERROR);
+      } else {
+        resolve(data.extrinsicHash);
+      }
+    });
+    emitterTransaction.on('error', error => {
+      reject(error);
+    });
+    return promise;
+  }
+  async signPsbt(request) {
+    // Extract necessary information from the BitcoinSendTransactionRequest
+    const {
+      account,
+      payload
+    } = request.payload;
+    const {
+      allowedSighash,
+      broadcast,
+      psbt,
+      signAtIndex
+    } = payload;
+    const transaction = this.#transactionService.getTransaction(request.id);
+    let eventData = {
+      id: request.id,
+      errors: [],
+      warnings: [],
+      extrinsicHash: request.id
+    };
+
+    // todo: validate type of the account
+
+    if (Object.keys(account).length === 0) {
+      throw new _BitcoinProviderError.BitcoinProviderError(_KoniTypes.BitcoinProviderErrorType.INVALID_PARAMS, 'Please connect to Wallet to try this request');
+    }
+    const pair = _uiKeyring.default.getPair(account.address);
+
+    // Unlock the pair if it is locked
+    if (pair.isLocked) {
+      _uiKeyring.default.unlockPair(pair.address);
+    }
+    const signAtIndexGenerate = signAtIndex ? (0, _util.isArray)(signAtIndex) ? signAtIndex : [signAtIndex] : [...Array(psbt.inputCount)].map((_, i) => i);
+    let psptSignedTransaction = null;
+
+    // Sign the Psbt using the pair's bitcoin object
+    try {
+      psptSignedTransaction = pair.bitcoin.signTransaction(psbt, signAtIndexGenerate, allowedSighash);
+    } catch (e) {
+      if (transaction) {
+        var _transaction$emitterT;
+        (_transaction$emitterT = transaction.emitterTransaction) === null || _transaction$emitterT === void 0 ? void 0 : _transaction$emitterT.emit('error', {
+          ...eventData,
+          errors: [new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, e.message)],
+          id: transaction.id,
+          extrinsicHash: transaction.id
+        });
+      }
+      throw new Error(e.message);
+    }
+    if (!psptSignedTransaction) {
+      throw new Error('Unable to sign');
+    }
+    if (!broadcast) {
+      for (const index of signAtIndexGenerate) {
+        psptSignedTransaction.finalizeInput(index);
+      }
+      return {
+        psbt: psptSignedTransaction.toHex()
+      };
+    }
+    if (!transaction) {
+      throw new _BitcoinProviderError.BitcoinProviderError(_KoniTypes.BitcoinProviderErrorType.INTERNAL_ERROR);
+    }
+    const {
+      chain,
+      emitterTransaction,
+      id
+    } = transaction;
+    eventData = {
+      id,
+      errors: [],
+      warnings: [],
+      extrinsicHash: id
+    };
+    if (!emitterTransaction) {
+      throw new _BitcoinProviderError.BitcoinProviderError(_KoniTypes.BitcoinProviderErrorType.INTERNAL_ERROR);
+    }
+    const chainInfo = this.#chainService.getChainInfoByKey(chain);
+    try {
+      psptSignedTransaction.finalizeAllInputs();
+    } catch (e) {
+      emitterTransaction.emit('error', {
+        ...eventData,
+        errors: [new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, e.message)]
+      });
+      throw new Error(e.message);
+    }
+    const hexTransaction = psptSignedTransaction.extractTransaction().toHex();
+    this.#transactionService.emitterEventTransaction(emitterTransaction, eventData, chainInfo.slug, hexTransaction);
+    const {
+      promise,
+      reject,
+      resolve
+    } = (0, _utils.createPromiseHandler)();
+    emitterTransaction.on('extrinsicHash', data => {
+      if (!data.extrinsicHash || !psptSignedTransaction) {
+        reject(_KoniTypes.BitcoinProviderErrorType.INTERNAL_ERROR);
+      } else {
+        var _psptSignedTransactio;
+        resolve({
+          psbt: (_psptSignedTransactio = psptSignedTransaction) === null || _psptSignedTransactio === void 0 ? void 0 : _psptSignedTransactio.toHex(),
+          txid: data.extrinsicHash
+        });
+      }
+    });
+    emitterTransaction.on('error', error => {
+      reject(error);
+    });
+    return promise;
+  }
+  async decorateResultBitcoin(t, request, result) {
+    if (t === 'bitcoinSignatureRequest') {
+      result.payload = this.signMessageBitcoin(request);
+    } else if (t === 'bitcoinSendTransactionRequest') {
+      result.payload = this.signTransactionBitcoin(request);
+    } else if (t === 'bitcoinSignPsbtRequest') {
+      result.payload = await this.signPsbt(request);
+    } else if (t === 'bitcoinSendTransactionRequestAfterConfirmation') {
+      result.payload = await this.signTransactionBitcoinWithPayload(request);
+    }
+    if (t === 'bitcoinSignatureRequest' || t === 'bitcoinSendTransactionRequest' || t === 'bitcoinSignPsbtRequest' || t === 'bitcoinSendTransactionRequestAfterConfirmation') {
+      const isAlwaysRequired = await this.#requestService.settingService.isAlwaysRequired;
+      if (isAlwaysRequired) {
+        this.#requestService.keyringService.lock();
+      }
+    }
+  }
+  async completeConfirmationBitcoin(request) {
+    const confirmations = this.confirmationsQueueSubjectBitcoin.getValue();
+    for (const ct in request) {
+      const type = ct;
+      const result = request[type];
+      const {
+        id,
+        isApproved
+      } = result;
+      const {
+        resolver,
+        validator
+      } = this.confirmationsPromiseMap[id];
+      const confirmation = confirmations[type][id];
+      if (!resolver || !confirmation) {
+        this.#logger.error((0, _i18next.t)('Unable to proceed. Please try again'), type, id);
+        throw new Error('Unable to proceed. Please try again');
+      }
+      if (isApproved) {
+        try {
+          // Fill signature for some special type
+          await this.decorateResultBitcoin(type, confirmation, result);
+          const error = validator && validator(result);
+          if (error) {
+            resolver.reject(error);
+          }
+        } catch (e) {
+          resolver.reject(e);
+        }
+      }
+
+      // Delete confirmations from queue
+      delete this.confirmationsPromiseMap[id];
+      delete confirmations[type][id];
+      this.confirmationsQueueSubjectBitcoin.next(confirmations);
+
+      // Update icon, and close queue
+      this.#requestService.updateIconV2(this.#requestService.numAllRequests === 0);
+      resolver.resolve(result);
+    }
+    return true;
+  }
+  resetWallet() {
+    const confirmations = this.confirmationsQueueSubjectBitcoin.getValue();
+    for (const [type, requests] of Object.entries(confirmations)) {
+      for (const confirmation of Object.values(requests)) {
+        const {
+          id
+        } = confirmation;
+        const {
+          resolver
+        } = this.confirmationsPromiseMap[id];
+        if (!resolver || !confirmation) {
+          console.error('Not found confirmation', type, id);
+        } else {
+          resolver.reject(new Error('Reset wallet'));
+        }
+        delete this.confirmationsPromiseMap[id];
+        delete confirmations[type][id];
+      }
+    }
+    this.confirmationsQueueSubjectBitcoin.next(confirmations);
+  }
+}
+exports.default = BitcoinRequestHandler;

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

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+var _BitcoinRequestHandler = _interopRequireDefault(require("@subwallet/extension-base/services/request-service/handler/BitcoinRequestHandler"));
 var _CardanoRequestHandler = _interopRequireDefault(require("@subwallet/extension-base/services/request-service/handler/CardanoRequestHandler"));
 var _TonRequestHandler = _interopRequireDefault(require("./handler/TonRequestHandler"));
 var _handler = require("./handler");
@@ -19,13 +20,14 @@ class RequestService {
   #authRequestHandler;
   #substrateRequestHandler;
   #evmRequestHandler;
+  #bitcoinRequestHandler;
   #tonRequestHandler;
   #cardanoRequestHandler;
   #connectWCRequestHandler;
   #notSupportWCRequestHandler;
 
   // Common
-  constructor(chainService, settingService, keyringService) {
+  constructor(chainService, settingService, keyringService, feeService, transactionService) {
     this.#chainService = chainService;
     this.settingService = settingService;
     this.keyringService = keyringService;
@@ -36,6 +38,7 @@ class RequestService {
     this.#evmRequestHandler = new _handler.EvmRequestHandler(this);
     this.#tonRequestHandler = new _TonRequestHandler.default(this);
     this.#cardanoRequestHandler = new _CardanoRequestHandler.default(this);
+    this.#bitcoinRequestHandler = new _BitcoinRequestHandler.default(this, this.#chainService, feeService, transactionService);
     this.#connectWCRequestHandler = new _handler.ConnectWCRequestHandler(this);
     this.#notSupportWCRequestHandler = new _handler.NotSupportWCRequestHandler(this);
 
@@ -43,7 +46,7 @@ class RequestService {
     this.updateIconV2();
   }
   get numAllRequests() {
-    return this.allSubstrateRequests.length + this.numEvmRequests + this.numTonRequests + this.numCardanoRequests;
+    return this.allSubstrateRequests.length + this.numEvmRequests + this.numTonRequests + this.numCardanoRequests + this.numBitcoinRequests;
   }
   updateIconV2(shouldClose) {
     this.#popupHandler.updateIconV2(shouldClose);
@@ -156,6 +159,9 @@ class RequestService {
   get numCardanoRequests() {
     return this.#cardanoRequestHandler.numCardanoRequests;
   }
+  get numBitcoinRequests() {
+    return this.#bitcoinRequestHandler.numBitcoinRequests;
+  }
   get confirmationsQueueSubject() {
     return this.#evmRequestHandler.getConfirmationsQueueSubject();
   }
@@ -201,6 +207,25 @@ class RequestService {
     return this.#evmRequestHandler.updateConfirmation(id, type, payload, options, validator);
   }
 
+  // Bitcoin requests
+
+  get confirmationsQueueSubjectBitcoin() {
+    return this.#bitcoinRequestHandler.getConfirmationsQueueSubjectBitcoin();
+  }
+  addConfirmationBitcoin(id, url, type, payload) {
+    let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+    let validator = arguments.length > 5 ? arguments[5] : undefined;
+    return this.#bitcoinRequestHandler.addConfirmationBitcoin(id, url, type, payload, options, validator);
+  }
+  async completeConfirmationBitcoin(request) {
+    return await this.#bitcoinRequestHandler.completeConfirmationBitcoin(request);
+  }
+  updateConfirmationBitcoin(id, type, payload) {
+    let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+    let validator = arguments.length > 4 ? arguments[4] : undefined;
+    return this.#bitcoinRequestHandler.updateConfirmationBitcoin(id, type, payload, options, validator);
+  }
+
   // WalletConnect Connect requests
   getConnectWCRequest(id) {
     return this.#connectWCRequestHandler.getConnectWCRequest(id);
@@ -237,7 +262,7 @@ class RequestService {
 
   // General methods
   get numRequests() {
-    return this.numMetaRequests + this.numAuthRequests + this.numSubstrateRequests + this.numEvmRequests + this.numConnectWCRequests + this.numNotSupportWCRequests + this.numTonRequests + this.numCardanoRequests;
+    return this.numMetaRequests + this.numAuthRequests + this.numSubstrateRequests + this.numEvmRequests + this.numConnectWCRequests + this.numNotSupportWCRequests + this.numTonRequests + this.numCardanoRequests + this.numBitcoinRequests;
   }
   resetWallet() {
     this.#authRequestHandler.resetWallet();
@@ -245,6 +270,7 @@ class RequestService {
     this.#evmRequestHandler.resetWallet();
     this.#tonRequestHandler.resetWallet();
     this.#cardanoRequestHandler.resetWallet();
+    this.#bitcoinRequestHandler.resetWallet();
     this.#metadataRequestHandler.resetWallet();
     this.#connectWCRequestHandler.resetWallet();
     this.#notSupportWCRequestHandler.resetWallet();

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

@@ -0,0 +1,105 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RunesService = void 0;
+var _SWError = require("@subwallet/extension-base/background/errors/SWError");
+var _constants = require("@subwallet/extension-base/services/chain-service/constants");
+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");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const BITCOIN_API_URL = 'https://btc-api.koni.studio';
+const BITCOIN_API_URL_TEST = 'https://api-testnet.openbit.app';
+class RunesService extends _apiRequestStrategy.BaseApiRequestStrategy {
+  constructor(url) {
+    const context = new _base.BaseApiRequestContext();
+    super(context);
+    this.baseUrl = url;
+  }
+  headers = {
+    'Content-Type': 'application/json',
+    Authorization: `Bearer ${_constants._BTC_SERVICE_TOKEN}`
+  };
+  isRateLimited() {
+    return false;
+  }
+  getUrl(path) {
+    return `${this.baseUrl}/${path}`;
+  }
+  getAddressRunesInfo(address, params) {
+    return this.addRequest(async () => {
+      const _rs = await (0, _utils.getRequest)(this.getUrl(`rune/address/${address}`), params, this.headers);
+      const rs = await _rs.json();
+      if (rs.status_code !== 200) {
+        throw new _SWError.SWError('RuneScanService.getAddressRunesInfo', rs.message);
+      }
+      return rs.result;
+    }, 1);
+  }
+
+  // * Deprecated
+  getRuneCollectionsByBatch(params) {
+    return this.addRequest(async () => {
+      const url = this.getUrl('rune');
+      const rs = await (0, _utils.getRequest)(url, params);
+      if (rs.status !== 200) {
+        throw new _SWError.SWError('RuneScanService.getRuneCollectionsByBatch', await rs.text());
+      }
+      return await rs.json();
+    }, 1);
+  }
+
+  // * Deprecated
+  getAddressRuneTxs(address, params) {
+    return this.addRequest(async () => {
+      const url = this.getUrl(`address/${address}/txs`);
+      const rs = await (0, _utils.getRequest)(url, params);
+      if (rs.status !== 200) {
+        throw new _SWError.SWError('RuneScanService.getAddressRuneTxs', await rs.text());
+      }
+      return await rs.json();
+    }, 0);
+  }
+  getRuneMetadata(runeid) {
+    return this.addRequest(async () => {
+      const _rs = await (0, _utils.getRequest)(this.getUrl(`rune/metadata/${runeid}`), undefined, this.headers);
+      const rs = await _rs.json();
+      if (rs.status_code !== 200) {
+        throw new _SWError.SWError('RuneScanService.getRuneMetadata', rs.message);
+      }
+      return rs.result;
+    }, 0);
+  }
+  getAddressRuneUtxos(address) {
+    return this.addRequest(async () => {
+      const _rs = await (0, _utils.getRequest)(this.getUrl(`rune/address/${address}/rune/utxo`), undefined, this.headers);
+      const rs = await _rs.json();
+      if (rs.status_code !== 200) {
+        throw new _SWError.SWError('RuneScanService.getAddressRuneUtxos', rs.message);
+      }
+      return rs.result;
+    }, 0);
+  }
+
+  // Singleton
+
+  static getInstance() {
+    let isTestnet = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    if (isTestnet) {
+      if (!RunesService.testnet) {
+        RunesService.testnet = new RunesService(BITCOIN_API_URL_TEST);
+      }
+      return RunesService.testnet;
+    } else {
+      if (!RunesService.mainnet) {
+        RunesService.mainnet = new RunesService(BITCOIN_API_URL);
+      }
+      return RunesService.mainnet;
+    }
+  }
+}
+exports.RunesService = RunesService;