@anywalletkit/wallet-btc 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,966 @@
+import {
+  BlockbookClient,
+  CAIP2_GENESIS,
+  DEFAULT_TIMEOUT_MS,
+  HistoryUnavailableError,
+  btcExplorerTxUrl,
+  createBtcHistory,
+  decodeCursor,
+  encodeCursor,
+  fetchWithTimeout,
+  isHex64,
+  isRecord,
+  mapBlockbookTx,
+  unconfirmedOutgoing
+} from "./chunk-KAAQYL5X.js";
+
+// src/errors.ts
+import { InsufficientFundsError, NetworkError, SignerError } from "@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/esplora.ts
+import { NetworkError as NetworkError2 } from "@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 NetworkError2(`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 NetworkError2(`Esplora returned non-JSON for ${path}`, { provider: this.base, cause: e });
+    }
+    if (!check(body)) throw new NetworkError2(`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 NetworkError2 && /\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 NetworkError2(`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 NetworkError2(`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 NetworkError2("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 NetworkError2("Esplora did not report a block height", { provider: this.base });
+    return h;
+  }
+};
+
+// src/client.ts
+import { NetworkError as NetworkError3 } from "@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 NetworkError3(`All BTC clients failed for ${method}`, { cause: last });
+  };
+  const out = {};
+  for (const m of METHODS) out[m] = call(m);
+  return out;
+}
+
+// src/message.ts
+import { sha256 } from "@noble/hashes/sha2.js";
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { base64 } from "@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 sha256(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 base64.encode(out);
+}
+function signMessage(message, privateKey, segwitType = "p2wpkh") {
+  const sig = 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 = 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 = secp256k1.recoverPublicKey(recovered, magicHash(message), { prehash: false });
+    const publicKey = compressed ? pub : secp256k1.Point.fromBytes(pub).toBytes(false);
+    return { publicKey, segwitType: segwit };
+  } catch {
+    return void 0;
+  }
+}
+
+// src/coinselect.ts
+import { InsufficientFundsError as InsufficientFundsError2 } from "@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 InsufficientFundsError2(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
+import { Transaction } from "@scure/btc-signer";
+import { hex } from "@scure/base";
+
+// src/address.ts
+import { Address, OutScript, p2tr, p2wpkh } from "@scure/btc-signer";
+function decodeAddress(address, network) {
+  let decoded;
+  try {
+    decoded = Address(network).decode(address);
+  } catch (e) {
+    throw new Error(`Invalid bitcoin address for this network: ${address}`, { cause: e });
+  }
+  return { script: OutScript.encode(decoded), kind: decoded.type };
+}
+function addressFromScript(script, network) {
+  try {
+    return Address(network).encode(OutScript.decode(script));
+  } catch {
+    return void 0;
+  }
+}
+function scriptKind(script) {
+  try {
+    return OutScript.decode(script).type;
+  } catch {
+    return "unknown";
+  }
+}
+function spendInfo(publicKey, network, type) {
+  if (type === "p2tr") return p2tr(publicKey.length === 33 ? publicKey.subarray(1) : publicKey, void 0, network);
+  return 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 Transaction.fromRaw(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 ? 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
+import { NETWORK, TEST_NETWORK } from "@scure/btc-signer";
+var REGTEST_NETWORK = Object.freeze({ bech32: "bcrt", pubKeyHash: 111, scriptHash: 196, wif: 239 });
+function networkParams(network) {
+  switch (network) {
+    case "bitcoin":
+      return NETWORK;
+    case "testnet":
+      return 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
+import { InsufficientFundsError as InsufficientFundsError3, NetworkError as NetworkError4 } from "@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 NetworkError4(`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 InsufficientFundsError3(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
+import { InsufficientFundsError as InsufficientFundsError4, LocalSigner, SignerError as SignerError2, requireCurve } from "@anywalletkit/core";
+import { SigHash, Transaction as Transaction2, p2pkh } from "@scure/btc-signer";
+import { schnorr, secp256k1 as secp256k12 } from "@noble/curves/secp256k1.js";
+import { hex as hex2 } from "@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 = requireCurve(signer, "secp256k1");
+    const needed = type === "p2tr" ? "schnorr" : "ecdsa";
+    if (!this.signer.schemes.includes(needed)) throw new SignerError2(`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(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 SignerError2("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: 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, 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 = p2pkh(this.publicKey).script;
+    for (let i = 0; i < tx.inputsLength; i++) {
+      const sighash = tx.preimageWitnessV0(i, scriptCode, SigHash.ALL, values[i]);
+      const rs = await this.signer.sign(sighash, { scheme: "ecdsa", context: "btc-sighash" });
+      const der = secp256k12.Signature.fromBytes(rs, "compact").toBytes("der");
+      const sig = new Uint8Array(der.length + 1);
+      sig.set(der, 0);
+      sig[der.length] = 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 Transaction2({ 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 InsufficientFundsError4(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 = hex2.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 || hex2.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 = hex2.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
+import { LocalSigner as LocalSigner2, SignerError as SignerError3, WalletManager, isSeedSigner } from "@anywalletkit/core";
+var WalletManagerBtc = class extends 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 = LocalSigner2.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 (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 SignerError3(`The injected signer sits at ${signer.path}; it cannot provide ${path}.`);
+    } else if (path !== `${this.basePath}/0'/0/0` && path !== "external") {
+      throw new SignerError3(`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 big = (n) => BigInt(Math.max(Math.ceil(n), 1));
+    return { slow: big(slow), normal: big(normal), fast: big(fast) };
+  }
+};
+export {
+  BlockbookClient,
+  CAIP2_GENESIS,
+  DEFAULT_MAX_FEE_RATE,
+  DUST_LIMIT_P2TR,
+  DUST_LIMIT_P2WPKH,
+  EsploraClient,
+  FINAL_SEQUENCE,
+  HistoryUnavailableError,
+  INPUT_WEIGHT,
+  MAX_UTXO_INPUTS,
+  RBF_SEQUENCE,
+  REGTEST_NETWORK,
+  TooManyInputsError,
+  UnsafeTransactionError,
+  UnsupportedAddressTypeError,
+  WalletAccountBtc,
+  WalletAccountReadOnlyBtc,
+  WalletManagerBtc,
+  addressFor,
+  addressFromPublicKey,
+  addressFromScript,
+  assertSafe,
+  btcExplorerTxUrl,
+  coinType,
+  createBtcHistory,
+  createClient,
+  decodeAddress,
+  decodeCursor as decodeHistoryCursor,
+  WalletManagerBtc as default,
+  describeTransaction,
+  dustLimit,
+  encodeCursor as encodeHistoryCursor,
+  encodeMessageSignature,
+  estimateVsize,
+  magicHash,
+  mapBlockbookTx,
+  networkParams,
+  outputVBytes,
+  parseRawTransaction,
+  purposeFor,
+  recoverMessagePublicKey,
+  scriptKind,
+  selectAll,
+  selectCoins,
+  signMessage,
+  signMessageWith,
+  spendableUtxos,
+  unconfirmedOutgoing
+};
+//# sourceMappingURL=index.js.map