@qbit-oss/api 0.0.0-stage → 0.1.0

package/lib/index.js

@@ -0,0 +1,1921 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_MAX_FEE_RATE_SAT_VB: () => DEFAULT_MAX_FEE_RATE_SAT_VB,
+  EsploraClient: () => EsploraClient,
+  MempoolQbitClient: () => MempoolQbitClient,
+  QbitApiError: () => QbitApiError,
+  addressBalanceFromStats: () => addressBalanceFromStats,
+  feeEstimatesFromMempoolRecommendedFees: () => feeEstimatesFromMempoolRecommendedFees,
+  feeTiersFromEstimates: () => feeTiersFromEstimates,
+  txidFromRawTx: () => txidFromRawTx
+});
+module.exports = __toCommonJS(index_exports);
+var import_sha256 = require("@noble/hashes/sha256");
+var unredactedCauses = /* @__PURE__ */ new WeakMap();
+var QBIT_API_ERROR_BRAND = /* @__PURE__ */ Symbol.for("qbit-js.QbitApiError");
+var QbitApiError = class extends Error {
+  /**
+   * The underlying error of `error` as the fetch implementation threw it, or
+   * undefined. Its message, stack and properties can contain the full request
+   * URL, base-URL secrets included, so it is kept off the error object, where
+   * no logger, error reporter or serializer can reach it. Do not log it where
+   * the base URL is secret.
+   */
+  static unredactedCause(error) {
+    return typeof error === "object" && error !== null ? unredactedCauses.get(error) : void 0;
+  }
+  /**
+   * Whether `value` is a `QbitApiError` (or a subclass instance) from any copy
+   * of `@qbit-oss/api`. `instanceof` only recognizes errors from the same copy,
+   * so it is false when an app loads both the CommonJS and the ESM build (or
+   * two installed versions) and the error comes from the other one. This checks
+   * a brand, `Symbol.for('qbit-js.QbitApiError')`, set on the class prototype
+   * instead. It identifies the class, not where the error came from: any code
+   * can set the brand. An error from another version can carry a `kind` this
+   * version does not list, so keep a default branch when switching on it.
+   */
+  static is(value) {
+    return typeof value === "object" && value !== null && value[QBIT_API_ERROR_BRAND] === true;
+  }
+  constructor(kind, message, options = {}) {
+    super(message);
+    this.name = "QbitApiError";
+    this.kind = kind;
+    if (options.status !== void 0) this.status = options.status;
+    if (options.url !== void 0) this.url = options.url;
+    if (options.retryAfterMs !== void 0) this.retryAfterMs = options.retryAfterMs;
+    if (options.cause !== void 0) this.cause = options.cause;
+    if (options.unredactedCause !== void 0) unredactedCauses.set(this, options.unredactedCause);
+    if (options.responseBody !== void 0) this.responseBody = options.responseBody;
+    if (options.txid !== void 0) this.txid = options.txid;
+  }
+};
+Object.defineProperty(QbitApiError.prototype, QBIT_API_ERROR_BRAND, { value: true });
+var TRANSIENT_STATUSES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+var IDEMPOTENT_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD"]);
+var UNPROCESSED_SERVER_ERROR_STATUSES = /* @__PURE__ */ new Set([501, 505, 511]);
+var PRE_CONNECTION_ERROR_CODES = /* @__PURE__ */ new Set(["ECONNREFUSED", "ENOTFOUND", "EAI_AGAIN", "UND_ERR_CONNECT_TIMEOUT"]);
+var CONNECT_STAGE_ERROR_CODES = /* @__PURE__ */ new Set(["EHOSTUNREACH", "ENETUNREACH"]);
+var TRANSPORT_ERROR_CODE_PATTERN = /^(?:E[A-Z0-9_]+|UND_ERR_[A-Z0-9_]+|HPE_[A-Z0-9_]+)$/;
+var TXID_PATTERN = /^[0-9a-f]{64}$/;
+var DEFAULT_MAX_ADDRESS_HISTORY_PAGES = 256;
+var DEFAULT_MAX_ADDRESS_HISTORY_TRANSACTIONS = 6400;
+var DEFAULT_MAX_RETRY_AFTER_MS = 3e4;
+var MAX_TIMER_DELAY_MS = 2147483647;
+var MAX_RETRIES = 10;
+var UNSAFE_BASE_URL_CHAR = /[\s\p{Cc}\\?#]|(?![\u200c\u200d])[\p{Cf}\p{Default_Ignorable_Code_Point}]/u;
+function validBaseUrl(value, allowInsecureHttp) {
+  const invalid = () => new QbitApiError(
+    "http",
+    "baseUrl must be an absolute http(s) URL without whitespace, control or format characters, backslashes, credentials, query or fragment"
+  );
+  if (typeof value !== "string" || UNSAFE_BASE_URL_CHAR.test(value)) throw invalid();
+  if (followsUrlStandard() && standardHref(value) === void 0) throw invalid();
+  const url = schemeAndHost(value);
+  if (!url || url.protocol !== "http:" && url.protocol !== "https:" || !url.hostname || url.userinfo || !/^\d*$/.test(url.port) || Number(url.port) > 65535 || /%E2%80%8[CD]|[\u200c\u200d]/i.test(url.path)) {
+    throw invalid();
+  }
+  if (url.protocol === "http:" && allowInsecureHttp !== true && !isLoopbackHostname(url.hostname)) {
+    throw new QbitApiError(
+      "http",
+      "baseUrl must use https unless its host is loopback; pass allowInsecureHttp: true to allow plain http"
+    );
+  }
+  return value.replace(/\/+$/, "");
+}
+function integerOption(value, defaultValue, name, min, max) {
+  const option = value === void 0 ? defaultValue : value;
+  if (!Number.isInteger(option) || option < min || option > max) {
+    throw new QbitApiError("http", `${name} must be an integer from ${min} to ${max}`);
+  }
+  return option;
+}
+function retryBaseDelayOption(value) {
+  const delay = value === void 0 ? 300 : value;
+  if (typeof delay !== "number" || !Number.isFinite(delay) || delay < 0 || delay > MAX_TIMER_DELAY_MS) {
+    throw new QbitApiError(
+      "http",
+      `retryBaseDelayMs must be a finite number from 0 to ${MAX_TIMER_DELAY_MS}`
+    );
+  }
+  return delay;
+}
+function defaultSleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(abortErrorFor(signal));
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(abortErrorFor(signal));
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+var internalSignals = /* @__PURE__ */ new WeakSet();
+function internalAbortController() {
+  const controller = new AbortController();
+  internalSignals.add(controller.signal);
+  return controller;
+}
+function abortErrorFor(signal) {
+  const reason = signal.reason;
+  if (internalSignals.has(signal) && reason instanceof QbitApiError) return reason;
+  return new QbitApiError("aborted", `request aborted by caller${formatErrorCause(reason)}`, {
+    cause: reason
+  });
+}
+function openOperationScope(sources, deadlineMs) {
+  if (deadlineMs !== void 0 && !(Number.isFinite(deadlineMs) && deadlineMs > 0 && deadlineMs <= MAX_TIMER_DELAY_MS)) {
+    throw new QbitApiError(
+      "http",
+      `deadlineMs must be a positive number no greater than ${MAX_TIMER_DELAY_MS}`
+    );
+  }
+  const controller = internalAbortController();
+  const cleanups = [];
+  const dispose = () => {
+    for (const cleanup of cleanups) cleanup();
+    cleanups.length = 0;
+  };
+  const abort = (error) => {
+    if (controller.signal.aborted) return;
+    controller.abort(error);
+    dispose();
+  };
+  for (const source of sources) {
+    if (source === void 0) continue;
+    if (source.aborted) {
+      abort(abortErrorFor(source));
+      break;
+    }
+    const onAbort = () => abort(abortErrorFor(source));
+    source.addEventListener("abort", onAbort, { once: true });
+    cleanups.push(() => source.removeEventListener("abort", onAbort));
+  }
+  if (deadlineMs !== void 0 && !controller.signal.aborted) {
+    const timer = setTimeout(
+      () => abort(new QbitApiError("timeout", `operation exceeded its ${deadlineMs}ms deadline`)),
+      deadlineMs
+    );
+    cleanups.push(() => clearTimeout(timer));
+  }
+  if (controller.signal.aborted) {
+    dispose();
+    throw abortErrorFor(controller.signal);
+  }
+  return { signal: controller.signal, dispose };
+}
+function raceAbort(promise, signal) {
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(abortErrorFor(signal));
+    if (signal.aborted) onAbort();
+    else signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (value) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve(value);
+      },
+      (error) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(error);
+      }
+    );
+  });
+}
+var EsploraClient = class {
+  constructor(options) {
+    /** In-flight GET de-dup: concurrent identical GETs share one request. */
+    this.inflight = /* @__PURE__ */ new Map();
+    if (!options.baseUrl) {
+      throw new QbitApiError("http", "EsploraClient requires a baseUrl");
+    }
+    const baseUrl = validBaseUrl(options.baseUrl, options.allowInsecureHttp);
+    const timeoutMs = integerOption(options.timeoutMs, 15e3, "timeoutMs", 1, MAX_TIMER_DELAY_MS);
+    const retries = integerOption(options.retries, 2, "retries", 0, MAX_RETRIES);
+    const retryBaseDelayMs = retryBaseDelayOption(options.retryBaseDelayMs);
+    const maxRetryAfterMs = integerOption(
+      options.maxRetryAfterMs,
+      DEFAULT_MAX_RETRY_AFTER_MS,
+      "maxRetryAfterMs",
+      0,
+      MAX_TIMER_DELAY_MS
+    );
+    const fetchImpl = options.fetchFn ?? globalThis.fetch;
+    if (typeof fetchImpl !== "function") {
+      throw new QbitApiError("network", "no fetch implementation available; pass options.fetchFn");
+    }
+    this.baseUrl = baseUrl;
+    this.fetchFn = options.fetchFn ? fetchImpl : fetchImpl.bind(globalThis);
+    this.timeoutMs = timeoutMs;
+    this.retries = retries;
+    this.retryBaseDelayMs = retryBaseDelayMs;
+    this.maxRetryAfterMs = maxRetryAfterMs;
+    this.headers = { ...options.headers ?? {} };
+    this.credentials = options.credentials ?? "omit";
+    this.sleepFn = options.sleepFn ?? defaultSleep;
+    this.signal = options.signal;
+  }
+  // --- esplora endpoints -------------------------------------------------
+  getAddressStats(address, options) {
+    return this.getJson(`/address/${encodeURIComponent(address)}`, options);
+  }
+  getAddressUtxos(address, options) {
+    return this.getJson(`/address/${encodeURIComponent(address)}/utxo`, options);
+  }
+  /**
+   * Confirmed transaction history for an address, newest first, 25 per page.
+   * Pass the last txid of the previous page as `afterTxid` to paginate.
+   */
+  getAddressTxs(address, afterTxid, options) {
+    const suffix = afterTxid ? `/${encodeURIComponent(afterTxid)}` : "";
+    return this.getJson(
+      `/address/${encodeURIComponent(address)}/txs/chain${suffix}`,
+      options
+    );
+  }
+  /**
+   * Unconfirmed (mempool) transactions touching an address. electrs lists at
+   * most `--rest-default-max-mempool-txs` (default 50) of them, with no way to
+   * page further; `getAddressHistory` detects that cap.
+   */
+  getAddressMempoolTxs(address, options) {
+    return this.getJson(
+      `/address/${encodeURIComponent(address)}/txs/mempool`,
+      options
+    );
+  }
+  /**
+   * Complete address history from a bounded, page-one scan. The confirmed
+   * chain route is exhausted explicitly; short pages are not assumed final.
+   *
+   * electrs answers a chain cursor it does not know (a lagging node behind a
+   * load balancer, or a reorg between pages) with HTTP 200 and `[]`, and
+   * `/txs/mempool` stops at 50 rows, so the scan alone cannot tell a short
+   * history from a complete one. The address stats are therefore read before
+   * and after the scan, each in a request of its own, and the history is
+   * returned only if both reads agree and it holds exactly
+   * `chain_stats.tx_count` confirmed and `mempool_stats.tx_count` mempool
+   * transactions. If the stats changed during the scan, the address is scanned
+   * once more; if they change again, or the counts differ, the call rejects
+   * with `invalid_cursor`. Stats without a non-negative safe-integer
+   * `tx_count` reject with `parse`. `maxPages` and `maxTransactions` cover
+   * both scans.
+   */
+  getAddressHistory(address, options = {}) {
+    return this.runOperation(options, (signal) => this.scanAddressHistory(address, options, signal));
+  }
+  async scanAddressHistory(address, options, signal) {
+    const maxPages = positiveAddressHistoryLimit(
+      options.maxPages,
+      DEFAULT_MAX_ADDRESS_HISTORY_PAGES,
+      "maxPages"
+    );
+    const maxTransactions = positiveAddressHistoryLimit(
+      options.maxTransactions,
+      DEFAULT_MAX_ADDRESS_HISTORY_TRANSACTIONS,
+      "maxTransactions"
+    );
+    const budget = createAddressHistoryBudget();
+    return verifiedAddressHistory(
+      address,
+      "esplora",
+      () => this.getJson(`/address/${encodeURIComponent(address)}`, { signal }, false),
+      () => this.scanAddressHistoryOnce(address, maxPages, maxTransactions, budget, signal)
+    );
+  }
+  async scanAddressHistoryOnce(address, maxPages, maxTransactions, budget, signal) {
+    if (budget.pageRequests >= maxPages) {
+      throw addressHistoryPageLimitError(address, maxPages, "esplora");
+    }
+    const state = createAddressHistoryScanState();
+    const mempoolRows = reserveAddressHistoryTransactions(
+      budget,
+      await this.getAddressMempoolTxs(address, { signal }),
+      maxTransactions,
+      address,
+      "esplora",
+      "esplora mempool"
+    );
+    const mempoolTxs = assertAddressHistoryPage(mempoolRows, address, "esplora mempool");
+    appendAddressHistoryTransactions(state, mempoolTxs, "mempool", address, "esplora");
+    let cursor;
+    const seenCursors = /* @__PURE__ */ new Set();
+    while (true) {
+      budget.pageRequests += 1;
+      const rows = reserveAddressHistoryTransactions(
+        budget,
+        await this.getAddressTxs(address, cursor, { signal }),
+        maxTransactions,
+        address,
+        "esplora",
+        "esplora confirmed"
+      );
+      if (rows.length === 0) break;
+      if (budget.pageRequests === maxPages) {
+        throw addressHistoryPageLimitError(address, maxPages, "esplora");
+      }
+      const txs = assertAddressHistoryPage(rows, address, "esplora confirmed");
+      cursor = nextAddressHistoryCursor(txs, cursor, seenCursors, address, "esplora");
+      appendAddressHistoryTransactions(state, txs, "confirmed", address, "esplora");
+    }
+    return { confirmed: state.confirmed, mempool: state.mempool };
+  }
+  getTx(txid, options) {
+    return this.getJson(`/tx/${encodeURIComponent(txid)}`, options);
+  }
+  /**
+   * Raw transaction hex as the backend serializes it (with witness data when
+   * the transaction has any), in lowercase. The reply is checked before it is
+   * returned: it must be non-empty, even-length hex that decodes to one
+   * complete transaction whose txid (the double SHA-256 of its
+   * witness-stripped serialization, as qbit Core computes it) is `txid`,
+   * compared case-insensitively. The transaction must be encoded as qbit
+   * Core's decoder requires: every count and length in its shortest
+   * CompactSize form and at most 0x02000000, and no witness flag when every
+   * witness stack is empty. Anything else, including the empty `200`
+   * reply mempool.qbit.org serves, throws a `parse` `QbitApiError`, so a
+   * backend cannot hand back an empty string or another transaction. Spaces,
+   * tabs and line breaks around the hex are ignored. The txid does not commit
+   * to witness data, so a reply with altered or stripped witnesses still
+   * passes; compare the wtxid if you need them.
+   */
+  async getTxHex(txid, options) {
+    const path = `/tx/${encodeURIComponent(txid)}/hex`;
+    const text = await this.getText(path, options);
+    const hex = trimAsciiWhitespace(text).toLowerCase();
+    const invalid = (reason) => new QbitApiError("parse", `transaction hex reply ${reason}`, {
+      url: this.errorUrl(path),
+      responseBody: responseBodyPreview(text, this.baseUrl)
+    });
+    if (hex === "") throw invalid("was empty");
+    if (hex.length % 2 !== 0 || !/^[0-9a-f]+$/.test(hex)) {
+      throw invalid(`was not even-length hex: ${quotedResponseText(text, this.baseUrl)}`);
+    }
+    const actual = tryTxidFromRawTx(hex);
+    if (actual === void 0) throw invalid("is not a well-formed transaction");
+    if (actual !== String(txid).toLowerCase()) throw invalid(`is transaction ${actual}, not the one requested`);
+    return hex;
+  }
+  getTxStatus(txid, options) {
+    return this.getJson(`/tx/${encodeURIComponent(txid)}/status`, options);
+  }
+  getFeeEstimates(options) {
+    return this.getJson("/fee-estimates", options);
+  }
+  async getTipHeight(options) {
+    const text = await this.getText("/blocks/tip/height", options);
+    const height = Number(text.trim());
+    if (!Number.isInteger(height)) {
+      throw new QbitApiError("parse", `tip height was not an integer: ${quotedResponseText(text, this.baseUrl)}`, {
+        url: this.errorUrl("/blocks/tip/height"),
+        responseBody: responseBodyPreview(text, this.baseUrl)
+      });
+    }
+    return height;
+  }
+  async getTipHash(options) {
+    return (await this.getText("/blocks/tip/hash", options)).trim();
+  }
+  /**
+   * Broadcast a raw transaction hex. Resolves with the txid once the node has
+   * the transaction, including when it reports the transaction as already in
+   * its mempool or chain. A submission is never re-sent after an attempt that
+   * may have reached the node: a timeout, an ambiguous network error, or a
+   * 5xx reply whose body carries no verdict from the node rejects with
+   * `unknown_outcome` carrying the txid so the caller can check
+   * `getTxStatus(txid)` before resubmitting the same hex. Only 429 replies and
+   * connection failures that happened before anything was sent are retried; a
+   * 429 whose `Retry-After` exceeds `maxRetryAfterMs` is not waited on and
+   * rejects at once as `rate_limit` with `retryAfterMs`, without a re-send.
+   * A redirect is never followed. A refused one (a 3xx, a browser opaque
+   * redirect, or a reply from a redirect the runtime followed) rejects with
+   * `unknown_outcome` too, with the `http` refusal as `cause`: the POST
+   * reached the backend, which may have accepted it before redirecting, and
+   * a runtime that followed the redirect may have re-sent it.
+   * Coded node rejections fail closed as `http` errors whatever the HTTP
+   * status, since qbit Core's own JSON-RPC server answers 500 for every RPC
+   * error and a backend or proxy may relay that status. When no txid
+   * can be derived from the hex and none is supplied, a 2xx reply resolves only
+   * if its body is itself a 64-hex txid; any other 2xx body is `unknown_outcome`.
+   * Hex `txidFromRawTx` cannot read, including encodings qbit Core refuses to
+   * decode, is still sent as it is, and the node gives the verdict.
+   * A malformed `rawTxHex` argument or an `options.txid` that is not a 64-hex
+   * transaction id matching the hex throws a `TypeError` before anything is sent.
+   *
+   * `options.signal` / `options.deadlineMs` bound the whole call. An abort or
+   * expired deadline before the POST is sent rejects with `aborted` /
+   * `timeout`; once the POST may have been sent (in flight or while its reply
+   * is read) it rejects with `unknown_outcome`, with that error as `cause`.
+   * A reply whose body stalls past `timeoutMs` or cannot be read is
+   * `unknown_outcome` too. A 429 reply is the exception throughout: it proves
+   * nothing was submitted, so one whose body is lost is retried (then
+   * `rate_limit`), and an abort or deadline during its body is definite.
+   */
+  async broadcastTx(rawTxHex, options) {
+    return this.submitTx("/tx", rawTxHex, resolveBroadcastTxid(rawTxHex, options), options);
+  }
+  // --- adapters (clean, wallet-friendly shapes) --------------------------
+  /** Confirmed + mempool balance for an address, in satoshis. */
+  async getAddressBalance(address, options) {
+    return addressBalanceFromStats(await this.getAddressStats(address, options));
+  }
+  /** Fee-rate tiers (sat/vB), ascending by confirmation target. */
+  async getFeeTiers(options) {
+    return feeTiersFromEstimates(await this.getFeeEstimates(options));
+  }
+  // --- internals ---------------------------------------------------------
+  /**
+   * Run one public call under a single signal that combines the client's
+   * signal, the caller's signal, and the caller's deadline. Pass `{ signal }`
+   * to dependent calls so they share the same cancellation and budget.
+   */
+  async runOperation(options, run) {
+    const scope = openOperationScope([this.signal, options?.signal], options?.deadlineMs);
+    try {
+      return await run(scope.signal);
+    } finally {
+      scope.dispose();
+    }
+  }
+  /**
+   * GET and parse JSON. With `dedup` false the request is sent on its own
+   * instead of joining an identical one already in flight, whose reply may
+   * predate requests this call has made since.
+   */
+  getJson(path, options, dedup = true) {
+    return this.runOperation(options, async (signal) => {
+      const response = await this.request(path, { method: "GET", dedup }, { signal });
+      const url = this.errorUrl(path);
+      const text = await readBody(response, url, this.baseUrl, signal);
+      if (!response.ok) throw httpError(response, text, url, this.baseUrl);
+      try {
+        return JSON.parse(text);
+      } catch (cause) {
+        throw new QbitApiError("parse", `failed to parse JSON from ${path}`, {
+          url,
+          responseBody: responseBodyPreview(text, this.baseUrl),
+          cause: new SyntaxError("response body is not valid JSON"),
+          unredactedCause: cause
+        });
+      }
+    });
+  }
+  getText(path, options) {
+    return this.runOperation(options, async (signal) => {
+      const response = await this.request(path, { method: "GET", dedup: true }, { signal });
+      const url = this.errorUrl(path);
+      const text = await readBody(response, url, this.baseUrl, signal);
+      if (!response.ok) throw httpError(response, text, url, this.baseUrl);
+      return text;
+    });
+  }
+  /**
+   * POST a transaction submission under the submission retry policy and
+   * classify the node's reply. `txid` identifies the submission in
+   * `unknown_outcome` errors and is the result for already-known replies.
+   * An abort or deadline once the POST may have been sent, including while
+   * the reply body is read, is an `unknown_outcome` too, unless the reply is
+   * a 429.
+   */
+  submitTx(path, body, txid, options) {
+    return this.runOperation(options, async (signal) => {
+      const url = `${this.baseUrl}${path}`;
+      const errorUrl = this.errorUrl(path);
+      const response = await this.requestWithRetry(
+        url,
+        { method: "POST", body, headers: { "content-type": "text/plain" } },
+        signal,
+        txid
+      );
+      let text;
+      try {
+        text = (await readBody(response, errorUrl, this.baseUrl, signal)).trim();
+      } catch (cause) {
+        if (response.status === 429 && signal.aborted) throw abortErrorFor(signal);
+        throw unknownOutcomeError(errorUrl, txid, `HTTP ${response.status} reply body could not be read`, {
+          status: response.status,
+          cause
+        });
+      }
+      const detail = responseBodyPreview(text, this.baseUrl);
+      const reply = httpReplyMessage(response.status, errorUrl, detail);
+      if (response.ok) {
+        const echoed = text.toLowerCase();
+        if (txid === void 0) {
+          if (TXID_PATTERN.test(echoed)) return echoed;
+        } else if (echoed === txid) {
+          return txid;
+        }
+        const reason = txid === void 0 ? "reply is not a txid" : "reply did not echo the txid";
+        throw unknownOutcomeError(errorUrl, txid, `${reason} (${reply})`, {
+          status: response.status,
+          responseBody: detail
+        });
+      }
+      if (UNPROCESSED_SERVER_ERROR_STATUSES.has(response.status)) throw httpError(response, text, errorUrl, this.baseUrl);
+      const rejection = parseBroadcastReply(text);
+      if (isAlreadyKnownBroadcastReply(rejection)) {
+        if (txid !== void 0) return txid;
+        throw unknownOutcomeError(errorUrl, void 0, `node already knows the transaction: ${reply}`, {
+          status: response.status,
+          responseBody: detail
+        });
+      }
+      if (response.status >= 500) {
+        if (isDefiniteNodeRejection(rejection)) throw httpError(response, text, errorUrl, this.baseUrl);
+        throw unknownOutcomeError(errorUrl, txid, reply, { status: response.status, responseBody: detail });
+      }
+      if (isRelayedTransportFailure(rejection)) {
+        throw unknownOutcomeError(errorUrl, txid, `backend lost its node connection (${reply})`, {
+          status: response.status,
+          responseBody: detail
+        });
+      }
+      throw httpError(response, text, errorUrl, this.baseUrl);
+    });
+  }
+  request(path, init, options) {
+    return this.runOperation(options, (signal) => {
+      const url = `${this.baseUrl}${path}`;
+      return init.dedup ? this.requestShared(url, init, signal) : this.requestWithRetry(url, init, signal);
+    });
+  }
+  /**
+   * Concurrent identical GETs share one request. One caller giving up only
+   * stops waiting; the shared request is aborted once every caller has left.
+   */
+  async requestShared(url, init, signal) {
+    let pending = this.inflight.get(url);
+    if (pending === void 0) {
+      const controller = internalAbortController();
+      pending = {
+        response: this.requestWithRetry(url, init, controller.signal),
+        consumers: 0,
+        controller
+      };
+      this.inflight.set(url, pending);
+    }
+    pending.consumers += 1;
+    let response;
+    try {
+      response = await raceAbort(pending.response, signal);
+    } catch (error) {
+      pending.consumers -= 1;
+      if (pending.consumers === 0) {
+        if (this.inflight.get(url) === pending) this.inflight.delete(url);
+        if (signal.aborted) {
+          const errorUrl = redactBaseUrl(url, this.baseUrl);
+          pending.controller.abort(new QbitApiError("aborted", `request abandoned: ${errorUrl}`, { url: errorUrl }));
+          pending.response.then(discardResponseBody, () => void 0);
+        }
+      }
+      throw error;
+    }
+    pending.consumers -= 1;
+    if (pending.consumers === 0) {
+      if (this.inflight.get(url) === pending) this.inflight.delete(url);
+      return response;
+    }
+    return response.clone();
+  }
+  /**
+   * Idempotent requests (GET/HEAD) retry on network errors, timeouts, and
+   * transient statuses. Any other method is a submission: an attempt is only
+   * repeated when it provably never reached the server (429, or a connection
+   * failure before anything was sent), and an attempt that may have been
+   * processed fails with `unknown_outcome` instead of being re-sent; that
+   * includes an abort or deadline that fires while a submission is in flight,
+   * and a refused redirect. `txid` labels that error when the submission is a
+   * transaction.
+   */
+  async requestWithRetry(url, init, signal, txid) {
+    const idempotent = IDEMPOTENT_METHODS.has(init.method.toUpperCase());
+    const errorUrl = redactBaseUrl(url, this.baseUrl);
+    let lastError;
+    for (let attempt = 0; attempt <= this.retries; attempt += 1) {
+      if (signal.aborted) throw abortErrorFor(signal);
+      const reply = {};
+      let response;
+      try {
+        response = await this.fetchOnce(url, init, signal, reply);
+      } catch (error) {
+        lastError = QbitApiError.is(error) ? error : new QbitApiError("network", redactBaseUrl(String(error), this.baseUrl), {
+          url: errorUrl,
+          ...causeOptions(error, this.baseUrl)
+        });
+        if (!idempotent && reply.refusedRedirect) {
+          throw unknownOutcomeError(errorUrl, txid, lastError.message, {
+            ...lastError.status === void 0 ? {} : { status: lastError.status },
+            cause: lastError
+          });
+        }
+        if (!idempotent && reply.status === 429) {
+          if (signal.aborted) throw abortErrorFor(signal);
+          const { retryAfterMs } = reply;
+          if (attempt < this.retries && (retryAfterMs === void 0 || retryAfterMs <= this.maxRetryAfterMs)) {
+            await this.sleep(retryAfterMs ?? this.backoffMs(attempt), signal);
+            continue;
+          }
+          throw new QbitApiError("rate_limit", `HTTP 429 from ${errorUrl} (reply body could not be read)`, {
+            status: 429,
+            url: errorUrl,
+            cause: lastError,
+            ...retryAfterMs === void 0 ? {} : { retryAfterMs }
+          });
+        }
+        if (!idempotent && reply.status !== void 0) {
+          throw unknownOutcomeError(errorUrl, txid, `HTTP ${reply.status} reply body could not be read`, {
+            status: reply.status,
+            cause: lastError
+          });
+        }
+        if (idempotent && lastError.kind === "parse" && reply.status !== void 0 && TRANSIENT_STATUSES.has(reply.status)) {
+          const { retryAfterMs } = reply;
+          const overCap = retryAfterMs !== void 0 && retryAfterMs > this.maxRetryAfterMs;
+          if (attempt < this.retries && !overCap && !signal.aborted) {
+            await this.sleep(retryAfterMs ?? this.backoffMs(attempt), signal);
+            continue;
+          }
+          throw lastError;
+        }
+        if (lastError.kind !== "network" && lastError.kind !== "timeout" && lastError.kind !== "aborted") {
+          throw lastError;
+        }
+        const unsent = idempotent || lastError.kind === "network" && lastError instanceof QbitApiError && isPreConnectionFailure(QbitApiError.unredactedCause(lastError) ?? lastError);
+        if (!unsent) {
+          const reason = redactBaseUrl(String(lastError.message), this.baseUrl);
+          throw unknownOutcomeError(errorUrl, txid, reason, { cause: lastError });
+        }
+        if (lastError.kind !== "aborted" && attempt < this.retries && !signal.aborted) {
+          await this.sleep(this.backoffMs(attempt), signal);
+          continue;
+        }
+        throw lastError;
+      }
+      const retryable = idempotent ? TRANSIENT_STATUSES.has(response.status) : response.status === 429;
+      if (retryable && attempt < this.retries) {
+        const retryAfterMs = parseRetryAfter(response.headers.get("retry-after"));
+        if (retryAfterMs !== void 0 && retryAfterMs > this.maxRetryAfterMs) return response;
+        void discardResponseBody(response);
+        await this.sleep(retryAfterMs ?? this.backoffMs(attempt), signal);
+        continue;
+      }
+      return response;
+    }
+    throw lastError ?? new QbitApiError("network", `request failed: ${errorUrl}`, { url: errorUrl });
+  }
+  /** Backoff that rejects as soon as `signal` aborts, even if `sleepFn` ignores it. */
+  async sleep(ms, signal) {
+    if (signal.aborted) throw abortErrorFor(signal);
+    await raceAbort(
+      Promise.resolve().then(() => this.sleepFn(ms, signal)),
+      signal
+    );
+  }
+  /**
+   * One attempt under one timeout that spans the headers and the whole body,
+   * also bounded by the call's signal until the body is buffered. Every
+   * response it returns is fully buffered, whatever its status, so no caller
+   * (retry loop, de-duplicated clone, or error path) can block on the network
+   * after the timer is cleared. A body that misses the attempt timeout fails
+   * the attempt as `timeout`, even for a status that would otherwise be
+   * retried; an abort or call deadline, before or after the headers, rejects
+   * with the call's `aborted` / `timeout` error. `reply.status` is set once
+   * the headers arrive. A redirect is refused before its body is read, which
+   * is cancelled instead, and `reply.refusedRedirect` is set; see
+   * `refuseRedirect`.
+   */
+  async fetchOnce(url, init, signal, reply) {
+    if (signal.aborted) throw abortErrorFor(signal);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    const onAbort = () => controller.abort(signal.reason);
+    signal.addEventListener("abort", onAbort, { once: true });
+    const requestInit = {
+      method: init.method,
+      headers: { ...this.headers, ...init.headers ?? {} },
+      mode: "cors",
+      redirect: "manual",
+      credentials: this.credentials,
+      signal: controller.signal
+    };
+    if (init.body !== void 0) requestInit.body = init.body;
+    let pending;
+    try {
+      let response;
+      try {
+        pending = this.fetchFn(url, requestInit);
+        response = await raceAbort(pending, signal);
+      } catch (cause) {
+        if (signal.aborted) {
+          pending?.then(discardResponseBody, () => void 0);
+          throw abortErrorFor(signal);
+        }
+        if (QbitApiError.is(cause)) throw cause;
+        if (isAbortError(cause)) throw this.timeoutError(url, cause);
+        const errorUrl = redactBaseUrl(url, this.baseUrl);
+        throw new QbitApiError("network", `network error: ${errorUrl}${redactBaseUrl(formatErrorCause(cause), this.baseUrl)}`, {
+          url: errorUrl,
+          ...causeOptions(cause, this.baseUrl)
+        });
+      }
+      try {
+        refuseRedirect(response, url, this.baseUrl);
+      } catch (refusal) {
+        reply.refusedRedirect = true;
+        throw refusal;
+      }
+      reply.status = response.status;
+      const retryAfterMs = parseRetryAfter(response.headers.get("retry-after"));
+      if (retryAfterMs !== void 0) reply.retryAfterMs = retryAfterMs;
+      let text;
+      try {
+        text = await readBodyUntilAborted(response, controller.signal);
+      } catch (cause) {
+        if (signal.aborted) throw abortErrorFor(signal);
+        if (controller.signal.aborted) throw this.timeoutError(url, cause, response.status);
+        throw bodyReadError(response, cause, redactBaseUrl(url, this.baseUrl), this.baseUrl);
+      }
+      return bufferedResponse(response, text);
+    } finally {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", onAbort);
+    }
+  }
+  /** `status` is set when the headers arrived and the body missed the deadline. */
+  timeoutError(url, cause, status) {
+    const errorUrl = redactBaseUrl(url, this.baseUrl);
+    return new QbitApiError(
+      "timeout",
+      `request timed out after ${this.timeoutMs}ms: ${errorUrl}${redactBaseUrl(formatErrorCause(cause), this.baseUrl)}`,
+      { url: errorUrl, ...causeOptions(cause, this.baseUrl), ...status === void 0 ? {} : { status } }
+    );
+  }
+  backoffMs(attempt) {
+    return Math.min(this.retryBaseDelayMs * 2 ** attempt, MAX_TIMER_DELAY_MS);
+  }
+  /** The request URL for `path` as errors show it: see `redactedBaseUrl`. */
+  errorUrl(path) {
+    return `${redactedBaseUrl(this.baseUrl)}${path}`;
+  }
+};
+var MEMPOOL_QBIT_ADDRESS_PAGE_SIZE = 10;
+var MempoolQbitClient = class extends EsploraClient {
+  constructor(options) {
+    super(options);
+    const maxAddressHistoryPages = options.maxAddressHistoryPages ?? DEFAULT_MAX_ADDRESS_HISTORY_PAGES;
+    if (!Number.isSafeInteger(maxAddressHistoryPages) || maxAddressHistoryPages < 1) {
+      throw new QbitApiError("http", "maxAddressHistoryPages must be a positive integer");
+    }
+    this.maxAddressHistoryPages = maxAddressHistoryPages;
+  }
+  /**
+   * Complete address history from one bounded traversal of mempool-qbit's
+   * combined endpoint. Page size is intentionally not assumed.
+   *
+   * The result is checked against the address stats, read before and after
+   * the traversal, as `EsploraClient.getAddressHistory` describes, and a
+   * traversal during which they changed is repeated once. qbit-electrs
+   * answers a cursor that is the last mempool row with `[]` instead of the
+   * confirmed rows that follow, so an address whose mempool rows fill whole
+   * pages (50 each by default) rejects with `invalid_cursor` while it has
+   * confirmed history, rather than returning none.
+   */
+  getAddressHistory(address, options = {}) {
+    return this.runOperation(
+      options,
+      (signal) => this.scanCombinedAddressHistory(address, options, signal)
+    );
+  }
+  async scanCombinedAddressHistory(address, options, signal) {
+    const requestedMaxPages = positiveAddressHistoryLimit(
+      options.maxPages,
+      this.maxAddressHistoryPages,
+      "maxPages"
+    );
+    const maxPages = Math.min(requestedMaxPages, this.maxAddressHistoryPages);
+    const maxTransactions = positiveAddressHistoryLimit(
+      options.maxTransactions,
+      DEFAULT_MAX_ADDRESS_HISTORY_TRANSACTIONS,
+      "maxTransactions"
+    );
+    const budget = createAddressHistoryBudget();
+    return verifiedAddressHistory(
+      address,
+      "mempool-qbit",
+      () => this.getJson(`/address/${encodeURIComponent(address)}`, { signal }, false),
+      () => this.scanCombinedAddressHistoryOnce(address, maxPages, maxTransactions, budget, signal)
+    );
+  }
+  async scanCombinedAddressHistoryOnce(address, maxPages, maxTransactions, budget, signal) {
+    if (budget.pageRequests >= maxPages) {
+      throw this.addressHistoryPaginationLimitError(address, maxPages);
+    }
+    const state = createAddressHistoryScanState();
+    let cursor;
+    const seenCursors = /* @__PURE__ */ new Set();
+    while (true) {
+      budget.pageRequests += 1;
+      const suffix = cursor ? `?after_txid=${encodeURIComponent(cursor)}` : "";
+      const rows = reserveAddressHistoryTransactions(
+        budget,
+        await this.getJson(`/address/${encodeURIComponent(address)}/txs${suffix}`, {
+          signal
+        }),
+        maxTransactions,
+        address,
+        "mempool-qbit",
+        "mempool-qbit combined"
+      );
+      if (rows.length === 0) break;
+      if (budget.pageRequests === maxPages) {
+        throw this.addressHistoryPaginationLimitError(address, maxPages);
+      }
+      const txs = assertAddressHistoryPage(rows, address, "mempool-qbit combined");
+      cursor = nextAddressHistoryCursor(txs, cursor, seenCursors, address, "mempool-qbit");
+      appendAddressHistoryTransactions(state, txs, "combined", address, "mempool-qbit");
+    }
+    return { confirmed: state.confirmed, mempool: state.mempool };
+  }
+  /**
+   * Confirmed transaction history for an address, newest first.
+   * mempool-qbit paginates combined history with `?after_txid=...` and sorts
+   * mempool entries first, so full mempool-only pages must still advance.
+   * Without `afterTxid`, an empty page right after a mempool row is checked
+   * against the address stats: qbit-electrs answers that cursor with `[]`
+   * instead of the confirmed rows that follow, so the call rejects with
+   * `invalid_cursor` if the stats count more confirmed transactions than it
+   * found.
+   */
+  getAddressTxs(address, afterTxid, options) {
+    return this.runOperation(options, (signal) => this.scanAddressTxs(address, afterTxid, signal));
+  }
+  async scanAddressTxs(address, afterTxid, signal) {
+    const confirmedTxs = [];
+    let cursor;
+    let continuationFound = afterTxid === void 0;
+    let cursorIsMempoolTx = false;
+    const seenCursors = /* @__PURE__ */ new Set();
+    const seenTxids = /* @__PURE__ */ new Set();
+    let pageCount = 0;
+    while (confirmedTxs.length < 25) {
+      if (pageCount >= this.maxAddressHistoryPages) {
+        throw this.addressHistoryPaginationLimitError(address);
+      }
+      pageCount += 1;
+      const suffix = cursor ? `?after_txid=${encodeURIComponent(cursor)}` : "";
+      const txs = await this.getJson(
+        `/address/${encodeURIComponent(address)}/txs${suffix}`,
+        { signal }
+      );
+      if (txs.length === 0) {
+        if (!continuationFound) throw this.invalidAddressHistoryCursorError(address, afterTxid);
+        if (afterTxid === void 0 && cursorIsMempoolTx) {
+          await this.assertConfirmedHistoryReached(address, confirmedTxs.length, signal);
+        }
+        break;
+      }
+      for (const tx of txs) {
+        if (!continuationFound) {
+          if (isConfirmedTx(tx)) seenTxids.add(tx.txid);
+          if (tx.txid !== afterTxid) continue;
+          if (!isConfirmedTx(tx)) {
+            throw this.invalidAddressHistoryCursorError(address, afterTxid);
+          }
+          continuationFound = true;
+          continue;
+        }
+        if (isConfirmedTx(tx) && !seenTxids.has(tx.txid)) {
+          confirmedTxs.push(tx);
+          seenTxids.add(tx.txid);
+        }
+      }
+      const nextCursor = txs[txs.length - 1]?.txid;
+      if (confirmedTxs.length >= 25) break;
+      if (txs.length < MEMPOOL_QBIT_ADDRESS_PAGE_SIZE) {
+        if (!continuationFound) throw this.invalidAddressHistoryCursorError(address, afterTxid);
+        break;
+      }
+      if (!nextCursor || nextCursor === cursor || seenCursors.has(nextCursor)) {
+        if (!continuationFound) throw this.invalidAddressHistoryCursorError(address, afterTxid);
+        throw this.nonAdvancingAddressHistoryCursorError(address, nextCursor ?? cursor);
+      }
+      seenCursors.add(nextCursor);
+      cursor = nextCursor;
+      cursorIsMempoolTx = !isConfirmedTx(txs[txs.length - 1]);
+    }
+    return confirmedTxs.slice(0, 25);
+  }
+  /**
+   * qbit-electrs's combined route answers an `after_txid` that is the last
+   * mempool row with `[]`, not the confirmed rows that follow: it passes the
+   * mempool txid on as the chain cursor, which `history()` never finds
+   * (`src/rest.rs:992-998` in Qbit-Org/qbit-electrs@53102e9). Reject that
+   * empty page when the address stats count confirmed transactions the scan
+   * has not seen.
+   */
+  async assertConfirmedHistoryReached(address, confirmedSeen, signal) {
+    const stats = addressHistoryStats(
+      await this.getJson(`/address/${encodeURIComponent(address)}`, { signal }, false),
+      address,
+      "mempool-qbit"
+    );
+    if (stats.chain_stats.tx_count > confirmedSeen) {
+      throw new QbitApiError(
+        "invalid_cursor",
+        `mempool-qbit combined history ended after a mempool transaction with ${confirmedSeen} of ${stats.chain_stats.tx_count} confirmed transactions: ${address}`
+      );
+    }
+  }
+  /**
+   * mempool-qbit does not expose `/txs/mempool`. Page through the combined
+   * history until confirmed entries begin, collecting the leading mempool set.
+   */
+  getAddressMempoolTxs(address, options) {
+    return this.runOperation(options, (signal) => this.scanAddressMempoolTxs(address, signal));
+  }
+  async scanAddressMempoolTxs(address, signal) {
+    const mempoolTxs = [];
+    let cursor;
+    const seenCursors = /* @__PURE__ */ new Set();
+    const seenTxids = /* @__PURE__ */ new Set();
+    let pageCount = 0;
+    while (true) {
+      if (pageCount >= this.maxAddressHistoryPages) {
+        throw this.addressHistoryPaginationLimitError(address);
+      }
+      pageCount += 1;
+      const suffix = cursor ? `?after_txid=${encodeURIComponent(cursor)}` : "";
+      const txs = await this.getJson(
+        `/address/${encodeURIComponent(address)}/txs${suffix}`,
+        { signal }
+      );
+      if (txs.length === 0) break;
+      for (const tx of txs) {
+        if (!isConfirmedTx(tx) && !seenTxids.has(tx.txid)) {
+          mempoolTxs.push(tx);
+          seenTxids.add(tx.txid);
+        }
+      }
+      const nextCursor = txs[txs.length - 1]?.txid;
+      if (txs.some(isConfirmedTx) || txs.length < MEMPOOL_QBIT_ADDRESS_PAGE_SIZE) break;
+      if (!nextCursor || nextCursor === cursor || seenCursors.has(nextCursor)) {
+        throw this.nonAdvancingAddressHistoryCursorError(address, nextCursor ?? cursor);
+      }
+      seenCursors.add(nextCursor);
+      cursor = nextCursor;
+    }
+    return mempoolTxs;
+  }
+  getMempoolRecommendedFees(options) {
+    return this.getJson("/fees/recommended", options);
+  }
+  async getFeeEstimates(options) {
+    return feeEstimatesFromMempoolRecommendedFees(await this.getMempoolRecommendedFees(options));
+  }
+  /**
+   * Broadcast via `/tx`, falling back to the `/tx/push` form route only when
+   * `/tx` reported that it did not submit the transaction. The fallback is a
+   * second submission, so it follows the same policy: an already-known reply
+   * resolves with the txid and an uncertain attempt rejects with
+   * `unknown_outcome`. An uncertain `/tx` attempt never falls back.
+   *
+   * One signal and deadline cover both requests, with the same abort rules as
+   * `EsploraClient.broadcastTx`. An abort or expired deadline during `/tx`
+   * never sends the `/tx/push` fallback.
+   */
+  async broadcastTx(rawTxHex, options) {
+    const txid = resolveBroadcastTxid(rawTxHex, options);
+    return this.runOperation(options, async (signal) => {
+      try {
+        return await this.submitTx("/tx", rawTxHex, txid, { signal });
+      } catch (error) {
+        if (!shouldRetryBroadcastViaTxPush(error)) {
+          throw error;
+        }
+        return this.submitTx("/tx/push", `txHash=${rawTxHex}`, txid, { signal });
+      }
+    });
+  }
+  addressHistoryPaginationLimitError(address, maxPages = this.maxAddressHistoryPages) {
+    return new QbitApiError(
+      "pagination_limit",
+      `mempool-qbit address history exceeded ${maxPages} pages: ${address}`
+    );
+  }
+  invalidAddressHistoryCursorError(address, afterTxid) {
+    return new QbitApiError(
+      "invalid_cursor",
+      `mempool-qbit address history cursor is stale or not confirmed: ${afterTxid} (${address})`
+    );
+  }
+  nonAdvancingAddressHistoryCursorError(address, cursor) {
+    return new QbitApiError(
+      "invalid_cursor",
+      `mempool-qbit address history cursor stopped advancing: ${quotedResponseText(String(cursor ?? "(missing)"), this.baseUrl)} (${address})`
+    );
+  }
+};
+function addressBalanceFromStats(stats) {
+  if (!isRecord(stats) || typeof stats.address !== "string" || !hasSafeTxoSums(stats.chain_stats) || !hasSafeTxoSums(stats.mempool_stats)) {
+    throw new QbitApiError("parse", "address stats lacked a string address or non-negative safe-integer funded/spent sums");
+  }
+  const confirmedSats = stats.chain_stats.funded_txo_sum - stats.chain_stats.spent_txo_sum;
+  const mempoolSats = stats.mempool_stats.funded_txo_sum - stats.mempool_stats.spent_txo_sum;
+  const totalSats = confirmedSats + mempoolSats;
+  if (confirmedSats < 0 || !isSafeSatAmount(totalSats)) {
+    throw new QbitApiError("parse", "address stats implied a negative or unsafe balance");
+  }
+  return {
+    address: stats.address,
+    confirmedSats,
+    mempoolSats,
+    totalSats
+  };
+}
+var DEFAULT_MAX_FEE_RATE_SAT_VB = 1e4;
+var MAX_FEE_ESTIMATE_TARGET = 1008;
+function isPositiveFeeRate(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function isSafeSatAmount(value) {
+  return Number.isSafeInteger(value) && value >= 0;
+}
+function hasSafeTxoSums(value) {
+  return isRecord(value) && isSafeSatAmount(value["funded_txo_sum"]) && isSafeSatAmount(value["spent_txo_sum"]);
+}
+function feeEstimatesFromMempoolRecommendedFees(fees) {
+  if (!isRecord(fees)) {
+    throw new QbitApiError("parse", "mempool-qbit recommended fees were not a JSON object");
+  }
+  for (const field of ["fastestFee", "halfHourFee", "hourFee"]) {
+    if (!isPositiveFeeRate(fees[field])) {
+      throw new QbitApiError("parse", `mempool-qbit recommended fees had an invalid ${field}`);
+    }
+  }
+  return {
+    "1": fees.fastestFee,
+    "2": fees.halfHourFee,
+    "3": fees.hourFee
+  };
+}
+function feeTiersFromEstimates(estimates, options = {}) {
+  const maxFeeRate = options.maxFeeRate ?? DEFAULT_MAX_FEE_RATE_SAT_VB;
+  if (!isPositiveFeeRate(maxFeeRate)) {
+    throw new TypeError("maxFeeRate must be a finite number above 0");
+  }
+  if (!isRecord(estimates)) {
+    throw new QbitApiError("parse", "fee estimates were not a JSON object");
+  }
+  return Object.entries(estimates).map(([key, feeRate]) => {
+    const target = Number(key);
+    if (!/^[1-9]\d*$/.test(key) || target > MAX_FEE_ESTIMATE_TARGET) {
+      throw new QbitApiError(
+        "parse",
+        `fee estimates had a confirmation target that is not a decimal block count from 1 to ${MAX_FEE_ESTIMATE_TARGET}`
+      );
+    }
+    if (!isPositiveFeeRate(feeRate) || feeRate > maxFeeRate) {
+      throw new QbitApiError(
+        "parse",
+        `fee estimate for target ${target} was not a finite rate above 0 and at most ${maxFeeRate} sat/vB`
+      );
+    }
+    return { target, feeRate };
+  }).sort((a, b) => a.target - b.target);
+}
+function txidFromRawTx(rawTxHex) {
+  const txid = tryTxidFromRawTx(rawTxHex);
+  if (txid === void 0) {
+    throw new QbitApiError("parse", "raw transaction hex is not a well-formed transaction");
+  }
+  return txid;
+}
+function trimAsciiWhitespace(text) {
+  let start = 0;
+  let end = text.length;
+  while (start < end && isAsciiWhitespace(text.charCodeAt(start))) start += 1;
+  while (end > start && isAsciiWhitespace(text.charCodeAt(end - 1))) end -= 1;
+  return text.slice(start, end);
+}
+function isAsciiWhitespace(code) {
+  return code === 32 || code === 9 || code === 10 || code === 13;
+}
+function tryTxidFromRawTx(rawTxHex) {
+  const bytes = hexToBytes(rawTxHex);
+  const stripped = bytes === void 0 ? void 0 : witnessStrippedTx(bytes);
+  if (stripped === void 0) return void 0;
+  return bytesToHex((0, import_sha256.sha256)((0, import_sha256.sha256)(stripped)).reverse());
+}
+function resolveBroadcastTxid(rawTxHex, options) {
+  if (typeof rawTxHex !== "string") {
+    throw new TypeError("broadcastTx: rawTxHex must be a hex string");
+  }
+  const requested = (options ?? {}).txid;
+  const derived = tryTxidFromRawTx(rawTxHex);
+  if (requested === void 0) return derived;
+  const provided = typeof requested === "string" ? requested.toLowerCase() : "";
+  if (!TXID_PATTERN.test(provided)) {
+    throw new TypeError("broadcastTx: options.txid must be a 64-character hex transaction id");
+  }
+  if (derived !== void 0 && derived !== provided) {
+    throw new TypeError(
+      `broadcastTx: options.txid ${provided} does not match the transaction hex (${derived})`
+    );
+  }
+  return provided;
+}
+var COMPACT_SIZE_MAX = 33554432;
+var RawTxReader = class {
+  constructor(bytes) {
+    this.bytes = bytes;
+    this.offset = 0;
+  }
+  get position() {
+    return this.offset;
+  }
+  get remaining() {
+    return this.bytes.length - this.offset;
+  }
+  skip(length) {
+    if (length > this.remaining) throw new RangeError("raw transaction is truncated");
+    this.offset += length;
+  }
+  readUint8() {
+    this.skip(1);
+    return this.bytes[this.offset - 1];
+  }
+  /**
+   * qbit Core `ReadCompactSize` with its default range check (serialize.h:330
+   * at v1.0.0). Only the shortest encoding of a value is valid: a `fd` prefix
+   * must carry at least 0xfd, `fe` at least 0x10000 and `ff` at least
+   * 0x100000000, or Core throws `non-canonical ReadCompactSize()`. A value
+   * above MAX_SIZE (serialize.h:32) fails `size too large`, so every `ff`
+   * encoding fails one check or the other. Core reads every count and length
+   * in a transaction this way, witness stacks included.
+   */
+  readCompactSize() {
+    const first = this.readUint8();
+    if (first < 253) return first;
+    const width = first === 253 ? 2 : first === 254 ? 4 : 8;
+    let value = 0;
+    for (let i = 0; i < width; i += 1) value += this.readUint8() * 2 ** (8 * i);
+    const minimum = first === 253 ? 253 : first === 254 ? 65536 : 2 ** 32;
+    if (value < minimum) throw new RangeError("raw transaction has a non-canonical CompactSize");
+    if (value > COMPACT_SIZE_MAX) throw new RangeError("raw transaction length is too large");
+    return value;
+  }
+  skipVarBytes() {
+    this.skip(this.readCompactSize());
+  }
+};
+function witnessStrippedTx(bytes) {
+  const reader = new RawTxReader(bytes);
+  try {
+    reader.skip(4);
+    const witness = reader.remaining >= 2 && bytes[4] === 0;
+    if (witness) {
+      if (bytes[5] !== 1) return void 0;
+      reader.skip(2);
+    }
+    const bodyStart = reader.position;
+    const inputCount = reader.readCompactSize();
+    for (let i = 0; i < inputCount; i += 1) {
+      reader.skip(36);
+      reader.skipVarBytes();
+      reader.skip(4);
+    }
+    const outputCount = reader.readCompactSize();
+    for (let i = 0; i < outputCount; i += 1) {
+      reader.skip(8);
+      reader.skipVarBytes();
+    }
+    const bodyEnd = reader.position;
+    if (witness) {
+      let hasWitness = false;
+      for (let i = 0; i < inputCount; i += 1) {
+        const items = reader.readCompactSize();
+        if (items > 0) hasWitness = true;
+        for (let j = 0; j < items; j += 1) reader.skipVarBytes();
+      }
+      if (!hasWitness) return void 0;
+    }
+    reader.skip(4);
+    if (reader.remaining !== 0) return void 0;
+    if (!witness) return bytes;
+    const stripped = new Uint8Array(4 + (bodyEnd - bodyStart) + 4);
+    stripped.set(bytes.subarray(0, 4), 0);
+    stripped.set(bytes.subarray(bodyStart, bodyEnd), 4);
+    stripped.set(bytes.subarray(bytes.length - 4), stripped.length - 4);
+    return stripped;
+  } catch {
+    return void 0;
+  }
+}
+function hexToBytes(hex) {
+  if (hex.length % 2 !== 0 || !/^[0-9a-fA-F]*$/.test(hex)) return void 0;
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < bytes.length; i += 1) {
+    bytes[i] = parseInt(hex.slice(2 * i, 2 * i + 2), 16);
+  }
+  return bytes;
+}
+function bytesToHex(bytes) {
+  let hex = "";
+  for (const byte of bytes) hex += byte.toString(16).padStart(2, "0");
+  return hex;
+}
+function createAddressHistoryScanState() {
+  return {
+    confirmed: [],
+    mempool: [],
+    seenTxids: /* @__PURE__ */ new Set()
+  };
+}
+function createAddressHistoryBudget() {
+  return { pageRequests: 0, rawTransactions: 0 };
+}
+var MAX_ADDRESS_HISTORY_RESCANS = 1;
+var ADDRESS_STATS_FIELDS = [
+  "funded_txo_count",
+  "funded_txo_sum",
+  "spent_txo_count",
+  "spent_txo_sum",
+  "tx_count"
+];
+async function verifiedAddressHistory(address, backend, readStats, scan) {
+  let before = addressHistoryStats(await readStats(), address, backend);
+  for (let scans = 1; ; scans += 1) {
+    const history = await scan();
+    const after = addressHistoryStats(await readStats(), address, backend);
+    if (!sameAddressHistoryStats(before, after)) {
+      if (scans > MAX_ADDRESS_HISTORY_RESCANS) {
+        throw new QbitApiError(
+          "invalid_cursor",
+          `${backend} address stats changed during each of ${scans} history scans: ${address}`
+        );
+      }
+      before = after;
+      continue;
+    }
+    const confirmed = after.chain_stats.tx_count;
+    const mempool = after.mempool_stats.tx_count;
+    if (history.confirmed.length !== confirmed || history.mempool.length !== mempool) {
+      throw new QbitApiError(
+        "invalid_cursor",
+        `${backend} address history returned ${history.confirmed.length} confirmed and ${history.mempool.length} mempool transactions, but the address stats count ${confirmed} and ${mempool}: ${address}`
+      );
+    }
+    return history;
+  }
+}
+function addressHistoryStats(value, address, backend) {
+  if (!isRecord(value) || !hasTxCount(value["chain_stats"]) || !hasTxCount(value["mempool_stats"])) {
+    throw new QbitApiError(
+      "parse",
+      `${backend} address stats lacked a non-negative safe-integer chain or mempool tx_count: ${address}`
+    );
+  }
+  return value;
+}
+function hasTxCount(value) {
+  return isRecord(value) && Number.isSafeInteger(value["tx_count"]) && value["tx_count"] >= 0;
+}
+function sameAddressHistoryStats(a, b) {
+  return ADDRESS_STATS_FIELDS.every(
+    (field) => a.chain_stats[field] === b.chain_stats[field] && a.mempool_stats[field] === b.mempool_stats[field]
+  );
+}
+function positiveAddressHistoryLimit(value, defaultValue, name) {
+  const limit = value ?? defaultValue;
+  if (!Number.isSafeInteger(limit) || limit < 1) {
+    throw new QbitApiError("http", `${name} must be a positive integer`);
+  }
+  return limit;
+}
+function assertAddressHistoryPage(value, address, source) {
+  value.forEach((tx, index) => {
+    const status = isRecord(tx) ? tx["status"] : void 0;
+    const vin = isRecord(tx) ? tx["vin"] : void 0;
+    const vout = isRecord(tx) ? tx["vout"] : void 0;
+    if (!isRecord(tx) || typeof tx["txid"] !== "string" || !/^[0-9a-f]{64}$/i.test(tx["txid"]) || !isRecord(status) || typeof status["confirmed"] !== "boolean" || !Array.isArray(vin) || !vin.every(isRecord) || !Array.isArray(vout) || !vout.every(isRecord)) {
+      throw new QbitApiError(
+        "parse",
+        `${source} address history transaction ${index} had an invalid txid, status, vin, or vout: ${address}`
+      );
+    }
+    const spendsFromAddress = vin.some(
+      (input) => isRecord(input) && isRecord(input["prevout"]) && addressHistoryAddressMatches(input["prevout"]["scriptpubkey_address"], address)
+    );
+    const paysToAddress = vout.some(
+      (output) => isRecord(output) && addressHistoryAddressMatches(output["scriptpubkey_address"], address)
+    );
+    if (!spendsFromAddress && !paysToAddress) {
+      throw new QbitApiError(
+        "parse",
+        `${source} address history transaction ${index} did not touch ${address}`
+      );
+    }
+  });
+  return value;
+}
+function reserveAddressHistoryTransactions(budget, value, maxTransactions, address, backend, source) {
+  if (!Array.isArray(value)) {
+    throw new QbitApiError("parse", `${source} address history was not an array: ${address}`);
+  }
+  budget.rawTransactions += value.length;
+  if (budget.rawTransactions > maxTransactions) {
+    throw new QbitApiError(
+      "pagination_limit",
+      `${backend} address history exceeded ${maxTransactions} transactions: ${address}`
+    );
+  }
+  return value;
+}
+function addressHistoryAddressMatches(value, address) {
+  if (typeof value !== "string") return false;
+  if (value === address) return true;
+  if (!isUniformCaseQbitBech32(value) || !isUniformCaseQbitBech32(address)) return false;
+  return value.toLowerCase() === address.toLowerCase();
+}
+var QBIT_BECH32_HRPS = /* @__PURE__ */ new Set(["qb", "tq", "qbrt"]);
+function isUniformCaseQbitBech32(value) {
+  const normalized = value.toLowerCase();
+  const separator = value.lastIndexOf("1");
+  const hrp = normalized.slice(0, separator);
+  const data = value.slice(separator + 1);
+  const hasUniformCase = value === value.toLowerCase() || value === value.toUpperCase();
+  return separator > 0 && QBIT_BECH32_HRPS.has(hrp) && data.length >= 6 && hasUniformCase && /^[qpzry9x8gf2tvdw0s3jn54khce6mua7l]+$/i.test(data);
+}
+function nextAddressHistoryCursor(txs, cursor, seenCursors, address, backend) {
+  const nextCursor = txs[txs.length - 1]?.txid;
+  if (!nextCursor) {
+    throw new QbitApiError(
+      "invalid_cursor",
+      `${backend} address history cursor stopped advancing: (missing) (${address})`
+    );
+  }
+  const normalizedNextCursor = nextCursor.toLowerCase();
+  if (normalizedNextCursor === cursor?.toLowerCase() || seenCursors.has(normalizedNextCursor)) {
+    throw new QbitApiError(
+      "invalid_cursor",
+      `${backend} address history cursor stopped advancing: ${nextCursor} (${address})`
+    );
+  }
+  seenCursors.add(normalizedNextCursor);
+  return nextCursor;
+}
+function appendAddressHistoryTransactions(state, txs, source, address, backend) {
+  for (const tx of txs) {
+    const normalizedTxid = tx.txid.toLowerCase();
+    if (state.seenTxids.has(normalizedTxid)) {
+      throw new QbitApiError(
+        "invalid_cursor",
+        `${backend} address history repeated transaction ${tx.txid}: ${address}`
+      );
+    }
+    state.seenTxids.add(normalizedTxid);
+    const confirmed = isConfirmedTx(tx);
+    if (source === "confirmed" && !confirmed) {
+      throw new QbitApiError(
+        "parse",
+        `esplora confirmed history returned an unconfirmed transaction ${tx.txid}: ${address}`
+      );
+    }
+    if (source === "mempool" && confirmed) {
+      throw new QbitApiError(
+        "parse",
+        `esplora mempool history returned a confirmed transaction ${tx.txid}: ${address}`
+      );
+    }
+    if (confirmed) state.confirmed.push(tx);
+    else state.mempool.push(tx);
+  }
+}
+function addressHistoryPageLimitError(address, maxPages, backend) {
+  return new QbitApiError(
+    "pagination_limit",
+    `${backend} address history exceeded ${maxPages} page fetches: ${address}`
+  );
+}
+function isConfirmedTx(tx) {
+  return tx.status?.confirmed === true;
+}
+function unknownOutcomeError(url, txid, reason, options = {}) {
+  const subject = txid === void 0 ? "the transaction" : `txid ${txid}`;
+  return new QbitApiError(
+    "unknown_outcome",
+    `transaction submission outcome unknown (${reason}); ${subject} may have been accepted, check its status before resubmitting`,
+    { ...options, url, ...txid === void 0 ? {} : { txid } }
+  );
+}
+function isPreConnectionFailure(error) {
+  const entries = collectErrorCodes(error, 0, []);
+  return entries.length > 0 && entries.every(
+    (entry) => PRE_CONNECTION_ERROR_CODES.has(entry.code) || CONNECT_STAGE_ERROR_CODES.has(entry.code) && entry.syscall === "connect"
+  );
+}
+function collectErrorCodes(error, depth, entries) {
+  if (!isRecord(error)) return entries;
+  if (depth > 5) {
+    entries.push({ code: "UNJUDGED", syscall: void 0 });
+    return entries;
+  }
+  const nested = error["errors"];
+  if (Array.isArray(nested) && nested.length > 0) {
+    for (const entry of nested) collectErrorCodes(entry, depth + 1, entries);
+  } else if (typeof error["code"] === "string") {
+    const syscall = error["syscall"];
+    entries.push({ code: error["code"], syscall: typeof syscall === "string" ? syscall : void 0 });
+  }
+  collectErrorCodes(error["cause"], depth + 1, entries);
+  return entries;
+}
+var ALREADY_KNOWN_BROADCAST_REPLY = /\b(?:txn already in mempool|txn already known|txn same nonwitness data in mempool|transaction already in block ?chain|transaction outputs already in utxo set)\b/;
+function isAlreadyKnownBroadcastReply(reply) {
+  if (reply.code === -27) return true;
+  return ALREADY_KNOWN_BROADCAST_REPLY.test(normalizeReplyText(reply.message));
+}
+function isRelayedTransportFailure(reply) {
+  if (typeof reply.code === "string") return !PRE_CONNECTION_ERROR_CODES.has(reply.code);
+  if (reply.code === -32603 || reply.code === -32602) return true;
+  return /^connection error\b/.test(normalizeReplyText(reply.message));
+}
+var RPC_REQUEST_ERROR_CODES = /* @__PURE__ */ new Set([-32700, -32600, -32601]);
+function isNodeVerdictCode(code) {
+  return code >= -99 && code <= -1 || RPC_REQUEST_ERROR_CODES.has(code);
+}
+var DEFINITE_REJECTION_REPLY = /^(?:bad txns |bad witness nonstandard|bad cb length|txn mempool conflict|tx decode failed|tx size\b|tx output not p2mr|scriptsig (?:size|not pushonly)|scriptpubkey\b|bare multisig|datacarrier|dust\b|non (?:bip68 )?final|(?:mempool |block |(?:non )?mandatory )script verify flag|min relay fee not met|mempool min fee not met|insufficient fee|max feerate exceeded|mempool full|too long mempool chain|truc violation|missing ephemeral spends|bip125 replacement disallowed|too many potential replacements|replacement adds unconfirmed|missing inputs|no mempool\b)/;
+function isDefiniteNodeRejection(reply) {
+  if (typeof reply.code === "number") return isNodeVerdictCode(reply.code);
+  if (typeof reply.code === "string") return PRE_CONNECTION_ERROR_CODES.has(reply.code);
+  return DEFINITE_REJECTION_REPLY.test(normalizeReplyText(reply.message));
+}
+function shouldRetryBroadcastViaTxPush(error) {
+  if (!QbitApiError.is(error)) return false;
+  if (error.kind === "not_found" && error.status === 404 || error.kind === "http" && (error.status === 405 || error.status === 501)) {
+    return true;
+  }
+  const body = error instanceof QbitApiError ? rawResponseBodies.get(error) ?? error.responseBody : void 0;
+  if (error.kind !== "http" || error.status !== 400 || body === void 0) {
+    return false;
+  }
+  const reply = parseBroadcastReply(body);
+  if (reply.code !== void 0) return false;
+  return /^(?:(?:failed|unable) to|could not) (?:send|submit|broadcast)(?: raw)? transaction$/.test(
+    normalizeReplyText(reply.message)
+  );
+}
+function parseBroadcastReply(body) {
+  let text = body;
+  try {
+    const parsed = JSON.parse(body);
+    if (typeof parsed === "string") {
+      text = parsed;
+    } else if (isRecord(parsed)) {
+      const nested = parsed["error"];
+      const code = errorCodeOf(nested) ?? errorCodeOf(parsed);
+      let message = body;
+      if (typeof nested === "string") message = nested;
+      else if (isRecord(nested) && typeof nested["message"] === "string") message = nested["message"];
+      else if (typeof parsed["message"] === "string") message = parsed["message"];
+      return { code: code ?? embeddedErrorCode(message), message };
+    }
+  } catch {
+  }
+  return { code: embeddedErrorCode(text), message: text };
+}
+function errorCodeOf(value) {
+  if (!isRecord(value)) return void 0;
+  const code = value["code"];
+  if (typeof code === "number") return Number.isInteger(code) && code < 0 ? code : void 0;
+  if (typeof code !== "string") return void 0;
+  const transportCode = code.toUpperCase();
+  return TRANSPORT_ERROR_CODE_PATTERN.test(transportCode) ? transportCode : void 0;
+}
+function embeddedErrorCode(text) {
+  const start = text.indexOf("{");
+  const end = text.lastIndexOf("}");
+  if (start === -1 || end <= start) return void 0;
+  try {
+    const parsed = JSON.parse(text.slice(start, end + 1));
+    if (isRecord(parsed)) return errorCodeOf(parsed["error"]) ?? errorCodeOf(parsed);
+  } catch {
+  }
+  return void 0;
+}
+function normalizeReplyText(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseRetryAfter(value) {
+  if (!value) return void 0;
+  let ms;
+  const seconds = Number(value);
+  if (!Number.isNaN(seconds)) {
+    ms = seconds * 1e3;
+  } else {
+    const date = Date.parse(value);
+    if (!Number.isFinite(date)) return void 0;
+    ms = date - Date.now();
+  }
+  return Math.min(Math.max(0, Math.ceil(ms)), Number.MAX_SAFE_INTEGER);
+}
+function isAbortError(error) {
+  return typeof error === "object" && error !== null && error.name === "AbortError";
+}
+function isLoopbackHostname(hostname) {
+  return hostname === "localhost" || hostname === "[::1]" || /^127\.\d+\.\d+\.\d+$/.test(hostname);
+}
+var DEFAULT_PORTS = {
+  "http:": "80",
+  "https:": "443",
+  "ws:": "80",
+  "wss:": "443",
+  "ftp:": "21"
+};
+function schemeAndHost(url, base) {
+  const match = /^([a-z][a-z\d+.-]*:)[/\\]*([^/?#\\]*)([^#]*)/i.exec(standardHref(url, base) ?? url);
+  if (!match) return void 0;
+  const protocol = match[1].toLowerCase();
+  const at = match[2].lastIndexOf("@");
+  const authority = match[2].slice(at + 1);
+  const [, hostname, port] = /^(\[[^\]]*\]|[^:]*):?(.*)$/s.exec(authority);
+  return {
+    protocol,
+    hostname: hostname.toLowerCase().replace(/\.$/, ""),
+    userinfo: at !== -1,
+    port: port === DEFAULT_PORTS[protocol] ? "" : port,
+    path: match[3].startsWith("/") ? match[3] : `/${match[3]}`
+  };
+}
+function standardHref(url, base) {
+  if (!followsUrlStandard()) return void 0;
+  try {
+    return new URL(url, base).href;
+  } catch {
+    return void 0;
+  }
+}
+function followsUrlStandard() {
+  try {
+    return new URL("HTTP://Q.EXAMPLE:80/a/../b").href === "http://q.example/b";
+  } catch {
+    return false;
+  }
+}
+function fromAnotherUrl(response, url) {
+  if (typeof response.url !== "string" || response.url === "") return false;
+  const requested = schemeAndHost(url);
+  const replied = schemeAndHost(response.url);
+  if (!requested || !replied) return true;
+  return replied.protocol !== requested.protocol || replied.hostname !== requested.hostname || replied.port !== requested.port || replied.path !== requested.path;
+}
+function refuseRedirect(response, url, baseUrl) {
+  const opaque = response.type === "opaqueredirect";
+  const redirectStatus = response.status >= 300 && response.status <= 399;
+  if (!opaque && !redirectStatus && response.redirected !== true && !fromAnotherUrl(response, url)) {
+    return response;
+  }
+  void discardResponseBody(response);
+  const errorUrl = redactBaseUrl(url, baseUrl);
+  if (opaque) {
+    throw new QbitApiError("http", `redirect refused (target hidden by the browser): ${errorUrl}`, { url: errorUrl });
+  }
+  if (redirectStatus) {
+    const target2 = redactRedirectTarget(redirectTargetOrigin(response.headers.get("location"), url), baseUrl);
+    throw new QbitApiError("http", `HTTP ${response.status} redirect to ${target2} refused: ${errorUrl}`, {
+      status: response.status,
+      url: errorUrl
+    });
+  }
+  const target = redactRedirectTarget(redirectTargetOrigin(response.url, url), baseUrl);
+  throw new QbitApiError("http", `fetch followed a redirect to ${target}; reply discarded: ${errorUrl}`, {
+    url: errorUrl
+  });
+}
+function redirectTargetOrigin(location, url) {
+  if (!location) return "an unspecified location";
+  const target = schemeAndHost(location, url) ?? schemeAndHost(/^[/\\]{2}/.test(location) ? `${schemeAndHost(url)?.protocol ?? ""}${location}` : url);
+  if (!target) return "an invalid location";
+  if (!/^(?:https?|wss?|ftp):$/.test(target.protocol)) return `a ${target.protocol} URL`;
+  if (!/^(?:[a-z\d._~-]+|\[[a-f\d:.]+\])$/.test(target.hostname) || !/^\d*$/.test(target.port)) {
+    return "an invalid location";
+  }
+  return `${target.protocol}//${target.hostname}${target.port ? `:${target.port}` : ""}`;
+}
+function redactedBaseUrl(baseUrl) {
+  let href = baseUrl;
+  try {
+    href = new URL(baseUrl).href;
+  } catch {
+  }
+  const match = /^(https?:)[/\\]*([^/?#\\]*)/i.exec(href);
+  if (!match) return "...";
+  const host = match[2].slice(match[2].lastIndexOf("@") + 1).toLowerCase();
+  if (!/^(?:[a-z\d._~-]+|\[[a-f\d:.]+\])(?::\d*)?$/.test(host) || href.slice(match[0].length).includes("@")) {
+    return "...";
+  }
+  const origin = `${match[1].toLowerCase()}//${host}`;
+  return basePath(href) ? `${origin}/...` : origin;
+}
+function redactBaseUrl(text, baseUrl) {
+  const spellings = [baseUrl];
+  try {
+    spellings.push(new URL(baseUrl).href.replace(/\/+$/, ""));
+  } catch {
+  }
+  const redacted = redactedBaseUrl(baseUrl);
+  const replacements = /* @__PURE__ */ new Map();
+  for (const part of spellings.flatMap(baseUrlParts)) replacements.set(part, "...");
+  for (const path of spellings.map(basePath)) if (path) replacements.set(path, "/...");
+  for (const spelling of spellings) if (spelling) replacements.set(spelling, redacted);
+  if (replacements.size === 0) return text;
+  const pattern = [...replacements.keys()].sort((a, b) => b.length - a.length).map((needle) => needle.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+  return text.replace(new RegExp(pattern, "g"), (match) => replacements.get(match));
+}
+function baseUrlParts(url) {
+  const match = /^(?:[a-z][a-z\d+.-]*:[/\\]*)?([^?#]*)(?:\?([^#]*))?/i.exec(url);
+  const beforeQuery = match[1];
+  const at = beforeQuery.lastIndexOf("@");
+  const userinfo = at === -1 ? "" : beforeQuery.slice(0, at);
+  const colon = userinfo.indexOf(":");
+  const parts = [
+    ...colon === -1 ? [userinfo] : [userinfo.slice(0, colon), userinfo.slice(colon + 1)],
+    ...beforeQuery.split(/[/\\]/).slice(1),
+    ...beforeQuery.slice(at + 1).split(/[/\\]/).slice(1),
+    ...(match[2] ?? "").split("&").map((pair) => pair.slice(pair.indexOf("=") + 1))
+  ];
+  return parts.flatMap((part) => [part, percentDecoded(part)]).filter((part) => part.length >= 8);
+}
+function percentDecoded(text) {
+  try {
+    return decodeURIComponent(text);
+  } catch {
+    return text;
+  }
+}
+function basePath(url) {
+  const path = /^[a-z][a-z\d+.-]*:[/\\]*[^/?#\\]*(.*)$/i.exec(url)?.[1] ?? "";
+  return path === "/" ? "" : path;
+}
+function redactRedirectTarget(target, baseUrl) {
+  const redacted = redactBaseUrl(target, baseUrl);
+  const parts = [...new Set(baseUrlParts(baseUrl))].sort((a, b) => b.length - a.length);
+  if (parts.length === 0) return redacted;
+  const pattern = parts.map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+  return redacted.replace(new RegExp(pattern, "gi"), "...");
+}
+function responseBodyPreview(text, baseUrl) {
+  return redactBaseUrl(text.trim(), baseUrl).slice(0, 200);
+}
+function quotedResponseText(text, baseUrl) {
+  return escapeControlChars(responseBodyPreview(text, baseUrl));
+}
+var REDACTED_CAUSE_DEPTH = 5;
+var NATIVE_ERRORS = [
+  Error,
+  TypeError,
+  RangeError,
+  SyntaxError,
+  ReferenceError,
+  EvalError,
+  URIError
+];
+function causeOptions(cause, baseUrl) {
+  return { cause: redactedCause(cause, baseUrl, REDACTED_CAUSE_DEPTH), unredactedCause: cause };
+}
+function redactedCause(value, baseUrl, depth) {
+  if (typeof value === "string") return redactBaseUrl(value, baseUrl);
+  if (typeof value === "function") return void 0;
+  if (typeof value !== "object" || value === null) return value;
+  if (depth === 0) return void 0;
+  if (Array.isArray(value)) return value.map((item) => redactedCause(item, baseUrl, depth - 1));
+  try {
+    let copy;
+    const prototype = Object.getPrototypeOf(value);
+    if (value instanceof Error) {
+      const ErrorClass = NATIVE_ERRORS.find((errorClass) => errorClass === value.constructor) ?? Error;
+      const error = new ErrorClass(redactBaseUrl(String(value.message), baseUrl));
+      if (error.name !== value.name) {
+        Object.defineProperty(error, "name", { value: String(value.name), writable: true, configurable: true });
+      }
+      error.stack = typeof value.stack === "string" ? redactBaseUrl(value.stack, baseUrl) : `${error.name}: ${error.message}`;
+      copy = error;
+    } else if (prototype === Object.prototype || prototype === null) {
+      copy = {};
+    } else {
+      return void 0;
+    }
+    for (const key of Object.getOwnPropertyNames(value)) {
+      if (value instanceof Error && (key === "message" || key === "stack")) continue;
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (descriptor === void 0 || !("value" in descriptor)) continue;
+      const redacted = redactedCause(descriptor.value, baseUrl, depth - 1);
+      if (redacted === void 0 && descriptor.value !== void 0) continue;
+      Object.defineProperty(copy, key, {
+        value: redacted,
+        enumerable: descriptor.enumerable ?? false,
+        writable: true,
+        configurable: true
+      });
+    }
+    return copy;
+  } catch {
+    return void 0;
+  }
+}
+function escapeControlChars(text) {
+  return text.replace(/[\p{Cc}\p{Zl}\p{Zp}\p{Bidi_Control}]/gu, (char) => {
+    if (char === "\n") return "\\n";
+    if (char === "\r") return "\\r";
+    if (char === "	") return "\\t";
+    return `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}`;
+  });
+}
+function formatErrorCause(error) {
+  if (error instanceof Error) {
+    return ` (${error.name}: ${error.message})`;
+  }
+  if (typeof error === "string") {
+    return ` (${error})`;
+  }
+  return "";
+}
+async function readBody(response, url, baseUrl, signal) {
+  if (signal.aborted) {
+    const error = abortErrorFor(signal);
+    void discardResponseBody(response, error);
+    throw error;
+  }
+  try {
+    return await readBodyUntilAborted(response, signal);
+  } catch (cause) {
+    if (signal.aborted) throw abortErrorFor(signal);
+    throw bodyReadError(response, cause, url, baseUrl);
+  }
+}
+function bodyReadError(response, cause, url, baseUrl) {
+  return new QbitApiError("parse", `failed to read response body from ${url}`, {
+    url,
+    status: response.status,
+    ...causeOptions(cause, baseUrl)
+  });
+}
+async function readBodyUntilAborted(response, signal) {
+  let rejectAborted = () => {
+  };
+  const aborted = new Promise((_, reject) => {
+    rejectAborted = reject;
+  });
+  aborted.catch(() => {
+  });
+  const onAbort = () => rejectAborted(signal.reason);
+  if (signal.aborted) onAbort();
+  else signal.addEventListener("abort", onAbort, { once: true });
+  try {
+    const body = response.body;
+    if (!body || typeof body.getReader !== "function" || typeof TextDecoder !== "function") {
+      try {
+        return await Promise.race([response.text(), aborted]);
+      } catch (error) {
+        if (signal.aborted) releaseBody(body, signal.reason);
+        throw error;
+      }
+    }
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let text = "";
+    try {
+      while (true) {
+        const chunk = await Promise.race([reader.read(), aborted]);
+        if (chunk.done) return text + decoder.decode();
+        text += decoder.decode(chunk.value, { stream: true });
+      }
+    } catch (error) {
+      reader.cancel(error).catch(() => {
+      });
+      throw error;
+    }
+  } finally {
+    signal.removeEventListener("abort", onAbort);
+  }
+}
+function releaseBody(body, reason) {
+  if (body === null || typeof body !== "object") return;
+  const stream = body;
+  try {
+    if (typeof stream.cancel === "function") {
+      const result = stream.cancel(reason);
+      if (result && typeof result.then === "function") result.then(void 0, () => {
+      });
+    } else if (typeof stream.destroy === "function") {
+      const handled = typeof stream.listenerCount === "function" && Number(stream.listenerCount("error")) > 0;
+      if (handled) stream.destroy(reason);
+      else stream.destroy();
+    }
+  } catch {
+  }
+}
+var NULL_BODY_STATUSES = /* @__PURE__ */ new Set([204, 205, 304]);
+function bufferedResponse(response, text) {
+  const body = NULL_BODY_STATUSES.has(response.status) ? null : text;
+  const buffered = constructedResponse(response, body) ?? plainBufferedResponse(response, body ?? "");
+  Object.defineProperties(buffered, {
+    url: { value: response.url },
+    headers: { value: response.headers },
+    clone: { value: () => bufferedResponse(response, text) }
+  });
+  return buffered;
+}
+function constructedResponse(response, body) {
+  if (typeof Response !== "function") return void 0;
+  try {
+    return new Response(body, { status: response.status, statusText: response.statusText });
+  } catch {
+    return void 0;
+  }
+}
+function plainBufferedResponse(response, text) {
+  let bodyUsed = false;
+  const consume = async () => {
+    if (bodyUsed) throw new TypeError("Body has already been consumed");
+    bodyUsed = true;
+    return text;
+  };
+  return {
+    status: response.status,
+    statusText: response.statusText,
+    ok: response.status >= 200 && response.status <= 299,
+    redirected: response.redirected ?? false,
+    type: response.type ?? "default",
+    body: null,
+    get bodyUsed() {
+      return bodyUsed;
+    },
+    text: consume,
+    json: async () => JSON.parse(await consume())
+  };
+}
+async function discardResponseBody(response, reason) {
+  if (response.body === null || response.bodyUsed) return;
+  try {
+    await response.body.cancel(reason);
+  } catch {
+  }
+}
+function httpReplyMessage(status, url, detail) {
+  return `HTTP ${status} from ${url}${detail ? `: ${escapeControlChars(detail)}` : ""}`;
+}
+var rawResponseBodies = /* @__PURE__ */ new WeakMap();
+function httpError(response, body, url, baseUrl) {
+  const status = response.status;
+  const detail = responseBodyPreview(body, baseUrl);
+  const message = httpReplyMessage(status, url, detail);
+  const options = { status, url, responseBody: detail };
+  const retryAfterMs = parseRetryAfter(response.headers.get("retry-after"));
+  if (retryAfterMs !== void 0) options.retryAfterMs = retryAfterMs;
+  const error = status === 429 ? new QbitApiError("rate_limit", message, options) : status === 413 ? new QbitApiError("payload_too_large", message, options) : status === 404 ? new QbitApiError("not_found", message, options) : new QbitApiError("http", message, options);
+  rawResponseBodies.set(error, body.trim().slice(0, 200));
+  return error;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_MAX_FEE_RATE_SAT_VB,
+  EsploraClient,
+  MempoolQbitClient,
+  QbitApiError,
+  addressBalanceFromStats,
+  feeEstimatesFromMempoolRecommendedFees,
+  feeTiersFromEstimates,
+  txidFromRawTx
+});
+//# sourceMappingURL=index.js.map