@anywalletkit/wallet-zcash 0.0.0-stage → 0.2.1

package/dist/index.js

@@ -0,0 +1,961 @@
+import {
+  BLOCKCHAIR_URL,
+  BlockchairClient,
+  CAIP2,
+  DEFAULT_TIMEOUT_MS,
+  HistoryUnavailableError,
+  Reader,
+  Writer,
+  blockchairTime,
+  bytesToHex,
+  compactSize,
+  createZcashHistory,
+  decodeCursor,
+  encodeCursor,
+  fetchWithTimeout,
+  hexToBytes,
+  isInt,
+  isIntString,
+  isRecord,
+  mapDashboardTx,
+  reverseBytes,
+  u32le,
+  utf8ToBytes,
+  zcashExplorerTxUrl
+} from "./chunk-GJBPCXQK.js";
+
+// src/address.ts
+import { sha256 } from "@noble/hashes/sha2.js";
+import { ripemd160 } from "@noble/hashes/legacy.js";
+import { base58check } from "@scure/base";
+var b58 = base58check(sha256);
+var PREFIX = {
+  mainnet: { p2pkh: [28, 184], p2sh: [28, 189] },
+  testnet: { p2pkh: [29, 37], p2sh: [28, 186] }
+};
+function addressPrefix(network, kind) {
+  return PREFIX[network][kind];
+}
+function hash160(data) {
+  return ripemd160(sha256(data));
+}
+function scriptFor(kind, hash) {
+  if (hash.length !== 20) throw new Error("A transparent script needs a 20-byte hash");
+  if (kind === "p2pkh") return Uint8Array.of(118, 169, 20, ...hash, 136, 172);
+  return Uint8Array.of(169, 20, ...hash, 135);
+}
+function scriptKind(script) {
+  if (script.length === 25 && script[0] === 118 && script[1] === 169 && script[2] === 20 && script[23] === 136 && script[24] === 172) return "p2pkh";
+  if (script.length === 23 && script[0] === 169 && script[1] === 20 && script[22] === 135) return "p2sh";
+  return "unknown";
+}
+function encodeAddress(kind, hash, network) {
+  if (hash.length !== 20) throw new Error("A transparent address needs a 20-byte hash");
+  const [a, b] = PREFIX[network][kind];
+  return b58.encode(Uint8Array.of(a, b, ...hash));
+}
+function decodeAddress(address, network) {
+  const a = address.trim();
+  if (/^u1|^utest/i.test(a)) throw new Error(`Unified address (${a.slice(0, 6)}\u2026) \u2014 shielded receivers are not supported; use a transparent t-address.`);
+  if (/^zs1|^ztestsapling/i.test(a)) throw new Error("Sapling shielded address (zs1\u2026) \u2014 this wallet sends to transparent t-addresses only.");
+  if (/^zc/i.test(a) && a.length > 90) throw new Error("Sprout address (zc\u2026) \u2014 the Sprout pool is deprecated; use a transparent t-address.");
+  let payload;
+  try {
+    payload = b58.decode(a);
+  } catch (e) {
+    throw new Error(`Invalid Zcash address: ${a}`, { cause: e });
+  }
+  if (payload.length !== 22) throw new Error(`Invalid Zcash address: ${a}`);
+  const p0 = payload[0], p1 = payload[1];
+  for (const net of ["mainnet", "testnet"]) {
+    for (const kind of ["p2pkh", "p2sh"]) {
+      const [a0, a1] = PREFIX[net][kind];
+      if (p0 === a0 && p1 === a1) {
+        if (net !== network) throw new Error(`${a} is a Zcash ${net} address; this wallet is on ${network}.`);
+        const hash = payload.slice(2);
+        return { kind, hash, script: scriptFor(kind, hash) };
+      }
+    }
+  }
+  throw new Error(`Invalid Zcash address: ${a} (unknown version prefix)`);
+}
+function addressFromScript(script, network) {
+  const kind = scriptKind(script);
+  if (kind === "unknown") return void 0;
+  return encodeAddress(kind, kind === "p2pkh" ? script.slice(3, 23) : script.slice(2, 22), network);
+}
+function addressFromPublicKey(publicKey, network = "mainnet") {
+  if (publicKey.length !== 33) throw new Error("Expected a 33-byte compressed public key");
+  return encodeAddress("p2pkh", hash160(publicKey), network);
+}
+function outputSize(script) {
+  return 8 + (script.length < 253 ? 1 : 3) + script.length;
+}
+var DUST_LIMIT = 546n;
+
+// src/fee.ts
+import { InsufficientFundsError } from "@anywalletkit/core";
+var MARGINAL_FEE = 5000n;
+var GRACE_ACTIONS = 2;
+var P2PKH_STANDARD_INPUT_SIZE = 150;
+var P2PKH_STANDARD_OUTPUT_SIZE = 34;
+var P2PKH_INPUT_SIZE = 149;
+var MAX_UTXO_INPUTS = 200;
+function logicalActions(inputSizes2, outputSizes) {
+  const inBytes = inputSizes2.reduce((s, n) => s + n, 0);
+  const outBytes = outputSizes.reduce((s, n) => s + n, 0);
+  return Math.max(Math.ceil(inBytes / P2PKH_STANDARD_INPUT_SIZE), Math.ceil(outBytes / P2PKH_STANDARD_OUTPUT_SIZE));
+}
+function conventionalFee(inputSizes2, outputSizes) {
+  return MARGINAL_FEE * BigInt(Math.max(GRACE_ACTIONS, logicalActions(inputSizes2, outputSizes)));
+}
+function estimateSize(inputs, outputSizes) {
+  const cs = (n) => n < 253 ? 1 : 3;
+  return 20 + cs(inputs) + inputs * P2PKH_INPUT_SIZE + cs(outputSizes.length) + outputSizes.reduce((s, n) => s + n, 0) + 3;
+}
+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 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) {
+  return utxos.filter((u) => u.value > MARGINAL_FEE).sort(cmpUtxo);
+}
+function selectCoins(o) {
+  const maxInputs = o.maxInputs ?? MAX_UTXO_INPUTS;
+  const dust = o.changeDust ?? DUST_LIMIT;
+  const candidates = spendableUtxos(o.utxos);
+  const available = o.utxos.reduce((s, u) => s + u.value, 0n);
+  const inputs = (n) => Array.from({ length: n }, () => P2PKH_INPUT_SIZE);
+  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 convNoChange = conventionalFee(inputs(n), [o.recipientOutputSize]);
+    const feeNoChange = o.fee ?? convNoChange;
+    if (sum < o.target + feeNoChange) continue;
+    const convWithChange = conventionalFee(inputs(n), [o.recipientOutputSize, o.changeOutputSize]);
+    const feeWithChange = o.fee ?? convWithChange;
+    const change = sum - o.target - feeWithChange;
+    if (change >= dust) {
+      return { utxos: selected, fee: feeWithChange, conventionalFee: convWithChange, change, changeFolded: false, size: estimateSize(n, [o.recipientOutputSize, o.changeOutputSize]) };
+    }
+    return { utxos: selected, fee: sum - o.target, conventionalFee: convNoChange, change: 0n, changeFolded: sum - o.target > feeNoChange, size: estimateSize(n, [o.recipientOutputSize]) };
+  }
+  const need = o.target + (o.fee ?? conventionalFee(inputs(Math.max(selected.length, 1)), [o.recipientOutputSize]));
+  throw new InsufficientFundsError(need, available, "ZEC");
+}
+function selectAll(o) {
+  const maxInputs = o.maxInputs ?? MAX_UTXO_INPUTS;
+  const utxos = spendableUtxos(o.utxos).slice(0, maxInputs);
+  if (utxos.length === 0) return { utxos, fee: 0n, amount: 0n, size: 0 };
+  const fee = o.fee ?? conventionalFee(Array.from({ length: utxos.length }, () => P2PKH_INPUT_SIZE), [o.outputSize]);
+  const amount = utxos.reduce((s, u) => s + u.value, 0n) - fee;
+  return { utxos, fee, amount: amount > 0n ? amount : 0n, size: estimateSize(utxos.length, [o.outputSize]) };
+}
+
+// src/tx.ts
+import { blake2b } from "@noble/hashes/blake2.js";
+var TX_VERSION_V5 = 2147483653;
+var VERSION_GROUP_ID_V5 = 648488714;
+var SIGHASH_ALL = 1;
+var MAINNET_UPGRADES = Object.freeze([
+  { name: "NU5", height: 1687104, branchId: 3268858036 },
+  { name: "NU6", height: 2726400, branchId: 3370586197 },
+  { name: "NU6.1", height: 3146400, branchId: 1307332080 },
+  { name: "NU6.3", height: 3428143, branchId: 933566043 }
+]);
+var CURRENT_BRANCH_ID = MAINNET_UPGRADES[MAINNET_UPGRADES.length - 1].branchId;
+function branchIdForHeight(height) {
+  if (height === void 0 || !Number.isFinite(height)) return CURRENT_BRANCH_ID;
+  let id = MAINNET_UPGRADES[0].branchId;
+  for (const u of MAINNET_UPGRADES) if (height >= u.height) id = u.branchId;
+  return id;
+}
+var FINAL_SEQUENCE = 4294967294;
+var MAX_SEQUENCE = 4294967295;
+var assertTxid = (txid2) => {
+  if (!/^[0-9a-fA-F]{64}$/.test(txid2)) throw new Error(`Invalid txid: ${txid2}`);
+};
+function writeTransparent(w, tx) {
+  w.compact(tx.inputs.length);
+  for (const i of tx.inputs) {
+    assertTxid(i.txid);
+    w.bytes(reverseBytes(hexToBytes(i.txid))).u32(i.vout).varBytes(i.scriptSig).u32(i.sequence);
+  }
+  w.compact(tx.outputs.length);
+  for (const o of tx.outputs) {
+    if (o.value < 0n) throw new Error("Negative output value");
+    w.i64(o.value).varBytes(o.script);
+  }
+}
+function serializeTx(tx) {
+  const w = new Writer();
+  w.u32(TX_VERSION_V5).u32(VERSION_GROUP_ID_V5).u32(tx.consensusBranchId >>> 0).u32(tx.lockTime).u32(tx.expiryHeight);
+  writeTransparent(w, tx);
+  w.compact(0);
+  w.compact(0);
+  w.compact(0);
+  return w.finish();
+}
+function parseTx(raw) {
+  const r = new Reader(typeof raw === "string" ? hexToBytes(raw) : raw);
+  const header = r.u32();
+  const overwintered = (header & 2147483648) !== 0;
+  const version = header & 2147483647;
+  if (!overwintered || version !== 5) throw new Error(`Only v5 Zcash transactions are supported here (got version ${version}${overwintered ? "" : ", not overwintered"}).`);
+  const vgid = r.u32();
+  if (vgid !== VERSION_GROUP_ID_V5) throw new Error(`Unexpected version group id 0x${vgid.toString(16)} for a v5 transaction.`);
+  const consensusBranchId = r.u32();
+  const lockTime = r.u32();
+  const expiryHeight = r.u32();
+  const nIn = r.compact();
+  const inputs = [];
+  for (let i = 0; i < nIn; i++) {
+    const txid2 = bytesToHex(reverseBytes(r.bytes(32)));
+    const vout = r.u32();
+    const scriptSig = r.varBytes();
+    const sequence = r.u32();
+    inputs.push({ txid: txid2, vout, scriptSig, sequence });
+  }
+  const nOut = r.compact();
+  const outputs = [];
+  for (let i = 0; i < nOut; i++) outputs.push({ value: r.i64(), script: r.varBytes() });
+  const nSpends = r.compact();
+  const nOutputs = r.compact();
+  if (nSpends !== 0 || nOutputs !== 0) throw new Error("This transaction carries a Sapling bundle; shielded transactions are not supported.");
+  const nActions = r.compact();
+  if (nActions !== 0) throw new Error("This transaction carries an Orchard bundle; shielded transactions are not supported.");
+  if (r.remaining !== 0) throw new Error(`Trailing bytes after the transaction (${r.remaining}).`);
+  return { consensusBranchId, lockTime, expiryHeight, inputs, outputs };
+}
+function personal(tag) {
+  const p = utf8ToBytes(tag);
+  if (p.length !== 16) throw new Error(`BLAKE2b personalization must be 16 bytes: ${tag}`);
+  return p;
+}
+function h(tag, data) {
+  return blake2b(data, { dkLen: 32, personalization: typeof tag === "string" ? personal(tag) : tag });
+}
+var EMPTY = new Uint8Array(0);
+function txHashPersonalization(consensusBranchId) {
+  const p = new Uint8Array(16);
+  p.set(utf8ToBytes("ZcashTxHash_"), 0);
+  p.set(u32le(consensusBranchId >>> 0), 12);
+  return p;
+}
+function headerDigest(tx) {
+  const w = new Writer().u32(TX_VERSION_V5).u32(VERSION_GROUP_ID_V5).u32(tx.consensusBranchId >>> 0).u32(tx.lockTime).u32(tx.expiryHeight);
+  return h("ZTxIdHeadersHash", w.finish());
+}
+function prevoutsDigest(tx) {
+  const w = new Writer();
+  for (const i of tx.inputs) {
+    assertTxid(i.txid);
+    w.bytes(reverseBytes(hexToBytes(i.txid))).u32(i.vout);
+  }
+  return h("ZTxIdPrevoutHash", w.finish());
+}
+function sequenceDigest(tx) {
+  const w = new Writer();
+  for (const i of tx.inputs) w.u32(i.sequence);
+  return h("ZTxIdSequencHash", w.finish());
+}
+function outputsDigest(tx) {
+  const w = new Writer();
+  for (const o of tx.outputs) w.i64(o.value).varBytes(o.script);
+  return h("ZTxIdOutputsHash", w.finish());
+}
+function transparentDigest(tx) {
+  if (tx.inputs.length === 0 && tx.outputs.length === 0) return h("ZTxIdTranspaHash", EMPTY);
+  const w = new Writer().bytes(prevoutsDigest(tx)).bytes(sequenceDigest(tx)).bytes(outputsDigest(tx));
+  return h("ZTxIdTranspaHash", w.finish());
+}
+var saplingDigestEmpty = () => h("ZTxIdSaplingHash", EMPTY);
+var orchardDigestEmpty = () => h("ZTxIdOrchardHash", EMPTY);
+function txidDigest(tx) {
+  const w = new Writer().bytes(headerDigest(tx)).bytes(transparentDigest(tx)).bytes(saplingDigestEmpty()).bytes(orchardDigestEmpty());
+  return h(txHashPersonalization(tx.consensusBranchId), w.finish());
+}
+function txid(tx) {
+  return bytesToHex(reverseBytes(txidDigest(tx)));
+}
+function sighashAll(tx, index, spent) {
+  if (spent.length !== tx.inputs.length) throw new Error(`sighash: ${tx.inputs.length} inputs but ${spent.length} spent outputs`);
+  const input = tx.inputs[index];
+  const coin = spent[index];
+  if (!input || !coin) throw new Error(`sighash: input ${index} does not exist`);
+  const amounts = new Writer();
+  const scripts = new Writer();
+  for (const s of spent) {
+    amounts.i64(s.value);
+    scripts.varBytes(s.script);
+  }
+  const txin = new Writer().bytes(reverseBytes(hexToBytes(input.txid))).u32(input.vout).i64(coin.value).varBytes(coin.script).u32(input.sequence);
+  const t = new Writer().u8(SIGHASH_ALL).bytes(prevoutsDigest(tx)).bytes(h("ZTxTrAmountsHash", amounts.finish())).bytes(h("ZTxTrScriptsHash", scripts.finish())).bytes(sequenceDigest(tx)).bytes(outputsDigest(tx)).bytes(h("Zcash___TxInHash", txin.finish()));
+  const transparentSig = h("ZTxIdTranspaHash", t.finish());
+  const w = new Writer().bytes(headerDigest(tx)).bytes(transparentSig).bytes(saplingDigestEmpty()).bytes(orchardDigestEmpty());
+  return h(txHashPersonalization(tx.consensusBranchId), w.finish());
+}
+function p2pkhScriptSig(derSignature, publicKey) {
+  const sig = new Uint8Array(derSignature.length + 1);
+  sig.set(derSignature, 0);
+  sig[derSignature.length] = SIGHASH_ALL;
+  return new Writer().bytes(compactSize(sig.length)).bytes(sig).bytes(compactSize(publicKey.length)).bytes(publicKey).finish();
+}
+function parseP2pkhScriptSig(scriptSig) {
+  try {
+    const r = new Reader(scriptSig);
+    const sig = r.varBytes();
+    const pub = r.varBytes();
+    if (r.remaining !== 0 || sig.length < 9 || pub.length !== 33 && pub.length !== 65) return void 0;
+    return { signature: sig.slice(0, -1), hashType: sig[sig.length - 1], publicKey: pub };
+  } catch {
+    return void 0;
+  }
+}
+
+// src/describe.ts
+var DEFAULT_MAX_FEE = 1000000n;
+var UnsafeTransactionError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "UnsafeTransactionError";
+    this.code = code;
+  }
+};
+function inputSizes(tx) {
+  return tx.inputs.map((i) => 32 + 4 + (i.scriptSig.length < 253 ? 1 : 3) + i.scriptSig.length + 4);
+}
+function describeTransaction(tx, spent, ctx) {
+  if (spent.length !== tx.inputs.length) throw new Error(`describeTransaction: ${tx.inputs.length} inputs but ${spent.length} spent outputs`);
+  const inputs = tx.inputs.map((i, k) => ({ txid: i.txid, vout: i.vout, value: spent[k].value, address: addressFromScript(spent[k].script, ctx.network) }));
+  const outputs = [];
+  const warnings = /* @__PURE__ */ new Set();
+  for (const o of tx.outputs) {
+    const address = addressFromScript(o.script, ctx.network);
+    const role = address !== void 0 && address === ctx.ownAddress ? "change" : ctx.intended === void 0 ? "recipient" : address !== void 0 && address === ctx.intended.to && o.value === ctx.intended.value ? "recipient" : "unknown";
+    if (scriptKind(o.script) !== "unknown" && o.value < DUST_LIMIT) warnings.add("dust-output");
+    outputs.push({ address, value: o.value, role });
+  }
+  const inputSum = spent.reduce((s, c) => s + c.value, 0n);
+  const outputSum = tx.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 conv = conventionalFee(inputSizes(tx), tx.outputs.map((o) => outputSize(o.script)));
+  if (fee < conv) warnings.add("fee-below-conventional");
+  if (amount > 0n && fee * 10n > amount) warnings.add("fee-over-10pct-of-amount");
+  if (!outputs.some((o) => o.role === "change")) warnings.add("no-change");
+  if (tx.expiryHeight === 0) warnings.add("no-expiry");
+  const signed = tx.inputs.length > 0 && tx.inputs.every((i) => i.scriptSig.length > 0);
+  const desc = {
+    kind: "zcash-transfer",
+    version: 5,
+    consensusBranchId: tx.consensusBranchId,
+    inputs,
+    outputs,
+    amount,
+    fee,
+    conventionalFee: conv,
+    size: serializeTx(tx).length,
+    lockTime: tx.lockTime,
+    expiryHeight: tx.expiryHeight,
+    warnings: [...warnings]
+  };
+  if (signed) desc.txid = txid(tx);
+  return desc;
+}
+function assertSafe(desc, ctx) {
+  const maxFee = ctx.maxFee ?? DEFAULT_MAX_FEE;
+  if (desc.fee < 0n) throw new UnsafeTransactionError("outputs-exceed-inputs", "Outputs exceed inputs.");
+  if (desc.fee > maxFee) throw new UnsafeTransactionError("fee-too-high", `Fee ${desc.fee} zatoshis exceeds the ${maxFee} zatoshi ceiling (maxFee).`);
+  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} zatoshis 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/blockbook.ts
+import { NetworkError } from "@anywalletkit/core";
+var ZcashBlockbookClient = class _ZcashBlockbookClient {
+  base;
+  headers;
+  fetchFn;
+  timeoutMs;
+  constructor(config, fetchFn = globalThis.fetch, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    this.base = config.url.replace(/\/+$/, "").replace(/\/api$/, "");
+    this.headers = { accept: "application/json", ...config.headers ?? {} };
+    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, { headers: this.headers }, this.timeoutMs, this.base);
+    if (!res.ok) throw new NetworkError(`Blockbook request failed: ${res.status} ${res.statusText} (${url})`, { provider: this.base });
+    let body;
+    try {
+      body = await res.json();
+    } catch (e) {
+      throw new NetworkError(`Blockbook returned non-JSON for ${url}`, { provider: this.base, cause: e });
+    }
+    if (!check(body)) throw new 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=basic`, (v) => isRecord(v) && isIntString(v.balance) && isIntString(v.unconfirmedBalance));
+    return { confirmed: BigInt(data.balance), unconfirmed: BigInt(data.unconfirmedBalance) };
+  }
+  async listUnspent(address) {
+    const data = await this.get(`/v2/utxo/${address}`, (v) => Array.isArray(v) && v.every((u) => isRecord(u) && typeof u.txid === "string" && isInt(u.vout) && isIntString(u.value)));
+    return data.map((u) => ({ txid: u.txid, vout: u.vout, value: BigInt(u.value), height: u.height && u.height > 0 ? u.height : -1 }));
+  }
+  static isTx(v) {
+    return isRecord(v) && typeof v.txid === "string" && isInt(v.blockHeight) && isInt(v.confirmations);
+  }
+  async getTransactionDetails(txid2) {
+    try {
+      return await this.get(`/v2/tx/${txid2}`, _ZcashBlockbookClient.isTx);
+    } catch (e) {
+      if (e instanceof NetworkError && /\b(400|404)\b/.test(e.message)) return void 0;
+      throw e;
+    }
+  }
+  async getTransaction(txid2) {
+    const tx = await this.get(`/v2/tx/${txid2}`, _ZcashBlockbookClient.isTx);
+    if (typeof tx.hex !== "string" || !tx.hex) throw new NetworkError(`Transaction ${txid2} has no hex data`, { provider: this.base });
+    return tx.hex;
+  }
+  async getOutput(txid2, vout) {
+    const tx = await this.getTransactionDetails(txid2);
+    const o = tx?.vout?.find((x) => x.n === vout);
+    if (!o || !isIntString(o.value) || typeof o.hex !== "string") return void 0;
+    return { value: BigInt(o.value), script: hexToBytes(o.hex) };
+  }
+  async getTransactionInfo(txid2) {
+    const tx = await this.getTransactionDetails(txid2);
+    if (!tx) return void 0;
+    const info = { txid: tx.txid, blockHeight: tx.blockHeight > 0 ? tx.blockHeight : -1, confirmations: tx.confirmations };
+    if (isIntString(tx.fees)) info.fee = BigInt(tx.fees);
+    if (typeof tx.blockTime === "number") info.blockTime = tx.blockTime;
+    return info;
+  }
+  async broadcast(rawTx) {
+    const data = await this.get(`/v2/sendtx/${rawTx}`, (v) => isRecord(v));
+    if (data.error) throw new Error(`Broadcast rejected: ${typeof data.error === "string" ? data.error : data.error.message ?? "broadcast failed"}`);
+    if (!data.result) throw new NetworkError("Blockbook returned no txid", { provider: this.base });
+    return data.result;
+  }
+  async getBlockHeight() {
+    const data = await this.get("/v2", (v) => isRecord(v));
+    const h2 = data.blockbook?.bestHeight;
+    if (typeof h2 !== "number" || h2 <= 0) throw new NetworkError("Blockbook did not report a block height", { provider: this.base });
+    return h2;
+  }
+};
+
+// src/client.ts
+import { NetworkError as NetworkError2 } 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 "blockchair":
+      return new BlockchairClient(c.clientConfig ?? {}, fetchFn, timeoutMs);
+    case "blockbook-http":
+      return new ZcashBlockbookClient(c.clientConfig, fetchFn, timeoutMs);
+    default:
+      throw new Error(`Unknown Zcash client type: ${String(c.type)}`);
+  }
+}
+var METHODS = ["connect", "close", "getBalance", "listUnspent", "getTransaction", "getOutput", "getTransactionInfo", "broadcast", "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];
+      try {
+        return await c[method].apply(c, args);
+      } catch (e) {
+        if (method === "broadcast" && !(e instanceof NetworkError2)) throw e;
+        last = e;
+      }
+    }
+    throw new NetworkError2(`All Zcash clients failed for ${method}`, { cause: last });
+  };
+  const out = {};
+  for (const m of METHODS) out[m] = call(m);
+  return out;
+}
+
+// src/message.ts
+import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { base64 } from "@scure/base";
+var MAGIC = "Zcash Signed Message:\n";
+var PREFIX2 = utf8ToBytes(MAGIC);
+function magicHash(message) {
+  const msg = typeof message === "string" ? utf8ToBytes(message) : message;
+  const p = compactSize(PREFIX2.length), l = compactSize(msg.length);
+  const buf = new Uint8Array(p.length + PREFIX2.length + l.length + msg.length);
+  let o = 0;
+  for (const part of [p, PREFIX2, l, msg]) {
+    buf.set(part, o);
+    o += part.length;
+  }
+  return sha2562(sha2562(buf));
+}
+function encodeMessageSignature(rs, recovery) {
+  if (rs.length !== 64 || recovery > 3) throw new Error("Expected a 64-byte r\u2016s signature and a recovery id 0..3.");
+  const out = new Uint8Array(65);
+  out[0] = 27 + 4 + recovery;
+  out.set(rs, 1);
+  return base64.encode(out);
+}
+async function signMessageWith(message, signer) {
+  const sig = await signer.sign(magicHash(message), { scheme: "ecdsa-recoverable", context: "zcash-message" });
+  return encodeMessageSignature(sig.subarray(0, 64), sig[64]);
+}
+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 recovered = new Uint8Array(65);
+  recovered[0] = flag & 3;
+  recovered.set(bytes.subarray(1), 1);
+  try {
+    const pub = secp256k1.recoverPublicKey(recovered, magicHash(message), { prehash: false });
+    return pub.length === 33 ? pub : secp256k1.Point.fromBytes(pub).toBytes(true);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/manager.ts
+import { LocalSigner as LocalSigner2, SignerError as SignerError2, WalletManager, isSeedSigner } from "@anywalletkit/core";
+
+// src/account.ts
+import { InsufficientFundsError as InsufficientFundsError3, LocalSigner, SignerError, requireCurve } from "@anywalletkit/core";
+import { secp256k1 as secp256k12 } from "@noble/curves/secp256k1.js";
+
+// src/read-only-account.ts
+import { InsufficientFundsError as InsufficientFundsError2, NetworkError as NetworkError3 } from "@anywalletkit/core";
+var toBig = (v) => typeof v === "bigint" ? v : BigInt(typeof v === "string" ? v.trim() : Math.round(v));
+var WalletAccountReadOnlyZcash = class {
+  /** The transparent address. */
+  address;
+  chain;
+  /** The address's scriptPubKey. */
+  scriptPubKey;
+  /** Script type of the address. */
+  scriptKind;
+  _config;
+  _client;
+  _network;
+  constructor(address, config = {}) {
+    this._config = config;
+    this._network = config.network ?? "mainnet";
+    const decoded = decodeAddress(address, this._network);
+    this.address = address.trim();
+    this.scriptPubKey = decoded.script;
+    this.scriptKind = decoded.kind;
+    this.chain = CAIP2[this._network];
+    this._client = createClient(config);
+  }
+  requireClient(what) {
+    if (!this._client) throw new NetworkError3(`The wallet must be connected to a client to ${what}.`);
+    return this._client;
+  }
+  /** Fee ceiling in zatoshis: `ZcashConfig.maxFee` or the default. */
+  get maxFee() {
+    return this._config.maxFee !== void 0 ? toBig(this._config.maxFee) : DEFAULT_MAX_FEE;
+  }
+  /** The transparent address. */
+  async getAddress() {
+    return this.address;
+  }
+  /** Confirmed plus incoming mempool value (the transports do not expose pending spends of our own outputs). */
+  async getBalance() {
+    const { confirmed, unconfirmed } = await this.requireClient("read balances").getBalance(this.address);
+    return confirmed + unconfirmed;
+  }
+  /** Always throws: Zcash has no tokens. */
+  async getTokenBalance(_token) {
+    throw new Error("The 'getTokenBalance' method is not supported on the zcash blockchain.");
+  }
+  /** Coin selection for a spend (ZIP-317 fee). Validates the recipient and the dust floor first. */
+  async planSpend(spend) {
+    if (this.scriptKind !== "p2pkh") throw new Error(`Cannot build spends from a ${this.scriptKind} address; only P2PKH (t1\u2026) accounts spend.`);
+    const amount = toBig(spend.value);
+    const recipient = decodeAddress(spend.to, this._network);
+    if (amount < DUST_LIMIT) throw new Error(`The amount must be at least the dust limit (${DUST_LIMIT} zatoshis).`);
+    const utxos = await this.requireClient("plan a spend").listUnspent(this.address);
+    if (utxos.length === 0) throw new InsufficientFundsError2(amount, 0n, "ZEC");
+    const selection = selectCoins({
+      utxos,
+      target: amount,
+      recipientOutputSize: outputSize(recipient.script),
+      changeOutputSize: outputSize(this.scriptPubKey),
+      maxInputs: this._config.maxInputs ?? MAX_UTXO_INPUTS,
+      ...spend.fee !== void 0 ? { fee: toBig(spend.fee) } : {}
+    });
+    return { ...selection, amount, recipient };
+  }
+  /** ZIP-317 fee of a spend in zatoshis. */
+  async quoteSendTransaction(tx) {
+    const { fee } = await this.planSpend(tx);
+    return { fee };
+  }
+  /** ZIP-317 fee of a transfer in zatoshis. */
+  async quoteTransfer(o) {
+    if (o.token) throw new Error("Tokens are not supported on the zcash blockchain.");
+    return this.quoteSendTransaction({ to: o.recipient, value: o.amount });
+  }
+  /** Everything spendable in ONE transaction to a single output, no change. */
+  async getMaxSpendable(opts = {}) {
+    const utxos = await this.requireClient("plan a spend").listUnspent(this.address);
+    const outScript = opts.to ? decodeAddress(opts.to, this._network).script : this.scriptPubKey;
+    const sweep = selectAll({ utxos, outputSize: outputSize(outScript), maxInputs: this._config.maxInputs ?? MAX_UTXO_INPUTS, ...opts.fee !== void 0 ? { fee: toBig(opts.fee) } : {} });
+    const amount = sweep.amount >= DUST_LIMIT ? sweep.amount : 0n;
+    return { amount, fee: amount > 0n ? sweep.fee : 0n, changeValue: 0n, inputs: amount > 0n ? sweep.utxos.length : 0 };
+  }
+  /** 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 info = await this.requireClient("fetch transaction receipts").getTransactionInfo(hash);
+    if (!info || info.blockHeight <= 0) return void 0;
+    return { hash, status: 1, blockNumber: BigInt(info.blockHeight), confirmations: info.confirmations, ...info.fee !== void 0 ? { fee: info.fee } : {} };
+  }
+  /** Recover the key from a Zcash message signature and compare its P2PKH address with ours. */
+  async verify(message, signature) {
+    const pub = recoverMessagePublicKey(message, signature);
+    if (!pub) return false;
+    try {
+      return addressFromPublicKey(pub, this._network) === this.address;
+    } catch {
+      return false;
+    }
+  }
+  /** Chain tip for lock time / expiry; undefined when the transport cannot tell. */
+  async tipHeight() {
+    if (!this._client) return void 0;
+    try {
+      return await this._client.getBlockHeight();
+    } catch {
+      return void 0;
+    }
+  }
+};
+
+// src/account.ts
+function addressFor(publicKey, network = "mainnet") {
+  return addressFromPublicKey(publicKey, network);
+}
+var DEFAULT_EXPIRY_DELTA = 40;
+var WalletAccountZcash = class _WalletAccountZcash extends WalletAccountReadOnlyZcash {
+  /** UTXOs and the tip height come from the network before signing. */
+  needsNetwork = true;
+  /** Derivation path, or `external` for an external signer. */
+  path;
+  /** Compressed secp256k1 public key. */
+  publicKey;
+  /** 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 = {}) {
+    super(addressFromPublicKey(publicKey, config.network ?? "mainnet"), config);
+    this.signer = requireCurve(signer, "secp256k1");
+    if (!this.signer.schemes.includes("ecdsa")) throw new SignerError(`A Zcash account needs a signer with the 'ecdsa' 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 _WalletAccountZcash(LocalSigner.fromPrivateKey("secp256k1", privateKey, publicKey, path), publicKey, path, config);
+  }
+  /** Account index for the standard m/44'/133'/0'/0/i path. */
+  get index() {
+    const m = /^m\/44'\/(133|1)'\/0'\/0\/(\d+)$/.exec(this.path);
+    return m ? Number(m[2]) : void 0;
+  }
+  live() {
+    if (this._disposed) throw new SignerError("This account has been disposed.");
+  }
+  /** Zcash message signature (zcashd `signmessage` encoding), base64. */
+  async sign(message) {
+    this.live();
+    return signMessageWith(message, this.signer);
+  }
+  ctx(intended) {
+    return { network: this._network, ownAddress: this.address, intended, maxFee: this.maxFee };
+  }
+  /** Lock time + expiry + branch id from the tip (or the config override). */
+  async chainParams() {
+    const tip = await this.tipHeight();
+    const delta = this._config.expiryDelta ?? DEFAULT_EXPIRY_DELTA;
+    const consensusBranchId = this._config.consensusBranchId ?? branchIdForHeight(tip);
+    const lockTime = tip !== void 0 && this._config.antiFeeSniping !== false ? tip : 0;
+    const expiryHeight = tip !== void 0 && delta > 0 ? tip + delta : 0;
+    return { lockTime, expiryHeight, consensusBranchId };
+  }
+  /** Sign every input through the signer; the scriptSig is `<DER ‖ 0x01> <pubkey>`. */
+  async signInputs(tx, spent) {
+    for (let i = 0; i < tx.inputs.length; i++) {
+      const digest = sighashAll(tx, i, spent);
+      const rs = await this.signer.sign(digest, { scheme: "ecdsa", context: "zcash-sighash" });
+      const der = secp256k12.Signature.fromBytes(rs, "compact").toBytes("der");
+      tx.inputs[i].scriptSig = p2pkhScriptSig(der, this.publicKey);
+    }
+  }
+  async buildSignedTransaction(spend) {
+    this.live();
+    const plan = await this.planSpend(spend);
+    const params = await this.chainParams();
+    const tx = {
+      ...params,
+      inputs: plan.utxos.map((u) => ({ txid: u.txid, vout: u.vout, scriptSig: new Uint8Array(0), sequence: FINAL_SEQUENCE })),
+      outputs: [{ value: plan.amount, script: plan.recipient.script }, ...plan.change > 0n ? [{ value: plan.change, script: this.scriptPubKey }] : []]
+    };
+    const spent = plan.utxos.map((u) => ({ value: u.value, script: this.scriptPubKey }));
+    const have = plan.utxos.reduce((s, u) => s + u.value, 0n);
+    if (have < plan.amount + plan.fee) throw new InsufficientFundsError3(plan.amount + plan.fee, have, "ZEC");
+    await this.signInputs(tx, spent);
+    const ctx = this.ctx({ to: spend.to, value: plan.amount });
+    const desc = describeTransaction(tx, spent, ctx);
+    assertSafe(desc, ctx);
+    const bytes = serializeTx(tx);
+    return { tx, hex: bytesToHex(bytes), txid: txid(tx), fee: plan.fee, plan, desc };
+  }
+  checkMax(fee, limit, op) {
+    if (limit !== void 0 && fee > BigInt(limit)) throw new Error(`Exceeded maximum fee cost for ${op} operation.`);
+  }
+  /** The outputs a raw transaction spends, fetched through the client (the wire format carries no values). */
+  async spentOutputs(tx) {
+    const client = this.requireClient("inspect a raw transaction");
+    const out = [];
+    for (const i of tx.inputs) {
+      const o = await client.getOutput(i.txid, i.vout);
+      if (!o) throw new Error(`Prevout ${i.txid}:${i.vout} not found.`);
+      out.push(o);
+    }
+    return out;
+  }
+  /** Describe a raw signed tx (needs the network for prevouts) and run the safety checks. */
+  async describeRaw(rawHex) {
+    const tx = parseTx(rawHex);
+    const ctx = this.ctx();
+    const desc = describeTransaction(tx, await this.spentOutputs(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 built = await this.buildSignedTransaction(tx);
+    this.checkMax(built.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 = txid(parsed);
+      fee = desc.fee;
+    } else {
+      const built = await this.buildSignedTransaction(tx);
+      rawHex = built.hex;
+      hash = built.txid;
+      fee = built.fee;
+    }
+    this.checkMax(fee, this._config.transactionMaxFee, "transaction");
+    const id = await client.broadcast(rawHex);
+    return { hash: id || hash, fee };
+  }
+  /** Native ZEC only (`token` is rejected). Subject to `transferMaxFee`. */
+  async transfer(o) {
+    if (o.token) throw new Error("Tokens are not supported on the zcash 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 id = await client.broadcast(built.hex);
+    return { hash: id || built.txid, fee: built.fee };
+  }
+  /** The same address as a {@link WalletAccountReadOnlyZcash}. */
+  toReadOnlyAccount() {
+    this._readOnly ??= new WalletAccountReadOnlyZcash(this.address, this._config);
+    return this._readOnly;
+  }
+  dispose() {
+    this._disposed = true;
+    this.signer.dispose();
+  }
+};
+
+// src/manager.ts
+var coinType = (network) => network === "mainnet" ? 133 : 1;
+var WalletManagerZcash = class extends WalletManager {
+  constructor(seedOrSigner, config = {}) {
+    super(seedOrSigner, config);
+  }
+  /** `m/44'/133'` on mainnet (coin type 1 on testnet); account `i` is at `basePath/0'/0/i`. */
+  get basePath() {
+    return `m/44'/${coinType(this._config.network ?? "mainnet")}'`;
+  }
+  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 WalletAccountZcash(signer, signer.publicKey, full, this._config);
+    this._accounts.set(full, account);
+    return account;
+  }
+  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 SignerError2(`The injected signer sits at ${signer.path}; it cannot provide ${path}.`);
+    } else if (path !== `${this.basePath}/0'/0/0` && path !== "external") {
+      throw new SignerError2(`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 WalletAccountZcash(leaf, await leaf.getPublicKey(), key, this._config);
+    this._accounts.set(key, account);
+    return account;
+  }
+  /** A read-only account for any transparent address, with this manager's config. */
+  getReadOnlyAccount(address) {
+    return new WalletAccountReadOnlyZcash(address, this._config);
+  }
+  /** ZIP-317 has no fee market: every tier is the 5000-zatoshi marginal fee per logical action. */
+  async getFeeRates() {
+    return { slow: MARGINAL_FEE, normal: MARGINAL_FEE, fast: MARGINAL_FEE };
+  }
+};
+export {
+  BLOCKCHAIR_URL,
+  BlockchairClient,
+  CAIP2,
+  CURRENT_BRANCH_ID,
+  DEFAULT_EXPIRY_DELTA,
+  DEFAULT_MAX_FEE,
+  DUST_LIMIT,
+  FINAL_SEQUENCE,
+  GRACE_ACTIONS,
+  HistoryUnavailableError,
+  MAINNET_UPGRADES,
+  MARGINAL_FEE,
+  MAX_SEQUENCE,
+  MAX_UTXO_INPUTS,
+  P2PKH_INPUT_SIZE,
+  SIGHASH_ALL,
+  TX_VERSION_V5,
+  TooManyInputsError,
+  UnsafeTransactionError,
+  VERSION_GROUP_ID_V5,
+  WalletAccountReadOnlyZcash,
+  WalletAccountZcash,
+  WalletManagerZcash,
+  ZcashBlockbookClient,
+  addressFor,
+  addressFromPublicKey,
+  addressFromScript,
+  addressPrefix,
+  assertSafe,
+  blockchairTime,
+  branchIdForHeight,
+  coinType,
+  conventionalFee,
+  createClient,
+  createZcashHistory,
+  decodeAddress,
+  decodeCursor as decodeHistoryCursor,
+  WalletManagerZcash as default,
+  describeTransaction,
+  encodeAddress,
+  encodeCursor as encodeHistoryCursor,
+  encodeMessageSignature,
+  estimateSize,
+  hash160,
+  headerDigest,
+  logicalActions,
+  magicHash,
+  mapDashboardTx,
+  outputSize,
+  outputsDigest,
+  p2pkhScriptSig,
+  parseP2pkhScriptSig,
+  parseTx,
+  prevoutsDigest,
+  recoverMessagePublicKey,
+  scriptFor,
+  scriptKind,
+  selectAll,
+  selectCoins,
+  sequenceDigest,
+  serializeTx,
+  sighashAll,
+  signMessageWith,
+  spendableUtxos,
+  transparentDigest,
+  txHashPersonalization,
+  txid,
+  txidDigest,
+  zcashExplorerTxUrl
+};
+//# sourceMappingURL=index.js.map