@anywalletkit/wallet-zcash 0.0.0-stage → 0.2.1

package/dist/index.cjs

@@ -0,0 +1,1355 @@
+"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, {
+  BLOCKCHAIR_URL: () => BLOCKCHAIR_URL,
+  BlockchairClient: () => BlockchairClient,
+  CAIP2: () => CAIP2,
+  CURRENT_BRANCH_ID: () => CURRENT_BRANCH_ID,
+  DEFAULT_EXPIRY_DELTA: () => DEFAULT_EXPIRY_DELTA,
+  DEFAULT_MAX_FEE: () => DEFAULT_MAX_FEE,
+  DUST_LIMIT: () => DUST_LIMIT,
+  FINAL_SEQUENCE: () => FINAL_SEQUENCE,
+  GRACE_ACTIONS: () => GRACE_ACTIONS,
+  HistoryUnavailableError: () => HistoryUnavailableError,
+  MAINNET_UPGRADES: () => MAINNET_UPGRADES,
+  MARGINAL_FEE: () => MARGINAL_FEE,
+  MAX_SEQUENCE: () => MAX_SEQUENCE,
+  MAX_UTXO_INPUTS: () => MAX_UTXO_INPUTS,
+  P2PKH_INPUT_SIZE: () => P2PKH_INPUT_SIZE,
+  SIGHASH_ALL: () => SIGHASH_ALL,
+  TX_VERSION_V5: () => TX_VERSION_V5,
+  TooManyInputsError: () => TooManyInputsError,
+  UnsafeTransactionError: () => UnsafeTransactionError,
+  VERSION_GROUP_ID_V5: () => VERSION_GROUP_ID_V5,
+  WalletAccountReadOnlyZcash: () => WalletAccountReadOnlyZcash,
+  WalletAccountZcash: () => WalletAccountZcash,
+  WalletManagerZcash: () => WalletManagerZcash,
+  ZcashBlockbookClient: () => ZcashBlockbookClient,
+  addressFor: () => addressFor,
+  addressFromPublicKey: () => addressFromPublicKey,
+  addressFromScript: () => addressFromScript,
+  addressPrefix: () => addressPrefix,
+  assertSafe: () => assertSafe,
+  blockchairTime: () => blockchairTime,
+  branchIdForHeight: () => branchIdForHeight,
+  coinType: () => coinType,
+  conventionalFee: () => conventionalFee,
+  createClient: () => createClient,
+  createZcashHistory: () => createZcashHistory,
+  decodeAddress: () => decodeAddress,
+  decodeHistoryCursor: () => decodeCursor,
+  default: () => WalletManagerZcash,
+  describeTransaction: () => describeTransaction,
+  encodeAddress: () => encodeAddress,
+  encodeHistoryCursor: () => encodeCursor,
+  encodeMessageSignature: () => encodeMessageSignature,
+  estimateSize: () => estimateSize,
+  hash160: () => hash160,
+  headerDigest: () => headerDigest,
+  logicalActions: () => logicalActions,
+  magicHash: () => magicHash,
+  mapDashboardTx: () => mapDashboardTx,
+  outputSize: () => outputSize,
+  outputsDigest: () => outputsDigest,
+  p2pkhScriptSig: () => p2pkhScriptSig,
+  parseP2pkhScriptSig: () => parseP2pkhScriptSig,
+  parseTx: () => parseTx,
+  prevoutsDigest: () => prevoutsDigest,
+  recoverMessagePublicKey: () => recoverMessagePublicKey,
+  scriptFor: () => scriptFor,
+  scriptKind: () => scriptKind,
+  selectAll: () => selectAll,
+  selectCoins: () => selectCoins,
+  sequenceDigest: () => sequenceDigest,
+  serializeTx: () => serializeTx,
+  sighashAll: () => sighashAll,
+  signMessageWith: () => signMessageWith,
+  spendableUtxos: () => spendableUtxos,
+  transparentDigest: () => transparentDigest,
+  txHashPersonalization: () => txHashPersonalization,
+  txid: () => txid,
+  txidDigest: () => txidDigest,
+  zcashExplorerTxUrl: () => zcashExplorerTxUrl
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/types.ts
+var CAIP2 = { mainnet: "zcash:mainnet", testnet: "zcash:testnet" };
+
+// src/address.ts
+var import_sha2 = require("@noble/hashes/sha2.js");
+var import_legacy = require("@noble/hashes/legacy.js");
+var import_base = require("@scure/base");
+var b58 = (0, import_base.base58check)(import_sha2.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 (0, import_legacy.ripemd160)((0, import_sha2.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
+var import_core = require("@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 import_core.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
+var import_blake2 = require("@noble/hashes/blake2.js");
+
+// src/encoding.ts
+var import_utils = require("@noble/hashes/utils.js");
+function compactSize(n) {
+  if (!Number.isInteger(n) || n < 0) throw new Error(`CompactSize: ${n} is not a non-negative integer`);
+  if (n < 253) return Uint8Array.of(n);
+  if (n <= 65535) return Uint8Array.of(253, n & 255, n >>> 8);
+  if (n <= 4294967295) return Uint8Array.of(254, n & 255, n >>> 8 & 255, n >>> 16 & 255, n >>> 24);
+  throw new Error("CompactSize: value too large");
+}
+function u32le(n) {
+  if (!Number.isInteger(n) || n < 0 || n > 4294967295) throw new Error(`u32: ${n} out of range`);
+  return Uint8Array.of(n & 255, n >>> 8 & 255, n >>> 16 & 255, n >>> 24);
+}
+function i64le(v) {
+  if (v < -(1n << 63n) || v >= 1n << 63n) throw new Error(`i64: ${v} out of range`);
+  let x = v < 0n ? v + (1n << 64n) : v;
+  const out = new Uint8Array(8);
+  for (let i = 0; i < 8; i++) {
+    out[i] = Number(x & 0xffn);
+    x >>= 8n;
+  }
+  return out;
+}
+var Writer = class {
+  parts = [];
+  u8(n) {
+    this.parts.push(Uint8Array.of(n & 255));
+    return this;
+  }
+  u32(n) {
+    this.parts.push(u32le(n));
+    return this;
+  }
+  i64(v) {
+    this.parts.push(i64le(v));
+    return this;
+  }
+  bytes(b) {
+    this.parts.push(b);
+    return this;
+  }
+  compact(n) {
+    this.parts.push(compactSize(n));
+    return this;
+  }
+  /** CompactSize length prefix + bytes (the "field encoding" of a script). */
+  varBytes(b) {
+    return this.compact(b.length).bytes(b);
+  }
+  finish() {
+    const len = this.parts.reduce((s, p) => s + p.length, 0);
+    const out = new Uint8Array(len);
+    let o = 0;
+    for (const p of this.parts) {
+      out.set(p, o);
+      o += p.length;
+    }
+    return out;
+  }
+};
+var Reader = class {
+  constructor(buf) {
+    this.buf = buf;
+  }
+  buf;
+  offset = 0;
+  get remaining() {
+    return this.buf.length - this.offset;
+  }
+  need(n) {
+    if (this.offset + n > this.buf.length) throw new Error("Transaction truncated");
+  }
+  u8() {
+    this.need(1);
+    return this.buf[this.offset++];
+  }
+  u32() {
+    this.need(4);
+    const b = this.buf;
+    const o = this.offset;
+    this.offset += 4;
+    return (b[o] | b[o + 1] << 8 | b[o + 2] << 16) + b[o + 3] * 16777216;
+  }
+  i64() {
+    this.need(8);
+    let v = 0n;
+    for (let i = 7; i >= 0; i--) v = v << 8n | BigInt(this.buf[this.offset + i]);
+    this.offset += 8;
+    return v >= 1n << 63n ? v - (1n << 64n) : v;
+  }
+  bytes(n) {
+    this.need(n);
+    const out = this.buf.slice(this.offset, this.offset + n);
+    this.offset += n;
+    return out;
+  }
+  compact() {
+    const first = this.u8();
+    if (first < 253) return first;
+    if (first === 253) {
+      this.need(2);
+      const v = this.buf[this.offset] | this.buf[this.offset + 1] << 8;
+      this.offset += 2;
+      return v;
+    }
+    if (first === 254) return this.u32();
+    throw new Error("CompactSize: 64-bit lengths are not supported");
+  }
+  varBytes() {
+    return this.bytes(this.compact());
+  }
+};
+function reverseBytes(b) {
+  return Uint8Array.from(b).reverse();
+}
+
+// src/tx.ts
+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((0, import_utils.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" ? (0, import_utils.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 = (0, import_utils.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 = (0, import_utils.utf8ToBytes)(tag);
+  if (p.length !== 16) throw new Error(`BLAKE2b personalization must be 16 bytes: ${tag}`);
+  return p;
+}
+function h(tag, data) {
+  return (0, import_blake2.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((0, import_utils.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((0, import_utils.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 (0, import_utils.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((0, import_utils.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/blockchair.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 isIntString = (v) => typeof v === "string" && /^-?\d+$/.test(v);
+var isInt = (v) => typeof v === "number" && Number.isInteger(v);
+
+// src/blockchair.ts
+var BLOCKCHAIR_URL = "https://api.blockchair.com/zcash";
+var UTXO_LIMIT = 1e3;
+var isUtxo = (v) => isRecord(v) && isInt(v.block_id) && typeof v.transaction_hash === "string" && isInt(v.index) && typeof v.value === "number";
+var isOutput = (v) => isRecord(v) && isInt(v.index) && typeof v.value === "number" && typeof v.script_hex === "string";
+var isDashboard = (v) => isRecord(v) && isRecord(v.transaction) && isInt(v.transaction.block_id) && typeof v.transaction.hash === "string" && Array.isArray(v.inputs) && v.inputs.every(isOutput) && Array.isArray(v.outputs) && v.outputs.every(isOutput);
+function blockchairTime(s) {
+  if (!s) return void 0;
+  const t = Date.parse(`${s.replace(" ", "T")}Z`);
+  return Number.isFinite(t) ? Math.floor(t / 1e3) : void 0;
+}
+var BlockchairClient = class {
+  base;
+  key;
+  fetchFn;
+  timeoutMs;
+  constructor(config = {}, fetchFn = globalThis.fetch, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    this.base = (config.url ?? BLOCKCHAIR_URL).replace(/\/+$/, "");
+    this.key = config.key;
+    this.fetchFn = fetchFn;
+    this.timeoutMs = timeoutMs;
+  }
+  async connect() {
+  }
+  async close() {
+  }
+  url(path, query = {}) {
+    const q = new URLSearchParams(query);
+    if (this.key) q.set("key", this.key);
+    const s = q.toString();
+    return `${this.base}/${path}${s ? `?${s}` : ""}`;
+  }
+  async request(path, query, init, check) {
+    const url = this.url(path, query);
+    const res = await fetchWithTimeout(this.fetchFn, url, init, this.timeoutMs, this.base);
+    let body;
+    try {
+      body = await res.json();
+    } catch (e) {
+      if (res.status === 402 || res.status === 429 || res.status === 430) throw new import_core3.NetworkError(`Blockchair rate limit (${res.status})`, { provider: this.base });
+      throw new import_core3.NetworkError(`Blockchair returned non-JSON (${res.status}) for ${url}`, { provider: this.base, cause: e });
+    }
+    const env = body;
+    const code = env.context?.code ?? res.status;
+    if (code === 402 || code === 429 || code === 430) throw new import_core3.NetworkError(`Blockchair rate limit (${code})`, { provider: this.base });
+    if (code === 404) throw new NotFound();
+    if (code !== 200 || !res.ok) throw new import_core3.NetworkError(`Blockchair request failed: ${code} ${env.context?.error ?? res.statusText} (${url})`, { provider: this.base });
+    if (!check(env.data)) throw new import_core3.NetworkError(`Blockchair returned an unexpected shape for ${url}`, { provider: this.base });
+    return { data: env.data, state: env.context?.state };
+  }
+  async dashboard(address) {
+    const { data, state } = await this.request(`dashboards/address/${address}`, { limit: `0,${UTXO_LIMIT}` }, void 0, (v) => isRecord(v) && Object.values(v).every((a) => isRecord(a) && isRecord(a.address) && typeof a.address.balance === "number" && Array.isArray(a.utxo) && a.utxo.every(isUtxo)));
+    const entry = data[address] ?? Object.values(data)[0];
+    if (!entry) throw new import_core3.NetworkError(`Blockchair knows no address ${address}`, { provider: this.base });
+    return { address: entry.address, utxo: entry.utxo, transactions: entry.transactions ?? [], state };
+  }
+  /** Transaction hashes of an address, newest first, paged by offset (what the activity history walks). */
+  async listTransactions(address, limit, offset) {
+    const { data } = await this.request(`dashboards/address/${address}`, { limit: `${limit},0`, offset: `${offset},0` }, void 0, (v) => isRecord(v) && Object.values(v).every((a) => isRecord(a) && isRecord(a.address) && (a.transactions === void 0 || Array.isArray(a.transactions))));
+    const entry = data[address] ?? Object.values(data)[0];
+    if (!entry) throw new import_core3.NetworkError(`Blockchair knows no address ${address}`, { provider: this.base });
+    return { hashes: (entry.transactions ?? []).filter((h2) => typeof h2 === "string"), total: entry.address.transaction_count };
+  }
+  /** Confirmed = the UTXOs mined so far; unconfirmed = incoming mempool outputs. (Beyond 1000 UTXOs the dashboard balance is used.) */
+  async getBalance(address) {
+    const d = await this.dashboard(address);
+    let confirmed = 0n, unconfirmed = 0n;
+    for (const u of d.utxo) {
+      if (u.block_id > 0) confirmed += BigInt(u.value);
+      else unconfirmed += BigInt(u.value);
+    }
+    if ((d.address.unspent_output_count ?? d.utxo.length) > d.utxo.length) confirmed = BigInt(d.address.balance) - unconfirmed;
+    return { confirmed, unconfirmed };
+  }
+  async listUnspent(address) {
+    const d = await this.dashboard(address);
+    return d.utxo.map((u) => ({ txid: u.transaction_hash, vout: u.index, value: BigInt(u.value), height: u.block_id > 0 ? u.block_id : -1 }));
+  }
+  async getTransaction(txid2) {
+    const { data } = await this.request(`raw/transaction/${txid2}`, {}, void 0, (v) => isRecord(v) && Object.values(v).every((t) => isRecord(t) && typeof t.raw_transaction === "string"));
+    const hex = (data[txid2] ?? Object.values(data)[0])?.raw_transaction;
+    if (!hex) throw new import_core3.NetworkError(`Transaction ${txid2} has no raw data`, { provider: this.base });
+    return hex;
+  }
+  /** Inputs / outputs with addresses, values and scripts — what the activity history and prevout lookups read. */
+  async getTransactionDashboard(txid2) {
+    try {
+      const { data, state } = await this.request(`dashboards/transaction/${txid2}`, {}, void 0, (v) => isRecord(v) && Object.values(v).every((t2) => t2 === null || isDashboard(t2)));
+      const t = data[txid2] ?? Object.values(data)[0];
+      if (!t) return void 0;
+      return { ...t, transaction: { ...t.transaction, ...state !== void 0 ? { confirmations: t.transaction.block_id > 0 ? state - t.transaction.block_id + 1 : 0 } : {} } };
+    } catch (e) {
+      if (e instanceof NotFound) return void 0;
+      throw e;
+    }
+  }
+  /** Several transactions in one call (Blockchair takes up to 10 comma-separated hashes). */
+  async getTransactionDashboards(txids) {
+    const out = /* @__PURE__ */ new Map();
+    for (let i = 0; i < txids.length; i += 10) {
+      const slice = txids.slice(i, i + 10);
+      const { data, state } = await this.request(`dashboards/transactions/${slice.join(",")}`, {}, void 0, (v) => isRecord(v) && Object.values(v).every((t) => t === null || isDashboard(t)));
+      for (const [hash, t] of Object.entries(data)) {
+        if (!t) continue;
+        const confirmations = state !== void 0 && t.transaction.block_id > 0 ? state - t.transaction.block_id + 1 : 0;
+        out.set(hash, { ...t, transaction: { ...t.transaction, confirmations } });
+      }
+    }
+    return out;
+  }
+  async getOutput(txid2, vout) {
+    const d = await this.getTransactionDashboard(txid2);
+    const o = d?.outputs.find((x) => x.index === vout);
+    return o ? { value: BigInt(o.value), script: (0, import_utils.hexToBytes)(o.script_hex) } : void 0;
+  }
+  async getTransactionInfo(txid2) {
+    const d = await this.getTransactionDashboard(txid2);
+    if (!d) return void 0;
+    const t = d.transaction;
+    const info = { txid: t.hash, blockHeight: t.block_id > 0 ? t.block_id : -1, confirmations: t.confirmations ?? 0 };
+    if (typeof t.fee === "number") info.fee = BigInt(t.fee);
+    const time = blockchairTime(t.time);
+    if (time !== void 0) info.blockTime = time;
+    return info;
+  }
+  async broadcast(rawTx) {
+    const body = `data=${encodeURIComponent(rawTx)}`;
+    const url = this.url("push/transaction");
+    const res = await fetchWithTimeout(this.fetchFn, url, { method: "POST", headers: { "content-type": "application/x-www-form-urlencoded" }, body }, this.timeoutMs, this.base);
+    let env = {};
+    try {
+      env = await res.json();
+    } catch {
+    }
+    const hash = env.data?.transaction_hash;
+    if (hash) return hash;
+    const reason = env.context?.error ?? `${res.status} ${res.statusText}`;
+    throw new Error(`Broadcast rejected: ${reason}`);
+  }
+  async getBlockHeight() {
+    const { data } = await this.request("stats", {}, void 0, (v) => isRecord(v) && isInt(v.best_block_height));
+    if (data.best_block_height <= 0) throw new import_core3.NetworkError("Blockchair reported no block height", { provider: this.base });
+    return data.best_block_height;
+  }
+};
+var NotFound = class extends Error {
+  constructor() {
+    super("not found");
+    this.name = "NotFound";
+  }
+};
+
+// src/blockbook.ts
+var import_core4 = require("@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 import_core4.NetworkError(`Blockbook request failed: ${res.status} ${res.statusText} (${url})`, { provider: this.base });
+    let body;
+    try {
+      body = await res.json();
+    } catch (e) {
+      throw new import_core4.NetworkError(`Blockbook returned non-JSON for ${url}`, { provider: this.base, cause: e });
+    }
+    if (!check(body)) throw new import_core4.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 import_core4.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 import_core4.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: (0, import_utils.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 import_core4.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 import_core4.NetworkError("Blockbook did not report a block height", { provider: this.base });
+    return h2;
+  }
+};
+
+// 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 "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 import_core5.NetworkError)) throw e;
+        last = e;
+      }
+    }
+    throw new import_core5.NetworkError(`All Zcash clients failed for ${method}`, { cause: last });
+  };
+  const out = {};
+  for (const m of METHODS) out[m] = call(m);
+  return out;
+}
+
+// src/message.ts
+var import_sha22 = require("@noble/hashes/sha2.js");
+var import_secp256k1 = require("@noble/curves/secp256k1.js");
+var import_base2 = require("@scure/base");
+var MAGIC = "Zcash Signed Message:\n";
+var PREFIX2 = (0, import_utils.utf8ToBytes)(MAGIC);
+function magicHash(message) {
+  const msg = typeof message === "string" ? (0, import_utils.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 (0, import_sha22.sha256)((0, import_sha22.sha256)(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 import_base2.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 = import_base2.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 = import_secp256k1.secp256k1.recoverPublicKey(recovered, magicHash(message), { prehash: false });
+    return pub.length === 33 ? pub : import_secp256k1.secp256k1.Point.fromBytes(pub).toBytes(true);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/manager.ts
+var import_core8 = require("@anywalletkit/core");
+
+// src/account.ts
+var import_core7 = require("@anywalletkit/core");
+var import_secp256k12 = require("@noble/curves/secp256k1.js");
+
+// src/read-only-account.ts
+var import_core6 = require("@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 import_core6.NetworkError(`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 import_core6.InsufficientFundsError(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 = (0, import_core7.requireCurve)(signer, "secp256k1");
+    if (!this.signer.schemes.includes("ecdsa")) throw new import_core7.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(import_core7.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 import_core7.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 = import_secp256k12.secp256k1.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 import_core7.InsufficientFundsError(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: (0, import_utils.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 import_core8.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 = import_core8.LocalSigner.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 ((0, import_core8.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_core8.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_core8.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 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 };
+  }
+};
+
+// src/history.ts
+var HistoryUnavailableError = class extends Error {
+  chain;
+  reason;
+  constructor(chain, reason) {
+    super(`History unavailable for ${chain}: ${reason}`);
+    this.name = "HistoryUnavailableError";
+    this.chain = chain;
+    this.reason = reason;
+  }
+};
+var DEFAULT_LIMIT = 25;
+var MAX_PAGE_SIZE = 100;
+function encodeCursor(c) {
+  return `${c.v}:${c.o}:${c.s}`;
+}
+function decodeCursor(s) {
+  const m = /^1:(\d+):(\d+)$/.exec(s);
+  if (!m) throw new Error("@anywalletkit/wallet-zcash: malformed history cursor");
+  const o = Number(m[1]), size = Number(m[2]);
+  if (size < 1) throw new Error("@anywalletkit/wallet-zcash: malformed history cursor");
+  return { v: 1, o, s: size };
+}
+function mapDashboardTx(chain, address, d) {
+  let ownIn = 0n, ownOut = 0n, sentToOthers = 0n;
+  for (const i of d.inputs) if (i.recipient === address) ownIn += BigInt(i.value);
+  for (const o of d.outputs) {
+    if (o.recipient === address) ownOut += BigInt(o.value);
+    else sentToOthers += BigInt(o.value);
+  }
+  const firstInput = d.inputs.find((i) => i.recipient)?.recipient;
+  const firstOther = d.outputs.find((o) => o.recipient && o.recipient !== address)?.recipient;
+  const transfers = [];
+  let from, to, nativeValue;
+  if (ownIn > 0n) {
+    from = address;
+    to = firstOther ?? address;
+    nativeValue = firstOther ? sentToOthers : ownOut;
+    if (nativeValue > 0n) transfers.push({ token: null, from: address, to, amount: nativeValue });
+  } else {
+    from = firstInput ?? (d.inputs.length === 0 ? "shielded" : "coinbase");
+    to = address;
+    nativeValue = ownOut;
+    if (nativeValue > 0n) transfers.push({ token: null, from, to: address, amount: nativeValue });
+  }
+  const t = d.transaction;
+  const confirmed = t.block_id > 0;
+  const out = {
+    chain,
+    hash: t.hash,
+    time: blockchairTime(t.time) ?? 0,
+    status: confirmed ? "confirmed" : "pending",
+    address,
+    from,
+    to,
+    nativeValue,
+    transfers,
+    raw: { tx: d, ownIn, ownOut }
+  };
+  if (typeof t.fee === "number") out.fee = BigInt(t.fee);
+  if (confirmed) out.block = BigInt(t.block_id);
+  return out;
+}
+function zcashExplorerTxUrl(hash) {
+  return `https://blockchair.com/zcash/transaction/${hash}`;
+}
+function createZcashHistory(options = {}) {
+  const chain = CAIP2.mainnet;
+  const fetchFn = options.fetch ?? globalThis.fetch;
+  if (typeof fetchFn !== "function") throw new Error("@anywalletkit/wallet-zcash: no global fetch; pass `fetch` in the options");
+  const client = new BlockchairClient({ ...options.blockchairUrl ? { url: options.blockchairUrl } : {}, ...options.key ? { key: options.key } : {} }, fetchFn, options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  const wrap = async (run) => {
+    try {
+      return await run();
+    } catch (e) {
+      throw new HistoryUnavailableError(chain, e instanceof Error ? e.message : String(e));
+    }
+  };
+  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 offset = cursor?.o ?? 0;
+      const { hashes, total } = await wrap(() => client.listTransactions(address, pageSize, offset));
+      const dashboards = hashes.length ? await wrap(() => client.getTransactionDashboards(hashes)) : /* @__PURE__ */ new Map();
+      let items = hashes.map((h2) => dashboards.get(h2)).filter((d) => !!d).map((d) => mapDashboardTx(chain, address, d));
+      items.sort((a, b) => (b.block === void 0 ? 1 : a.block === void 0 ? -1 : Number(b.block - a.block)) || b.time - a.time);
+      let more = total !== void 0 ? offset + hashes.length < total : hashes.length === pageSize;
+      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, offset, ...total !== void 0 ? { total } : {} };
+      if (more) page.cursor = encodeCursor({ v: 1, o: offset + hashes.length, s: pageSize });
+      return page;
+    },
+    async getTransaction(hash, address) {
+      const d = await wrap(() => client.getTransactionDashboard(hash));
+      return d ? mapDashboardTx(chain, address, d) : void 0;
+    },
+    explorerTxUrl: zcashExplorerTxUrl
+  };
+}
+//# sourceMappingURL=index.cjs.map