@anywalletkit/wallet-btc 0.0.0-stage → 0.2.1

package/dist/index.cjs

@@ -0,0 +1,1275 @@
+"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 src_exports = {};
+__export(src_exports, {
+  BlockbookClient: () => BlockbookClient,
+  CAIP2_GENESIS: () => CAIP2_GENESIS,
+  DEFAULT_MAX_FEE_RATE: () => DEFAULT_MAX_FEE_RATE,
+  DUST_LIMIT_P2TR: () => DUST_LIMIT_P2TR,
+  DUST_LIMIT_P2WPKH: () => DUST_LIMIT_P2WPKH,
+  EsploraClient: () => EsploraClient,
+  FINAL_SEQUENCE: () => FINAL_SEQUENCE,
+  HistoryUnavailableError: () => HistoryUnavailableError,
+  INPUT_WEIGHT: () => INPUT_WEIGHT,
+  MAX_UTXO_INPUTS: () => MAX_UTXO_INPUTS,
+  RBF_SEQUENCE: () => RBF_SEQUENCE,
+  REGTEST_NETWORK: () => REGTEST_NETWORK,
+  TooManyInputsError: () => TooManyInputsError,
+  UnsafeTransactionError: () => UnsafeTransactionError,
+  UnsupportedAddressTypeError: () => UnsupportedAddressTypeError,
+  WalletAccountBtc: () => WalletAccountBtc,
+  WalletAccountReadOnlyBtc: () => WalletAccountReadOnlyBtc,
+  WalletManagerBtc: () => WalletManagerBtc,
+  addressFor: () => addressFor,
+  addressFromPublicKey: () => addressFromPublicKey,
+  addressFromScript: () => addressFromScript,
+  assertSafe: () => assertSafe,
+  btcExplorerTxUrl: () => btcExplorerTxUrl,
+  coinType: () => coinType,
+  createBtcHistory: () => createBtcHistory,
+  createClient: () => createClient,
+  decodeAddress: () => decodeAddress,
+  decodeHistoryCursor: () => decodeCursor,
+  default: () => WalletManagerBtc,
+  describeTransaction: () => describeTransaction,
+  dustLimit: () => dustLimit,
+  encodeHistoryCursor: () => encodeCursor,
+  encodeMessageSignature: () => encodeMessageSignature,
+  estimateVsize: () => estimateVsize,
+  magicHash: () => magicHash,
+  mapBlockbookTx: () => mapBlockbookTx,
+  networkParams: () => networkParams,
+  outputVBytes: () => outputVBytes,
+  parseRawTransaction: () => parseRawTransaction,
+  purposeFor: () => purposeFor,
+  recoverMessagePublicKey: () => recoverMessagePublicKey,
+  scriptKind: () => scriptKind,
+  selectAll: () => selectAll,
+  selectCoins: () => selectCoins,
+  signMessage: () => signMessage,
+  signMessageWith: () => signMessageWith,
+  spendableUtxos: () => spendableUtxos,
+  unconfirmedOutgoing: () => unconfirmedOutgoing
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/types.ts
+var CAIP2_GENESIS = {
+  bitcoin: "bip122:000000000019d6689c085ae165831e93",
+  testnet: "bip122:000000000933ea01ad0ee984209779ba",
+  regtest: "bip122:0f9188f13cb7b2c71f2a335e3a4fc328"
+};
+
+// src/errors.ts
+var import_core = require("@anywalletkit/core");
+var UnsafeTransactionError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "UnsafeTransactionError";
+    this.code = code;
+  }
+};
+var TooManyInputsError = class extends Error {
+  maxInputs;
+  constructor(maxInputs) {
+    super(`The spend needs more than ${maxInputs} inputs; consolidate the UTXOs first or raise maxInputs.`);
+    this.name = "TooManyInputsError";
+    this.maxInputs = maxInputs;
+  }
+};
+var UnsupportedAddressTypeError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UnsupportedAddressTypeError";
+  }
+};
+
+// src/blockbook.ts
+var import_core3 = require("@anywalletkit/core");
+
+// src/http.ts
+var import_core2 = require("@anywalletkit/core");
+var DEFAULT_TIMEOUT_MS = 15e3;
+async function fetchWithTimeout(fetchFn, url, init, timeoutMs, provider) {
+  const signal = typeof AbortSignal !== "undefined" && typeof AbortSignal.timeout === "function" ? AbortSignal.timeout(timeoutMs) : void 0;
+  try {
+    return await fetchFn(url, { ...init, ...signal ? { signal } : {} });
+  } catch (e) {
+    throw new import_core2.NetworkError(`Request failed: ${url}`, { provider, cause: e });
+  }
+}
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var isHex64 = (v) => typeof v === "string" && /^[0-9a-fA-F]{64}$/.test(v);
+var isIntString = (v) => typeof v === "string" && /^-?\d+$/.test(v);
+
+// src/blockbook.ts
+var MEMPOOL_SPACE_URL = "https://mempool.space";
+function unconfirmedOutgoing(transactions, address) {
+  const pending = (transactions ?? []).filter((tx) => tx.blockHeight === -1);
+  const pendingIds = new Set(pending.map((t) => t.txid));
+  const byId = new Map(pending.map((t) => [t.txid, t]));
+  const trusted = /* @__PURE__ */ new Map();
+  const owned = (entries) => (entries ?? []).filter((e) => e.isAddress && e.addresses?.includes(address)).reduce((s, e) => s + BigInt(e.value ?? 0), 0n);
+  const isTrusted = (tx) => {
+    if (trusted.has(tx.txid)) return trusted.get(tx.txid);
+    trusted.set(tx.txid, false);
+    const vins = tx.vin ?? [];
+    const ours = vins.filter((v) => v.isAddress && v.addresses?.includes(address));
+    const ok = vins.length > 0 && ours.length === vins.length && ours.every((v) => !v.txid || !pendingIds.has(v.txid) || isTrusted(byId.get(v.txid)));
+    trusted.set(tx.txid, ok);
+    return ok;
+  };
+  const consumed = /* @__PURE__ */ new Set();
+  for (const tx of pending) for (const v of tx.vin ?? []) if (v.txid && pendingIds.has(v.txid)) consumed.add(`${v.txid}:${v.vout}`);
+  return pending.reduce((total, tx) => {
+    const spent = owned((tx.vin ?? []).filter((v) => !v.txid || !pendingIds.has(v.txid)));
+    const change = isTrusted(tx) ? owned((tx.vout ?? []).filter((o) => !consumed.has(`${tx.txid}:${o.n}`))) : 0n;
+    return total + (spent - change);
+  }, 0n);
+}
+var BlockbookClient = class _BlockbookClient {
+  base;
+  fetchFn;
+  timeoutMs;
+  constructor(config, fetchFn = globalThis.fetch, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    this.base = config.url.replace(/\/+$/, "").replace(/\/api$/, "");
+    this.fetchFn = fetchFn;
+    this.timeoutMs = timeoutMs;
+  }
+  async connect() {
+  }
+  async close() {
+  }
+  async get(path, check) {
+    const url = `${this.base}/api${path}`;
+    const res = await fetchWithTimeout(this.fetchFn, url, void 0, this.timeoutMs, this.base);
+    if (!res.ok) throw new import_core3.NetworkError(`Blockbook request failed: ${res.status} ${res.statusText} (${url})`, { provider: this.base });
+    let body;
+    try {
+      body = await res.json();
+    } catch (e) {
+      throw new import_core3.NetworkError(`Blockbook returned non-JSON for ${url}`, { provider: this.base, cause: e });
+    }
+    if (!check(body)) throw new import_core3.NetworkError(`Blockbook returned an unexpected shape for ${url}`, { provider: this.base });
+    return body;
+  }
+  async getBalance(address) {
+    const data = await this.get(`/v2/address/${address}?details=txs`, (v) => isRecord(v) && isIntString(v.balance) && isIntString(v.unconfirmedBalance) && (v.transactions === void 0 || Array.isArray(v.transactions)));
+    return { confirmed: BigInt(data.balance), unconfirmed: BigInt(data.unconfirmedBalance), unconfirmedOutgoing: unconfirmedOutgoing(data.transactions, address) };
+  }
+  async listUnspent(address) {
+    const data = await this.get(`/v2/utxo/${address}`, (v) => Array.isArray(v) && v.every((u) => isRecord(u) && typeof u.txid === "string" && typeof u.vout === "number" && isIntString(u.value)));
+    return data.map((u) => ({ txid: u.txid, vout: u.vout, value: BigInt(u.value), height: u.height ?? -1 }));
+  }
+  async getHistory(address) {
+    const items = [];
+    for (let page = 1; ; page++) {
+      const data = await this.get(`/v2/address/${address}?details=txslight&pageSize=1000&page=${page}`, (v) => isRecord(v) && (v.transactions === void 0 || Array.isArray(v.transactions)));
+      for (const tx of data.transactions ?? []) items.push({ txid: tx.txid, height: tx.blockHeight });
+      if (page >= (data.totalPages ?? 1)) break;
+    }
+    return items;
+  }
+  /** One page of the address's transactions, newest first, with inputs / outputs (what the activity history reads). */
+  async getAddressPage(address, page = 1, pageSize = 25) {
+    const data = await this.get(`/v2/address/${address}?details=txs&page=${page}&pageSize=${pageSize}`, (v) => isRecord(v) && (v.transactions === void 0 || Array.isArray(v.transactions) && v.transactions.every(_BlockbookClient.isTx)));
+    const out = { ...data };
+    for (const tx of out.transactions ?? []) delete tx.hex;
+    return out;
+  }
+  /** A transaction with its inputs / outputs; undefined when Blockbook does not know it. */
+  async getTransactionDetails(txid) {
+    try {
+      const tx = await this.get(`/v2/tx/${txid}`, (v) => _BlockbookClient.isTx(v));
+      const out = { ...tx };
+      delete out.hex;
+      return out;
+    } catch (e) {
+      if (e instanceof import_core3.NetworkError && /\b(400|404)\b/.test(e.message)) return void 0;
+      throw e;
+    }
+  }
+  static isTx(v) {
+    return isRecord(v) && typeof v.txid === "string" && typeof v.blockHeight === "number" && typeof v.confirmations === "number";
+  }
+  async getTransactionInfo(txid) {
+    try {
+      return await this.get(`/v2/tx/${txid}`, _BlockbookClient.isTx);
+    } catch (e) {
+      if (e instanceof import_core3.NetworkError && /\b(400|404)\b/.test(e.message)) return void 0;
+      throw e;
+    }
+  }
+  async getTransaction(txid) {
+    const data = await this.get(`/v2/tx/${txid}`, _BlockbookClient.isTx);
+    if (typeof data.hex !== "string" || !data.hex) throw new import_core3.NetworkError(`Transaction ${txid} has no hex data`, { provider: this.base });
+    return data.hex;
+  }
+  async broadcast(rawTx) {
+    const data = await this.get(`/v2/sendtx/${rawTx}`, (v) => isRecord(v));
+    if (data.error) throw new Error(typeof data.error === "string" ? data.error : data.error.message ?? "broadcast failed");
+    if (!data.result) throw new import_core3.NetworkError("Blockbook returned no txid", { provider: this.base });
+    return data.result;
+  }
+  /** sat/vB. Blockbook reports BTC/kB (×1e5 → sat/vB); falls back to mempool.space when it has no estimate. */
+  async estimateFee(blocks) {
+    try {
+      const data = await this.get(`/v1/estimatefee/${blocks}`, (v) => typeof v === "string" || isRecord(v));
+      const rate = Number(typeof data === "string" ? data : data.result);
+      if (rate > 0) return Math.max(rate * 1e5, 1);
+    } catch {
+    }
+    const res = await fetchWithTimeout(this.fetchFn, `${MEMPOOL_SPACE_URL}/api/v1/fees/recommended`, void 0, this.timeoutMs, MEMPOOL_SPACE_URL);
+    if (!res.ok) throw new import_core3.NetworkError("Fee estimation request failed", { provider: MEMPOOL_SPACE_URL });
+    const d = await res.json();
+    const satPerVb = blocks <= 1 ? d.fastestFee : blocks <= 3 ? d.halfHourFee : blocks <= 6 ? d.hourFee : d.economyFee;
+    if (!satPerVb || satPerVb <= 0) throw new import_core3.NetworkError("Fee estimation is unavailable", { provider: MEMPOOL_SPACE_URL });
+    return satPerVb;
+  }
+  async getBlockHeight() {
+    const data = await this.get("/v2", (v) => isRecord(v));
+    const h = data.blockbook?.bestHeight;
+    if (typeof h !== "number" || h <= 0) throw new import_core3.NetworkError("Blockbook did not report a block height", { provider: this.base });
+    return h;
+  }
+};
+
+// src/esplora.ts
+var import_core4 = require("@anywalletkit/core");
+var isStats = (v) => isRecord(v) && typeof v.funded_txo_sum === "number" && typeof v.spent_txo_sum === "number";
+var isStatus = (v) => isRecord(v) && typeof v.confirmed === "boolean";
+var EsploraClient = class {
+  base;
+  fetchFn;
+  timeoutMs;
+  constructor(config, fetchFn = globalThis.fetch, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    const trimmed = config.url.replace(/\/+$/, "");
+    this.base = trimmed.endsWith("/api") ? trimmed : `${trimmed}/api`;
+    this.fetchFn = fetchFn;
+    this.timeoutMs = timeoutMs;
+  }
+  async connect() {
+  }
+  async close() {
+  }
+  async request(path, init) {
+    const url = `${this.base}${path}`;
+    const res = await fetchWithTimeout(this.fetchFn, url, init, this.timeoutMs, this.base);
+    if (!res.ok) throw new import_core4.NetworkError(`Esplora request failed: ${res.status} ${res.statusText} (${url})`, { provider: this.base });
+    return res;
+  }
+  async json(path, check) {
+    const res = await this.request(path);
+    let body;
+    try {
+      body = await res.json();
+    } catch (e) {
+      throw new import_core4.NetworkError(`Esplora returned non-JSON for ${path}`, { provider: this.base, cause: e });
+    }
+    if (!check(body)) throw new import_core4.NetworkError(`Esplora returned an unexpected shape for ${path}`, { provider: this.base });
+    return body;
+  }
+  async text(path, init) {
+    return (await this.request(path, init)).text();
+  }
+  async getBalance(address) {
+    const d = await this.json(`/address/${address}`, (v) => isRecord(v) && isStats(v.chain_stats) && isStats(v.mempool_stats));
+    const confirmed = BigInt(d.chain_stats.funded_txo_sum) - BigInt(d.chain_stats.spent_txo_sum);
+    const unconfirmed = BigInt(d.mempool_stats.funded_txo_sum) - BigInt(d.mempool_stats.spent_txo_sum);
+    const outgoing = BigInt(d.mempool_stats.spent_txo_sum) - BigInt(d.mempool_stats.funded_txo_sum);
+    return { confirmed, unconfirmed, unconfirmedOutgoing: outgoing > 0n ? outgoing : 0n };
+  }
+  async listUnspent(address) {
+    const d = await this.json(`/address/${address}/utxo`, (v) => Array.isArray(v) && v.every((u) => isRecord(u) && isHex64(u.txid) && typeof u.vout === "number" && typeof u.value === "number" && isStatus(u.status)));
+    return d.map((u) => ({ txid: u.txid, vout: u.vout, value: BigInt(u.value), height: u.status.confirmed && u.status.block_height ? u.status.block_height : -1 }));
+  }
+  /** Esplora pages 25 (mempool.space: up to 50) txs per call; walk `/txs/chain/<last>` until a short page. */
+  async getHistory(address) {
+    const items = [];
+    const check = (v) => Array.isArray(v) && v.every((t) => isRecord(t) && isHex64(t.txid) && isStatus(t.status));
+    let page = await this.json(`/address/${address}/txs`, check);
+    for (; ; ) {
+      for (const t of page) items.push({ txid: t.txid, height: t.status.confirmed && t.status.block_height ? t.status.block_height : -1 });
+      if (page.length < 25) break;
+      const confirmedTail = [...page].reverse().find((t) => t.status.confirmed);
+      if (!confirmedTail) break;
+      page = await this.json(`/address/${address}/txs/chain/${confirmedTail.txid}`, check);
+      if (page.length === 0) break;
+    }
+    return items;
+  }
+  async getTransactionInfo(txid) {
+    let d;
+    try {
+      d = await this.json(`/tx/${txid}`, (v) => isRecord(v) && isHex64(v.txid) && isStatus(v.status));
+    } catch (e) {
+      if (e instanceof import_core4.NetworkError && /\b(400|404)\b/.test(e.message)) return void 0;
+      throw e;
+    }
+    const height = d.status.confirmed && d.status.block_height ? d.status.block_height : -1;
+    const confirmations = height > 0 ? Math.max(await this.getBlockHeight() - height + 1, 1) : 0;
+    return { txid: d.txid, blockHeight: height, confirmations, ...typeof d.fee === "number" ? { fees: String(d.fee) } : {} };
+  }
+  async getTransaction(txid) {
+    const hex3 = (await this.text(`/tx/${txid}/hex`)).trim();
+    if (!/^[0-9a-fA-F]+$/.test(hex3) || hex3.length < 20) throw new import_core4.NetworkError(`Esplora returned no hex for ${txid}`, { provider: this.base });
+    return hex3;
+  }
+  async broadcast(rawTx) {
+    const id = (await this.text("/tx", { method: "POST", body: rawTx, headers: { "content-type": "text/plain" } })).trim();
+    if (!/^[0-9a-fA-F]{64}$/.test(id)) throw new import_core4.NetworkError(`Esplora broadcast returned an unexpected body: ${id.slice(0, 120)}`, { provider: this.base });
+    return id;
+  }
+  /** `/fee-estimates` → { "1": sat/vB, "2": …, "25": …, "144": … }; picks the nearest target ≥ `blocks`. */
+  async estimateFee(blocks) {
+    const d = await this.json("/fee-estimates", (v) => isRecord(v) && Object.values(v).every((n) => typeof n === "number"));
+    const targets = Object.keys(d).map(Number).filter((n) => Number.isFinite(n) && n > 0).sort((a, b) => a - b);
+    const target = targets.find((t) => t >= blocks) ?? targets.at(-1);
+    const rate = target !== void 0 ? d[String(target)] : void 0;
+    if (!rate || rate <= 0) throw new import_core4.NetworkError("Esplora has no fee estimate", { provider: this.base });
+    return rate;
+  }
+  async getBlockHeight() {
+    const h = Number((await this.text("/blocks/tip/height")).trim());
+    if (!Number.isInteger(h) || h <= 0) throw new import_core4.NetworkError("Esplora did not report a block height", { provider: this.base });
+    return h;
+  }
+};
+
+// src/client.ts
+var import_core5 = require("@anywalletkit/core");
+var isClient = (c) => typeof c === "object" && c !== null && typeof c.listUnspent === "function";
+function toClient(c, fetchFn, timeoutMs) {
+  if (isClient(c)) return c;
+  switch (c.type) {
+    case "blockbook-http":
+      return new BlockbookClient(c.clientConfig, fetchFn, timeoutMs);
+    case "esplora-http":
+      return new EsploraClient(c.clientConfig, fetchFn, timeoutMs);
+    default:
+      throw new Error(`Unknown BTC client type: ${String(c.type)}`);
+  }
+}
+var METHODS = ["connect", "close", "getBalance", "listUnspent", "getHistory", "getTransaction", "getTransactionInfo", "broadcast", "estimateFee", "getBlockHeight"];
+function createClient(config) {
+  if (config.client === void 0) return void 0;
+  const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const list = (Array.isArray(config.client) ? config.client : [config.client]).map((c) => toClient(c, config.fetch, timeoutMs));
+  if (list.length === 0) return void 0;
+  if (list.length === 1) return list[0];
+  const attempts = list.length + (config.retries ?? 3);
+  const call = (method) => async (...args) => {
+    let last;
+    for (let i = 0; i < attempts; i++) {
+      const c = list[i % list.length];
+      const fn = c[method];
+      if (!fn) continue;
+      try {
+        return await fn.apply(c, args);
+      } catch (e) {
+        last = e;
+      }
+    }
+    throw new import_core5.NetworkError(`All BTC clients failed for ${method}`, { cause: last });
+  };
+  const out = {};
+  for (const m of METHODS) out[m] = call(m);
+  return out;
+}
+
+// src/message.ts
+var import_sha2 = require("@noble/hashes/sha2.js");
+var import_secp256k1 = require("@noble/curves/secp256k1.js");
+var import_base = require("@scure/base");
+var PREFIX = new TextEncoder().encode("Bitcoin Signed Message:\n");
+function varint(n) {
+  if (n < 253) return Uint8Array.of(n);
+  if (n <= 65535) return Uint8Array.of(253, n & 255, n >> 8);
+  return Uint8Array.of(254, n & 255, n >> 8 & 255, n >> 16 & 255, n >>> 24 & 255);
+}
+function magicHash(message) {
+  const msg = typeof message === "string" ? new TextEncoder().encode(message) : message;
+  const len = varint(msg.length);
+  const buf = new Uint8Array(PREFIX.length + len.length + msg.length);
+  buf.set(PREFIX, 0);
+  buf.set(len, PREFIX.length);
+  buf.set(msg, PREFIX.length + len.length);
+  return (0, import_sha2.sha256)((0, import_sha2.sha256)(buf));
+}
+function headerFlag(recovery, segwitType) {
+  let flag = recovery;
+  if (segwitType !== void 0) {
+    flag += 8;
+    if (segwitType === "p2wpkh") flag += 4;
+  } else flag += 4;
+  return 27 + flag;
+}
+function encodeMessageSignature(rs, recovery, segwitType = "p2wpkh") {
+  if (rs.length !== 64 || recovery > 1) throw new Error("BIP-137: expected a 64-byte r\u2016s signature and a 0/1 recovery id.");
+  const out = new Uint8Array(65);
+  out[0] = headerFlag(recovery, segwitType);
+  out.set(rs, 1);
+  return import_base.base64.encode(out);
+}
+function signMessage(message, privateKey, segwitType = "p2wpkh") {
+  const sig = import_secp256k1.secp256k1.sign(magicHash(message), privateKey, { prehash: false, format: "recovered" });
+  return encodeMessageSignature(sig.subarray(1), sig[0], segwitType);
+}
+async function signMessageWith(message, signer, segwitType = "p2wpkh") {
+  const sig = await signer.sign(magicHash(message), { scheme: "ecdsa-recoverable", context: "btc-message" });
+  return encodeMessageSignature(sig.subarray(0, 64), sig[64], segwitType);
+}
+function recoverMessagePublicKey(message, signature) {
+  let bytes;
+  try {
+    bytes = import_base.base64.decode(signature);
+  } catch {
+    return void 0;
+  }
+  if (bytes.length !== 65) return void 0;
+  const flag = bytes[0] - 27;
+  if (flag < 0 || flag > 15) return void 0;
+  const recovery = flag & 3;
+  const compressed = !!(flag & 4) || !!(flag & 8);
+  const segwit = flag & 8 ? flag & 4 ? "p2wpkh" : "p2sh(p2wpkh)" : void 0;
+  const recovered = new Uint8Array(65);
+  recovered[0] = recovery;
+  recovered.set(bytes.subarray(1), 1);
+  try {
+    const pub = import_secp256k1.secp256k1.recoverPublicKey(recovered, magicHash(message), { prehash: false });
+    const publicKey = compressed ? pub : import_secp256k1.secp256k1.Point.fromBytes(pub).toBytes(false);
+    return { publicKey, segwitType: segwit };
+  } catch {
+    return void 0;
+  }
+}
+
+// src/coinselect.ts
+var import_core6 = require("@anywalletkit/core");
+var MAX_UTXO_INPUTS = 200;
+var OVERHEAD_WEIGHT = 42;
+function estimateVsize(inputs, inputWeight, outputVBytes2) {
+  const outputWeight = outputVBytes2.reduce((s, vb) => s + vb * 4, 0);
+  const extra = (inputs > 252 ? 2 : 0) + (outputVBytes2.length > 252 ? 2 : 0);
+  return Math.ceil((OVERHEAD_WEIGHT + extra * 4 + inputs * inputWeight + outputWeight) / 4);
+}
+var cmpUtxo = (a, b) => a.value > b.value ? -1 : a.value < b.value ? 1 : a.txid < b.txid ? -1 : a.txid > b.txid ? 1 : a.vout - b.vout;
+function spendableUtxos(utxos, feeRate, inputWeight) {
+  const inputFee = BigInt(Math.ceil(inputWeight / 4)) * feeRate;
+  return utxos.filter((u) => u.value > inputFee).sort(cmpUtxo);
+}
+function selectCoins(o) {
+  if (o.feeRate < 1n) throw new Error("feeRate must be at least 1 sat/vB");
+  const maxInputs = o.maxInputs ?? MAX_UTXO_INPUTS;
+  const targetSum = o.targets.reduce((s, t) => s + t.value, 0n);
+  const targetVB = o.targets.map((t) => t.vbytes);
+  const candidates = spendableUtxos(o.utxos, o.feeRate, o.inputWeight);
+  const available = o.utxos.reduce((s, u) => s + u.value, 0n);
+  const feeFor = (n, withChange) => BigInt(estimateVsize(n, o.inputWeight, withChange ? [...targetVB, o.changeVBytes] : targetVB)) * o.feeRate;
+  const selected = [];
+  let sum = 0n;
+  for (const u of candidates) {
+    if (selected.length >= maxInputs) throw new TooManyInputsError(maxInputs);
+    selected.push(u);
+    sum += u.value;
+    const n = selected.length;
+    const feeNoChange = feeFor(n, false);
+    if (sum < targetSum + feeNoChange) continue;
+    const feeWithChange = feeFor(n, true);
+    const change = sum - targetSum - feeWithChange;
+    if (change >= o.changeDust) {
+      return { utxos: selected, fee: feeWithChange, change, changeFolded: false, vsize: estimateVsize(n, o.inputWeight, [...targetVB, o.changeVBytes]), feeRate: o.feeRate };
+    }
+    return { utxos: selected, fee: sum - targetSum, change: 0n, changeFolded: sum - targetSum > feeNoChange, vsize: estimateVsize(n, o.inputWeight, targetVB), feeRate: o.feeRate };
+  }
+  const need = targetSum + feeFor(Math.max(selected.length, 1), false);
+  throw new import_core6.InsufficientFundsError(need, available, "BTC");
+}
+function selectAll(o) {
+  const maxInputs = o.maxInputs ?? MAX_UTXO_INPUTS;
+  const utxos = spendableUtxos(o.utxos, o.feeRate, o.inputWeight).slice(0, maxInputs);
+  if (utxos.length === 0) return { utxos, fee: 0n, amount: 0n, vsize: 0 };
+  const vsize = estimateVsize(utxos.length, o.inputWeight, [o.outputVBytes]);
+  const fee = BigInt(vsize) * o.feeRate;
+  const amount = utxos.reduce((s, u) => s + u.value, 0n) - fee;
+  return { utxos, fee, amount: amount > 0n ? amount : 0n, vsize };
+}
+
+// src/describe.ts
+var import_btc_signer2 = require("@scure/btc-signer");
+var import_base2 = require("@scure/base");
+
+// src/address.ts
+var import_btc_signer = require("@scure/btc-signer");
+function decodeAddress(address, network) {
+  let decoded;
+  try {
+    decoded = (0, import_btc_signer.Address)(network).decode(address);
+  } catch (e) {
+    throw new Error(`Invalid bitcoin address for this network: ${address}`, { cause: e });
+  }
+  return { script: import_btc_signer.OutScript.encode(decoded), kind: decoded.type };
+}
+function addressFromScript(script, network) {
+  try {
+    return (0, import_btc_signer.Address)(network).encode(import_btc_signer.OutScript.decode(script));
+  } catch {
+    return void 0;
+  }
+}
+function scriptKind(script) {
+  try {
+    return import_btc_signer.OutScript.decode(script).type;
+  } catch {
+    return "unknown";
+  }
+}
+function spendInfo(publicKey, network, type) {
+  if (type === "p2tr") return (0, import_btc_signer.p2tr)(publicKey.length === 33 ? publicKey.subarray(1) : publicKey, void 0, network);
+  return (0, import_btc_signer.p2wpkh)(publicKey, network);
+}
+function addressFromPublicKey(publicKey, network, type = "p2wpkh") {
+  const { address } = spendInfo(publicKey, network, type);
+  if (!address) throw new Error(`Could not derive a ${type} address`);
+  return address;
+}
+var INPUT_WEIGHT = { p2wpkh: 272, p2tr: 230 };
+function outputVBytes(kind, script) {
+  switch (kind) {
+    case "wpkh":
+      return 31;
+    case "tr":
+    case "wsh":
+      return 43;
+    case "pkh":
+      return 34;
+    case "sh":
+      return 32;
+    default:
+      return 9 + (script?.length ?? 34);
+  }
+}
+function dustLimit(kind) {
+  switch (kind) {
+    case "wpkh":
+      return 294n;
+    case "tr":
+    case "wsh":
+      return 330n;
+    case "pkh":
+      return 546n;
+    case "sh":
+      return 540n;
+    default:
+      return 546n;
+  }
+}
+var DUST_LIMIT_P2WPKH = dustLimit("wpkh");
+var DUST_LIMIT_P2TR = dustLimit("tr");
+var kindOfType = (type) => type === "p2tr" ? "tr" : "wpkh";
+
+// src/describe.ts
+var DEFAULT_MAX_FEE_RATE = 500;
+var RBF_SEQUENCE = 4294967293;
+var FINAL_SEQUENCE = 4294967294;
+function parseRawTransaction(rawHex) {
+  return import_btc_signer2.Transaction.fromRaw(import_base2.hex.decode(rawHex), { allowUnknownInputs: true, allowUnknownOutputs: true });
+}
+function vsizeOf(tx) {
+  try {
+    return tx.vsize;
+  } catch {
+    return tx.unsignedTx.length;
+  }
+}
+function describeTransaction(tx, inputValues, ctx) {
+  if (inputValues.length !== tx.inputsLength) throw new Error(`describeTransaction: ${tx.inputsLength} inputs but ${inputValues.length} values`);
+  const inputs = Array.from({ length: tx.inputsLength }, (_, i) => {
+    const inp = tx.getInput(i);
+    return { txid: inp.txid ? import_base2.hex.encode(inp.txid) : "", vout: inp.index ?? 0, value: inputValues[i] };
+  });
+  const outputs = [];
+  const warnings = /* @__PURE__ */ new Set();
+  for (let i = 0; i < tx.outputsLength; i++) {
+    const out = tx.getOutput(i);
+    const value = out.amount ?? 0n;
+    const address = tx.getOutputAddress(i, ctx.network);
+    const role = address !== void 0 && address === ctx.ownAddress ? "change" : ctx.intended === void 0 ? "recipient" : address !== void 0 && address === ctx.intended.to && value === ctx.intended.value ? "recipient" : "unknown";
+    if (out.script && value < dustLimit(scriptKind(out.script))) warnings.add("dust-output");
+    outputs.push({ address, value, role });
+  }
+  const inputSum = inputs.reduce((s, i) => s + i.value, 0n);
+  const outputSum = outputs.reduce((s, o) => s + o.value, 0n);
+  const fee = inputSum - outputSum;
+  const amount = outputs.filter((o) => o.role !== "change").reduce((s, o) => s + o.value, 0n);
+  const vsize = vsizeOf(tx);
+  const feeRate = vsize > 0 ? Math.round(Number(fee) / vsize * 100) / 100 : 0;
+  if (feeRate > (ctx.maxFeeRate ?? DEFAULT_MAX_FEE_RATE)) warnings.add("high-fee-rate");
+  if (amount > 0n && fee * 10n > amount) warnings.add("fee-over-10pct-of-amount");
+  if (!outputs.some((o) => o.role === "change")) warnings.add("no-change");
+  let rbf = false;
+  for (let i = 0; i < tx.inputsLength; i++) if ((tx.getInput(i).sequence ?? 4294967295) < FINAL_SEQUENCE) rbf = true;
+  const desc = { kind: "btc-transfer", inputs, outputs, amount, fee, feeRate, vsize, rbf, lockTime: tx.lockTime, warnings: [...warnings] };
+  if (tx.isFinal) desc.txid = tx.id;
+  return desc;
+}
+function assertSafe(desc, ctx) {
+  const maxFeeRate = ctx.maxFeeRate ?? DEFAULT_MAX_FEE_RATE;
+  if (desc.feeRate > maxFeeRate) {
+    throw new UnsafeTransactionError("fee-rate-too-high", `Fee rate ${desc.feeRate} sat/vB exceeds the ${maxFeeRate} sat/vB ceiling (maxFeeRate).`);
+  }
+  if (desc.fee < 0n) throw new UnsafeTransactionError("unexpected-output", "Outputs exceed inputs.");
+  for (const o of desc.outputs) {
+    if (o.role === "change" && o.address !== ctx.ownAddress) throw new UnsafeTransactionError("change-not-ours", `Change output pays ${o.address ?? "<no address>"}, not ${ctx.ownAddress}.`);
+  }
+  if (ctx.intended) {
+    const recipients = desc.outputs.filter((o) => o.role === "recipient");
+    if (recipients.length !== 1) throw new UnsafeTransactionError("recipient-mismatch", `Expected one output of ${ctx.intended.value} sat to ${ctx.intended.to}, found ${recipients.length}.`);
+    const unknown = desc.outputs.filter((o) => o.role === "unknown");
+    if (unknown.length) throw new UnsafeTransactionError("unexpected-output", `Transaction carries ${unknown.length} output(s) that are neither the recipient nor our change.`);
+  }
+}
+
+// src/network.ts
+var import_btc_signer3 = require("@scure/btc-signer");
+var REGTEST_NETWORK = Object.freeze({ bech32: "bcrt", pubKeyHash: 111, scriptHash: 196, wif: 239 });
+function networkParams(network) {
+  switch (network) {
+    case "bitcoin":
+      return import_btc_signer3.NETWORK;
+    case "testnet":
+      return import_btc_signer3.TEST_NETWORK;
+    case "regtest":
+      return REGTEST_NETWORK;
+    default:
+      throw new Error(`Unknown bitcoin network: ${String(network)}`);
+  }
+}
+var coinType = (network) => network === "bitcoin" ? 0 : 1;
+var purposeFor = (type) => type === "p2tr" ? 86 : 84;
+
+// src/read-only-account.ts
+var import_core7 = require("@anywalletkit/core");
+var toBig = (v) => typeof v === "bigint" ? v : BigInt(Math.round(Number(v)));
+var WalletAccountReadOnlyBtc = class {
+  /** The address. */
+  address;
+  chain;
+  /** Output script of `address`. */
+  scriptPubKey;
+  /** Script type of the address. */
+  scriptKind;
+  /** p2wpkh / p2tr when the address is one we know how to spend from; undefined for other script types. */
+  addressType;
+  /** Smallest output this address type may create, in satoshis. */
+  dustLimit;
+  _config;
+  _client;
+  _network;
+  _networkName;
+  constructor(address, config = {}) {
+    this._config = config;
+    this._networkName = config.network ?? "bitcoin";
+    this._network = networkParams(this._networkName);
+    const decoded = decodeAddress(address, this._network);
+    this.address = address;
+    this.scriptPubKey = decoded.script;
+    this.scriptKind = decoded.kind;
+    this.addressType = decoded.kind === "wpkh" ? "p2wpkh" : decoded.kind === "tr" ? "p2tr" : void 0;
+    this.dustLimit = dustLimit(decoded.kind);
+    this.chain = CAIP2_GENESIS[this._networkName];
+    this._client = createClient(config);
+  }
+  requireClient(what) {
+    if (!this._client) throw new import_core7.NetworkError(`The wallet must be connected to a client to ${what}.`);
+    return this._client;
+  }
+  /** Fee-rate ceiling in sat/vB: `BtcConfig.maxFeeRate` or {@link DEFAULT_MAX_FEE_RATE}. */
+  get maxFeeRate() {
+    return this._config.maxFeeRate ?? DEFAULT_MAX_FEE_RATE;
+  }
+  /** The address. */
+  async getAddress() {
+    return this.address;
+  }
+  /** Confirmed minus pending outgoing (Bitcoin Core wallet semantics). */
+  async getBalance() {
+    const { confirmed, unconfirmed, unconfirmedOutgoing: unconfirmedOutgoing2 } = await this.requireClient("read balances").getBalance(this.address);
+    return unconfirmedOutgoing2 !== void 0 ? confirmed - unconfirmedOutgoing2 : confirmed + unconfirmed;
+  }
+  /** Always throws: Bitcoin has no tokens. */
+  async getTokenBalance(_token) {
+    throw new Error("The 'getTokenBalance' method is not supported on the bitcoin blockchain.");
+  }
+  /** Weight one of OUR inputs adds; throws for address types we cannot spend from. */
+  inputWeight() {
+    if (!this.addressType) throw new UnsupportedAddressTypeError(`Cannot build spends from a ${this.scriptKind} address; only p2wpkh and p2tr accounts spend.`);
+    return INPUT_WEIGHT[this.addressType];
+  }
+  async resolveFeeRate(spend) {
+    if (spend.feeRate !== void 0) {
+      const r = toBig(spend.feeRate);
+      return r < 1n ? 1n : r;
+    }
+    const est = await this.requireClient("estimate fees").estimateFee(spend.confirmationTarget ?? 1);
+    return BigInt(Math.max(Math.ceil(est), 1));
+  }
+  /** Coin selection for a spend (see coinselect.ts). Validates the recipient and the dust floor first. */
+  async planSpend(spend) {
+    const amount = toBig(spend.value);
+    const recipient = decodeAddress(spend.to, this._network);
+    const floor = dustLimit(recipient.kind);
+    if (amount < floor) throw new Error(`The amount must be at least the dust limit of the recipient's address type (${floor} sat).`);
+    const inputWeight = this.inputWeight();
+    const feeRate = await this.resolveFeeRate(spend);
+    const utxos = await this.requireClient("plan a spend").listUnspent(this.address);
+    if (utxos.length === 0) throw new import_core7.InsufficientFundsError(amount, 0n, "BTC");
+    const own = kindOfType(this.addressType);
+    const selection = selectCoins({
+      utxos,
+      targets: [{ value: amount, vbytes: outputVBytes(recipient.kind, recipient.script) }],
+      feeRate,
+      inputWeight,
+      changeVBytes: outputVBytes(own),
+      changeDust: dustLimit(own),
+      maxInputs: this._config.maxInputs ?? MAX_UTXO_INPUTS
+    });
+    return { ...selection, amount, recipientScript: recipient.script, recipientKind: recipient.kind };
+  }
+  /** Fee of a spend in satoshis, from a coin selection at the current fee rate. */
+  async quoteSendTransaction(tx) {
+    const { fee } = await this.planSpend(tx);
+    return { fee };
+  }
+  /**
+   * Fee of a transfer in satoshis.
+   *
+   * @throws Error when `token` is set.
+   */
+  async quoteTransfer(o) {
+    if (o.token) throw new Error("Tokens are not supported on the bitcoin blockchain.");
+    return this.quoteSendTransaction({ to: o.recipient, value: o.amount });
+  }
+  /** Everything spendable in ONE transaction to a single output of our own address type, no change. */
+  async getMaxSpendable(opts = {}) {
+    const inputWeight = this.inputWeight();
+    const feeRate = await this.resolveFeeRate(opts);
+    const utxos = await this.requireClient("plan a spend").listUnspent(this.address);
+    const outKind = opts.to ? decodeAddress(opts.to, this._network).kind : kindOfType(this.addressType);
+    const sweep = selectAll({ utxos, feeRate, inputWeight, outputVBytes: outputVBytes(outKind), maxInputs: this._config.maxInputs ?? MAX_UTXO_INPUTS });
+    const amount = sweep.amount >= dustLimit(outKind) ? sweep.amount : 0n;
+    return { amount, fee: amount > 0n ? sweep.fee : 0n, changeValue: 0n, inputs: amount > 0n ? sweep.utxos.length : 0, feeRate };
+  }
+  /** Undefined until the transaction is mined. */
+  async getTransactionReceipt(hash) {
+    if (!/^[0-9a-fA-F]{64}$/.test(hash)) throw new Error("The 'getTransactionReceipt(hash)' method requires a valid transaction hash.");
+    const client = this.requireClient("fetch transaction receipts");
+    const info = client.getTransactionInfo ? await client.getTransactionInfo(hash) : void 0;
+    if (!info || !info.blockHeight || info.blockHeight <= 0) return void 0;
+    return {
+      hash,
+      status: 1,
+      blockNumber: BigInt(info.blockHeight),
+      confirmations: info.confirmations,
+      ...info.fees !== void 0 ? { fee: BigInt(info.fees) } : {},
+      ...info.hex !== void 0 ? { hex: info.hex } : {}
+    };
+  }
+  /** BIP-137: recover the key and compare its p2wpkh address with ours. Taproot addresses have no BIP-137 form. */
+  async verify(message, signature) {
+    if (this.addressType === "p2tr") throw new UnsupportedAddressTypeError("BIP-137 message signatures do not exist for taproot addresses (BIP-322 is not implemented).");
+    const rec = recoverMessagePublicKey(message, signature);
+    if (!rec || rec.publicKey.length !== 33) return false;
+    try {
+      return spendInfo(rec.publicKey, this._network, "p2wpkh").address === this.address;
+    } catch {
+      return false;
+    }
+  }
+  /** Chain tip for anti-fee-sniping; undefined when disabled or the transport cannot tell. */
+  async lockTimeHeight() {
+    if (this._config.antiFeeSniping === false || !this._client?.getBlockHeight) return 0;
+    try {
+      return await this._client.getBlockHeight();
+    } catch {
+      return 0;
+    }
+  }
+};
+
+// src/account.ts
+var import_core8 = require("@anywalletkit/core");
+var import_btc_signer4 = require("@scure/btc-signer");
+var import_secp256k12 = require("@noble/curves/secp256k1.js");
+var import_base3 = require("@scure/base");
+function addressFor(publicKey, network = "bitcoin", type = "p2wpkh") {
+  return addressFromPublicKey(publicKey, typeof network === "string" ? networkParams(network) : network, type);
+}
+var WalletAccountBtc = class _WalletAccountBtc extends WalletAccountReadOnlyBtc {
+  /** UTXOs, fee rate and tip height come from the network before signing. */
+  needsNetwork = true;
+  /** Derivation path, or `external` for an external signer. */
+  path;
+  /** Compressed secp256k1 public key. */
+  publicKey;
+  addressType;
+  /** The signer that holds the key. */
+  signer;
+  _disposed = false;
+  _readOnly;
+  /** `publicKey` is the signer's compressed secp256k1 key (33 bytes); it is needed synchronously for the address. */
+  constructor(signer, publicKey, path, config = {}) {
+    const type = config.addressType ?? "p2wpkh";
+    super(addressFromPublicKey(publicKey, networkParams(config.network ?? "bitcoin"), type), config);
+    this.addressType = type;
+    this.signer = (0, import_core8.requireCurve)(signer, "secp256k1");
+    const needed = type === "p2tr" ? "schnorr" : "ecdsa";
+    if (!this.signer.schemes.includes(needed)) throw new import_core8.SignerError(`A ${type} account needs a signer with the '${needed}' scheme (has: ${this.signer.schemes.join(", ")}).`);
+    this.publicKey = publicKey;
+    this.path = path;
+  }
+  /** Back-compat: wrap a raw derived key in a {@link LocalSigner} (the account takes ownership; it cannot derive). */
+  static fromPrivateKey(privateKey, publicKey, path, config = {}) {
+    return new _WalletAccountBtc(import_core8.LocalSigner.fromPrivateKey("secp256k1", privateKey, publicKey, path), publicKey, path, config);
+  }
+  /** Account index for the standard m/{84|86}'/{0|1}'/0'/0/i path. */
+  get index() {
+    const m = /^m\/8[46]'\/[01]'\/0'\/0\/(\d+)$/.exec(this.path);
+    return m ? Number(m[1]) : void 0;
+  }
+  live() {
+    if (this._disposed) throw new import_core8.SignerError("This account has been disposed.");
+  }
+  /** BIP-137 p2wpkh signature, base64 (Electrum / Bitcoin Core encoding). Not available for taproot accounts. */
+  async sign(message) {
+    this.live();
+    if (this.addressType === "p2tr") throw new UnsupportedAddressTypeError("BIP-137 message signatures do not exist for taproot accounts (BIP-322 is not implemented).");
+    return signMessageWith(message, this.signer, "p2wpkh");
+  }
+  /** The x-only internal key and its BIP-86 tweak (no script tree) for taproot key-path spends. */
+  taprootKeys() {
+    const xonly = this.publicKey.length === 33 ? this.publicKey.subarray(1) : this.publicKey;
+    return { xonly, tweak: import_secp256k12.schnorr.utils.taggedHash("TapTweak", xonly) };
+  }
+  /**
+   * Sign every input through the signer and attach the witness-ready signature:
+   * p2wpkh → `partialSig` (DER + SIGHASH_ALL), p2tr → `tapKeySig` (64 bytes, DEFAULT).
+   * btc-signer only computes the sighash and assembles the witness; it never sees a key.
+   */
+  async signInputs(tx, values) {
+    if (this.addressType === "p2tr") {
+      const { tweak } = this.taprootKeys();
+      const scripts = Array.from({ length: tx.inputsLength }, () => this.scriptPubKey);
+      for (let i = 0; i < tx.inputsLength; i++) {
+        const sighash = tx.preimageWitnessV1(i, scripts, import_btc_signer4.SigHash.DEFAULT, values);
+        const sig = await this.signer.sign(sighash, { scheme: "schnorr", context: "btc-taproot-keypath", tweak });
+        tx.updateInput(i, { tapKeySig: sig }, true);
+      }
+      return;
+    }
+    const scriptCode = (0, import_btc_signer4.p2pkh)(this.publicKey).script;
+    for (let i = 0; i < tx.inputsLength; i++) {
+      const sighash = tx.preimageWitnessV0(i, scriptCode, import_btc_signer4.SigHash.ALL, values[i]);
+      const rs = await this.signer.sign(sighash, { scheme: "ecdsa", context: "btc-sighash" });
+      const der = import_secp256k12.secp256k1.Signature.fromBytes(rs, "compact").toBytes("der");
+      const sig = new Uint8Array(der.length + 1);
+      sig.set(der, 0);
+      sig[der.length] = import_btc_signer4.SigHash.ALL;
+      tx.updateInput(i, { partialSig: [[this.publicKey, sig]] }, true);
+    }
+  }
+  ctx(intended) {
+    return { network: this._network, ownAddress: this.address, intended, maxFeeRate: this.maxFeeRate };
+  }
+  async buildAndSign(plan, to, recipientValue, change, lockTime, rbf) {
+    const spend = spendInfo(this.publicKey, this._network, this.addressType);
+    const tx = new import_btc_signer4.Transaction({ lockTime });
+    const sequence = rbf ? RBF_SEQUENCE : FINAL_SEQUENCE;
+    for (const u of plan.utxos) {
+      tx.addInput({ ...spend, txid: u.txid, index: u.vout, sequence, witnessUtxo: { script: this.scriptPubKey, amount: u.value } });
+    }
+    tx.addOutputAddress(to, recipientValue, this._network);
+    if (change > 0n) tx.addOutputAddress(this.address, change, this._network);
+    await this.signInputs(tx, plan.utxos.map((u) => u.value));
+    tx.finalize();
+    return tx;
+  }
+  /**
+   * Plan → sign → measure. The plan's fee assumes 72-byte DER signatures; if the
+   * signed vsize somehow needs more, the difference comes out of change (never the
+   * recipient) and the tx is re-signed once.
+   */
+  async buildSignedTransaction(spend) {
+    this.live();
+    const plan = await this.planSpend(spend);
+    await this.verifyPrevouts(plan.utxos);
+    const lockTime = await this.lockTimeHeight();
+    const rbf = spend.rbf ?? this._config.rbf ?? true;
+    let change = plan.change;
+    let fee = plan.fee;
+    let tx = await this.buildAndSign(plan, spend.to, plan.amount, change, lockTime, rbf);
+    const required = BigInt(tx.vsize) * plan.feeRate;
+    if (required > fee) {
+      const delta = required - fee;
+      if (change === 0n) {
+        const have = plan.utxos.reduce((s, u) => s + u.value, 0n);
+        throw new import_core8.InsufficientFundsError(plan.amount + required, have, "BTC");
+      }
+      change = change - delta;
+      if (change < this.dustLimit) {
+        fee = plan.fee + plan.change;
+        change = 0n;
+      } else fee = required;
+      tx = await this.buildAndSign(plan, spend.to, plan.amount, change, lockTime, rbf);
+      if (BigInt(tx.vsize) * plan.feeRate > fee) throw new Error("Fee shortfall after output rebalance.");
+    }
+    const ctx = this.ctx({ to: spend.to, value: plan.amount });
+    const desc = describeTransaction(tx, plan.utxos.map((u) => u.value), ctx);
+    assertSafe(desc, ctx);
+    return { tx, fee, plan, desc };
+  }
+  checkMax(fee, limit, op) {
+    if (limit !== void 0 && fee > BigInt(limit)) throw new Error(`Exceeded maximum fee cost for ${op} operation.`);
+  }
+  /**
+   * BIP-143 (p2wpkh) commits each input's signature to that input's CLAIMED amount
+   * only: an indexer that understates a different coin in each of two signing
+   * sessions can combine their signatures into one valid tx whose real fee the
+   * wallet never showed (scan 2026-10-23 F2). So every p2wpkh coin is read from
+   * its full previous transaction, which must hash to the claimed txid, and its
+   * amount and script must match before anything is signed. Taproot (BIP-341)
+   * commits to every input amount and skips the extra requests.
+   */
+  async verifyPrevouts(utxos) {
+    if (this.addressType === "p2tr") return;
+    const client = this.requireClient("verify the coins it spends");
+    const ours = import_base3.hex.encode(this.scriptPubKey);
+    const cache = /* @__PURE__ */ new Map();
+    for (const u of utxos) {
+      let prev = cache.get(u.txid);
+      if (!prev) {
+        prev = parseRawTransaction(await client.getTransaction(u.txid));
+        if (prev.id !== u.txid) throw new UnsafeTransactionError("prevout-mismatch", `The indexer's transaction for ${u.txid} hashes to ${prev.id}.`);
+        cache.set(u.txid, prev);
+      }
+      const out = u.vout < prev.outputsLength ? prev.getOutput(u.vout) : void 0;
+      if (out?.amount === void 0 || out.amount !== u.value) {
+        throw new UnsafeTransactionError("prevout-mismatch", `Coin ${u.txid}:${u.vout} is worth ${out?.amount ?? "nothing"} sat on chain, not the ${u.value} the indexer reported.`);
+      }
+      if (!out.script || import_base3.hex.encode(out.script) !== ours) throw new UnsafeTransactionError("prevout-mismatch", `Coin ${u.txid}:${u.vout} does not pay this account.`);
+    }
+  }
+  /** Prevout values of a raw tx, fetched through the client (the wire format carries none). */
+  async inputValues(tx) {
+    const client = this.requireClient("inspect a raw transaction");
+    const cache = /* @__PURE__ */ new Map();
+    const values = [];
+    for (let i = 0; i < tx.inputsLength; i++) {
+      const inp = tx.getInput(i);
+      if (!inp.txid || inp.index === void 0) throw new Error("Raw transaction input without a prevout.");
+      const id = import_base3.hex.encode(inp.txid);
+      let prev = cache.get(id);
+      if (!prev) {
+        prev = parseRawTransaction(await client.getTransaction(id));
+        if (prev.id !== id) throw new UnsafeTransactionError("prevout-mismatch", `The indexer's transaction for ${id} hashes to ${prev.id}.`);
+        cache.set(id, prev);
+      }
+      const out = prev.getOutput(inp.index);
+      if (out.amount === void 0) throw new Error(`Prevout ${id}:${inp.index} not found.`);
+      values.push(out.amount);
+    }
+    return values;
+  }
+  /** Describe a raw signed tx (needs the network for prevout values) and run the safety checks. */
+  async describeRaw(rawHex) {
+    const tx = parseRawTransaction(rawHex);
+    const ctx = this.ctx();
+    const desc = describeTransaction(tx, await this.inputValues(tx), ctx);
+    assertSafe(desc, ctx);
+    return { tx, desc };
+  }
+  /** "What you sign": the fully resolved spend (signed, NOT broadcast) or a caller's raw hex. */
+  async describeTransaction(tx) {
+    if (typeof tx === "string") return (await this.describeRaw(tx)).desc;
+    return (await this.buildSignedTransaction(tx)).desc;
+  }
+  /** Sign without broadcasting. Returns the raw transaction hex. Raw hex input is returned unchanged. */
+  async signTransaction(tx) {
+    this.live();
+    if (typeof tx === "string") return tx;
+    const { tx: built, fee } = await this.buildSignedTransaction(tx);
+    this.checkMax(fee, this._config.transactionMaxFee, "transaction");
+    return built.hex;
+  }
+  async quoteSendTransaction(tx) {
+    if (typeof tx === "string") return { fee: (await this.describeRaw(tx)).desc.fee };
+    return super.quoteSendTransaction(tx);
+  }
+  async sendTransaction(tx) {
+    this.live();
+    const client = this.requireClient("send transactions");
+    let rawHex, hash, fee;
+    if (typeof tx === "string") {
+      const { tx: parsed, desc } = await this.describeRaw(tx);
+      rawHex = tx;
+      hash = parsed.id;
+      fee = desc.fee;
+    } else {
+      const built = await this.buildSignedTransaction(tx);
+      rawHex = built.tx.hex;
+      hash = built.tx.id;
+      fee = built.fee;
+    }
+    this.checkMax(fee, this._config.transactionMaxFee, "transaction");
+    const txid = await client.broadcast(rawHex);
+    return { hash: txid || hash, fee };
+  }
+  /** Native BTC only (`token` is rejected). Subject to `transferMaxFee`. */
+  async transfer(o) {
+    if (o.token) throw new Error("Tokens are not supported on the bitcoin blockchain.");
+    this.live();
+    const client = this.requireClient("transfer");
+    const built = await this.buildSignedTransaction({ to: o.recipient, value: o.amount });
+    this.checkMax(built.fee, this._config.transferMaxFee, "transfer");
+    const txid = await client.broadcast(built.tx.hex);
+    return { hash: txid || built.tx.id, fee: built.fee };
+  }
+  /** The same address as a {@link WalletAccountReadOnlyBtc}. */
+  toReadOnlyAccount() {
+    this._readOnly ??= new WalletAccountReadOnlyBtc(this.address, this._config);
+    return this._readOnly;
+  }
+  dispose() {
+    this._disposed = true;
+    this.signer.dispose();
+  }
+};
+
+// src/manager.ts
+var import_core9 = require("@anywalletkit/core");
+var WalletManagerBtc = class extends import_core9.WalletManager {
+  constructor(seedOrSigner, config = {}) {
+    super(seedOrSigner, config);
+  }
+  /**
+   * `m/84'/0'` for p2wpkh or `m/86'/0'` for p2tr on mainnet (coin type 1 on test networks); account
+   * `i` is at `basePath/0'/0/i`.
+   */
+  get basePath() {
+    return `m/${purposeFor(this._config.addressType ?? "p2wpkh")}'/${coinType(this._config.network ?? "bitcoin")}'`;
+  }
+  async getAccount(index = 0) {
+    return this.getAccountByPath(`${this.basePath}/0'/0/${index}`);
+  }
+  async getAccountByPath(path) {
+    const full = path.startsWith("m/") ? path : `${this.basePath}/${path}`;
+    const cached = this._accounts.get(full);
+    if (cached) return cached;
+    const external = this.externalSigner();
+    if (external) return this.fromSigner(external, full);
+    const signer = import_core9.LocalSigner.leafFromSeed(this.seedBytes(), "secp256k1", full);
+    const account = new WalletAccountBtc(signer, signer.publicKey, full, this._config);
+    this._accounts.set(full, account);
+    return account;
+  }
+  /** Resolve `path` against an injected signer: the signer itself, or a child when it can derive there. */
+  async fromSigner(signer, path) {
+    this.requireSigner("secp256k1");
+    let leaf = signer;
+    let key = "external";
+    if ((0, import_core9.isSeedSigner)(signer)) {
+      if (path === signer.path) key = path;
+      else if (path.startsWith(`${signer.path}/`)) {
+        leaf = await (signer.deriveLeaf ?? signer.derive).call(signer, path.slice(signer.path.length + 1));
+        key = path;
+      } else throw new import_core9.SignerError(`The injected signer sits at ${signer.path}; it cannot provide ${path}.`);
+    } else if (path !== `${this.basePath}/0'/0/0` && path !== "external") {
+      throw new import_core9.SignerError(`An external signer has one account; ${path} is not derivable from it.`);
+    }
+    const cached = this._accounts.get(key);
+    if (cached) return cached;
+    const account = new WalletAccountBtc(leaf, await leaf.getPublicKey(), key, this._config);
+    this._accounts.set(key, account);
+    return account;
+  }
+  /** A read-only account for any address, with this manager's config. */
+  getReadOnlyAccount(address) {
+    return new WalletAccountReadOnlyBtc(address, this._config);
+  }
+  /** sat/vB from the client's estimator: fast = 1 block, normal = 3, slow = 6. */
+  async getFeeRates() {
+    const probe = new WalletAccountReadOnlyBtc(
+      (this._config.network ?? "bitcoin") === "bitcoin" ? "bc1qcr8te4kr609gcawutmrza0j4xv80jy8z306fyu" : "tb1q6rz28mcfaxtmd6v789l9rrlrusdprr9pqcpvkl",
+      this._config
+    );
+    const client = probe.requireClient("get fee rates");
+    const [fast, normal, slow] = await Promise.all([1, 3, 6].map((b) => client.estimateFee(b)));
+    const big2 = (n) => BigInt(Math.max(Math.ceil(n), 1));
+    return { slow: big2(slow), normal: big2(normal), fast: big2(fast) };
+  }
+};
+
+// src/history.ts
+var HistoryUnavailableError = class extends Error {
+  chain;
+  reason;
+  attempts;
+  constructor(chain, reason, attempts = []) {
+    super(`History unavailable for ${chain}: ${reason}`);
+    this.name = "HistoryUnavailableError";
+    this.chain = chain;
+    this.reason = reason;
+    this.attempts = attempts;
+  }
+};
+var DEFAULT_LIMIT = 25;
+var MAX_PAGE_SIZE = 100;
+var B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function b64encode(s) {
+  let out = "";
+  for (let i = 0; i < s.length; i += 3) {
+    const c = [s.charCodeAt(i), s.charCodeAt(i + 1), s.charCodeAt(i + 2)];
+    const n = c[0] << 16 | (c[1] || 0) << 8 | (c[2] || 0);
+    out += B64[n >> 18 & 63] + B64[n >> 12 & 63] + (Number.isNaN(c[1]) ? "=" : B64[n >> 6 & 63]) + (Number.isNaN(c[2]) ? "=" : B64[n & 63]);
+  }
+  return out;
+}
+function b64decode(s) {
+  const clean = s.replace(/[^A-Za-z0-9+/]/g, "");
+  let out = "";
+  for (let i = 0; i < clean.length; i += 4) {
+    const c = [0, 1, 2, 3].map((k) => i + k < clean.length ? B64.indexOf(clean[i + k]) : -1);
+    if (c[0] < 0 || c[1] < 0) throw new Error("bad base64");
+    const n = c[0] << 18 | c[1] << 12 | (c[2] < 0 ? 0 : c[2]) << 6 | (c[3] < 0 ? 0 : c[3]);
+    out += String.fromCharCode(n >> 16 & 255);
+    if (c[2] >= 0) out += String.fromCharCode(n >> 8 & 255);
+    if (c[3] >= 0) out += String.fromCharCode(n & 255);
+  }
+  return out;
+}
+function encodeCursor(c) {
+  return b64encode(JSON.stringify(c));
+}
+function decodeCursor(s) {
+  let parsed;
+  try {
+    parsed = JSON.parse(b64decode(s));
+  } catch {
+    throw new Error("@anywalletkit/wallet-btc: malformed history cursor");
+  }
+  const c = parsed;
+  if (!c || c.v !== 1 || !Number.isInteger(c.p) || c.p < 1 || !Number.isInteger(c.s) || c.s < 1) throw new Error("@anywalletkit/wallet-btc: malformed history cursor");
+  return { v: 1, p: c.p, s: c.s };
+}
+var big = (v) => typeof v === "string" && /^-?\d+$/.test(v) ? BigInt(v) : typeof v === "number" ? BigInt(Math.trunc(v)) : 0n;
+function mapBlockbookTx(chain, address, tx) {
+  const owns = (e) => e.isAddress !== false && (e.addresses ?? []).includes(address);
+  let ownIn = 0n, ownOut = 0n, sentToOthers = 0n;
+  for (const vin of tx.vin ?? []) if (owns(vin)) ownIn += big(vin.value);
+  for (const vout of tx.vout ?? []) {
+    if (owns(vout)) ownOut += big(vout.value);
+    else sentToOthers += big(vout.value);
+  }
+  const firstInput = (tx.vin ?? []).find((v) => v.isAddress !== false && v.addresses?.[0])?.addresses?.[0];
+  const firstOtherOutput = (tx.vout ?? []).find((v) => v.isAddress !== false && !owns(v) && v.addresses?.[0])?.addresses?.[0];
+  const transfers = [];
+  let from, to, nativeValue;
+  if (ownIn > 0n) {
+    from = address;
+    to = firstOtherOutput ?? address;
+    nativeValue = firstOtherOutput ? sentToOthers : ownOut;
+    if (nativeValue > 0n) transfers.push({ token: null, from: address, to, amount: nativeValue });
+  } else {
+    from = firstInput ?? "coinbase";
+    to = address;
+    nativeValue = ownOut;
+    if (nativeValue > 0n) transfers.push({ token: null, from, to: address, amount: nativeValue });
+  }
+  const confirmed = tx.confirmations > 0 && tx.blockHeight > 0;
+  const out = {
+    chain,
+    hash: tx.txid,
+    time: tx.blockTime ?? 0,
+    status: confirmed ? "confirmed" : "pending",
+    address,
+    from,
+    to,
+    nativeValue,
+    transfers,
+    raw: { tx, ownIn, ownOut }
+  };
+  if (tx.fees !== void 0) out.fee = big(tx.fees);
+  if (confirmed) out.block = BigInt(tx.blockHeight);
+  return out;
+}
+function btcExplorerTxUrl(hash, network = "bitcoin") {
+  return `https://mempool.space/${network === "testnet" ? "testnet/" : ""}tx/${hash}`;
+}
+function createBtcHistory(options = {}) {
+  const network = options.network ?? "bitcoin";
+  const chain = CAIP2_GENESIS[network];
+  const urls = [...options.blockbookUrls ?? [], ...options.blockbookUrl ? [options.blockbookUrl] : []];
+  if (urls.length === 0) throw new Error("@anywalletkit/wallet-btc: createBtcHistory needs blockbookUrl or blockbookUrls");
+  const fetchFn = options.fetch ?? globalThis.fetch;
+  if (typeof fetchFn !== "function") throw new Error("@anywalletkit/wallet-btc: no global fetch; pass `fetch` in the options");
+  const clients = urls.map((url) => ({ url, client: new BlockbookClient({ url }, fetchFn, options.timeoutMs ?? DEFAULT_TIMEOUT_MS) }));
+  async function failover(run) {
+    const attempts = [];
+    for (const { url, client } of clients) {
+      try {
+        return await run(client);
+      } catch (e) {
+        attempts.push(`${url}: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    }
+    throw new HistoryUnavailableError(chain, attempts[attempts.length - 1] ?? "every Blockbook failed", attempts);
+  }
+  return {
+    chain,
+    async listActivity(address, query = {}) {
+      const cursor = query.cursor ? decodeCursor(query.cursor) : void 0;
+      const pageSize = cursor?.s ?? Math.min(MAX_PAGE_SIZE, Math.max(1, Math.floor(options.pageSize ?? query.limit ?? DEFAULT_LIMIT)));
+      const pageNo = cursor?.p ?? 1;
+      const data = await failover((c) => c.getAddressPage(address, pageNo, pageSize));
+      let items = (data.transactions ?? []).map((tx) => mapBlockbookTx(chain, address, tx));
+      items.sort((a, b) => (b.block === void 0 ? 1 : a.block === void 0 ? -1 : Number(b.block - a.block)) || b.time - a.time);
+      const totalPages = data.totalPages ?? 1;
+      let more = pageNo < totalPages;
+      if (query.since !== void 0) {
+        const since = query.since;
+        if (items.some((t) => t.status === "confirmed" && t.time < since)) more = false;
+        items = items.filter((t) => t.status !== "confirmed" || t.time >= since);
+      }
+      const page = { items, page: pageNo, totalPages };
+      if (more) page.cursor = encodeCursor({ v: 1, p: pageNo + 1, s: pageSize });
+      return page;
+    },
+    async getTransaction(hash, address) {
+      const tx = await failover((c) => c.getTransactionDetails(hash));
+      return tx ? mapBlockbookTx(chain, address, tx) : void 0;
+    },
+    explorerTxUrl(hash) {
+      return btcExplorerTxUrl(hash, network);
+    }
+  };
+}
+//# sourceMappingURL=index.cjs.map