@secondlayer/verify 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,1720 @@
+// src/bytes.ts
+import { sha512_256 } from "@noble/hashes/sha2.js";
+import { bytesToHex, concatBytes, hexToBytes } from "@noble/hashes/utils.js";
+var hex = (b) => bytesToHex(b);
+var unhex = (s) => hexToBytes(s.startsWith("0x") ? s.slice(2) : s);
+var concat = (parts) => concatBytes(...parts);
+var bytesEqual = (a, b) => {
+  if (a.length !== b.length)
+    return false;
+  for (let i = 0;i < a.length; i++)
+    if (a[i] !== b[i])
+      return false;
+  return true;
+};
+var hashAll = (parts) => {
+  const h = sha512_256.create();
+  for (const p of parts)
+    h.update(p);
+  return h.digest();
+};
+
+class Reader {
+  buf;
+  pos = 0;
+  constructor(buf) {
+    this.buf = buf;
+  }
+  bytes(n) {
+    if (n < 0 || this.pos + n > this.buf.length)
+      throw new Error(`unexpected end of input at ${this.pos} reading ${n}`);
+    const out = this.buf.subarray(this.pos, this.pos + n);
+    this.pos += n;
+    return out;
+  }
+  view(n) {
+    const b = this.bytes(n);
+    return new DataView(b.buffer, b.byteOffset, n);
+  }
+  u8 = () => this.bytes(1)[0];
+  u16 = () => this.view(2).getUint16(0);
+  u32 = () => this.view(4).getUint32(0);
+  u64 = () => this.view(8).getBigUint64(0);
+  i64 = () => this.view(8).getBigInt64(0);
+  vec(item, max) {
+    const n = this.u32();
+    if (n > max)
+      throw new Error(`vec length ${n} exceeds ${max}`);
+    return Array.from({ length: n }, item);
+  }
+  get done() {
+    return this.pos === this.buf.length;
+  }
+}
+// src/header.ts
+import { sha512_256 as sha512_2562 } from "@noble/hashes/sha2.js";
+var NAKAMOTO_BLOCK_VERSION_EPOCH_4 = 1;
+var MAX_SIGNERS = 4000;
+var MAX_PROBLEMATIC_TXS = 1 << 16;
+function parseNakamotoHeader(raw) {
+  const r = new Reader(raw);
+  const version = r.u8();
+  const chainLength = r.u64();
+  const burnSpent = r.u64();
+  const consensusHash = r.bytes(20);
+  const parentBlockId = r.bytes(32);
+  const txMerkleRoot = r.bytes(32);
+  const stateIndexRoot = r.bytes(32);
+  const timestamp = r.u64();
+  const minerSignature = r.bytes(65);
+  const sigStart = r.pos;
+  const signerSignatures = r.vec(() => r.bytes(65), MAX_SIGNERS);
+  const sigEnd = r.pos;
+  const bits = r.u16();
+  if (bits === 0 || bits > MAX_SIGNERS)
+    throw new Error(`bad pox_treatment length ${bits}`);
+  const bitBytes = Math.ceil(bits / 8);
+  if (r.u32() !== bitBytes)
+    throw new Error("bad pox_treatment data length");
+  r.bytes(bitBytes);
+  if ((version & 127) >= NAKAMOTO_BLOCK_VERSION_EPOCH_4) {
+    r.vec(() => r.bytes(5), MAX_PROBLEMATIC_TXS);
+  }
+  const end = r.pos;
+  return {
+    version,
+    chainLength,
+    burnSpent,
+    consensusHash,
+    parentBlockId,
+    txMerkleRoot,
+    stateIndexRoot,
+    timestamp,
+    minerSignature,
+    signerSignatures,
+    signerSighashPreimage: concat([
+      raw.subarray(0, sigStart),
+      raw.subarray(sigEnd, end)
+    ]),
+    byteLength: end
+  };
+}
+var signerSignatureHash = (h) => sha512_2562(h.signerSighashPreimage);
+var blockId = (h) => hashAll([signerSignatureHash(h), h.consensusHash]);
+// src/marf.ts
+import { sha512_256 as sha512_2563 } from "@noble/hashes/sha2.js";
+var MARF_VALUE_SIZE = 40;
+var NodeId = {
+  Empty: 0,
+  Leaf: 1,
+  Node4: 2,
+  Node16: 3,
+  Node48: 4,
+  Node256: 5
+};
+var NODE_PTR_COUNT = {
+  [NodeId.Node4]: 4,
+  [NodeId.Node16]: 16,
+  [NodeId.Node48]: 48,
+  [NodeId.Node256]: 256
+};
+var isBackptr = (id) => (id & 128) !== 0;
+var marfPath = (key) => sha512_2563(new TextEncoder().encode(key));
+function marfValue(value) {
+  const v = new Uint8Array(MARF_VALUE_SIZE);
+  v.set(sha512_2563(new TextEncoder().encode(value)));
+  return v;
+}
+function pathPreimage(path) {
+  if (path.length > 32)
+    throw new Error("trie path longer than 32 bytes");
+  return concat([Uint8Array.of(path.length), path]);
+}
+var leafHash = (path, value) => hashAll([Uint8Array.of(NodeId.Leaf), pathPreimage(path), value]);
+function nodeHash(node, children) {
+  const parts = [Uint8Array.of(node.id)];
+  for (const p of node.ptrs)
+    parts.push(Uint8Array.of(p.id, p.chr), p.backBlock);
+  parts.push(pathPreimage(node.path), ...children);
+  return hashAll(parts);
+}
+var PROOF_KIND = [
+  "Node4",
+  "Node16",
+  "Node48",
+  "Node256",
+  "Leaf",
+  "Shunt"
+];
+var KIND_PTRS = {
+  Node4: 4,
+  Node16: 16,
+  Node48: 48,
+  Node256: 256
+};
+function decodeProof(bytes) {
+  const r = new Reader(bytes);
+  const hash = () => r.bytes(32);
+  const steps = r.vec(() => {
+    const kind = PROOF_KIND[r.u8()];
+    if (!kind)
+      throw new Error("bad proof step type");
+    if (kind === "Shunt")
+      return { kind, idx: r.i64(), hashes: r.vec(hash, 1 << 20) };
+    const chr = r.u8();
+    if (kind === "Leaf")
+      return {
+        kind,
+        chr,
+        path: r.bytes(r.u32()),
+        value: r.bytes(MARF_VALUE_SIZE)
+      };
+    const node = {
+      id: r.u8(),
+      path: r.bytes(r.u32()),
+      ptrs: r.vec(() => ({ id: r.u8(), chr: r.u8(), backBlock: r.bytes(32) }), 256)
+    };
+    const hashes = Array.from({ length: KIND_PTRS[kind] - 1 }, hash);
+    return { kind, chr, node, hashes };
+  }, 1 << 20);
+  if (!r.done)
+    throw new Error("trailing bytes after proof");
+  return steps;
+}
+var isShunt = (s) => s?.kind === "Shunt";
+var segmentEnd = (p, i) => {
+  let j = i + 1;
+  while (j < p.length && !isShunt(p[j]))
+    j++;
+  return j;
+};
+function segmentProofHash(step, childHash) {
+  const count = KIND_PTRS[step.kind];
+  if (step.node.ptrs.length !== count)
+    return null;
+  const all = [];
+  let ih = 0;
+  for (const p of step.node.ptrs) {
+    if (p.id !== NodeId.Empty && p.chr === step.chr)
+      all.push(childHash);
+    else {
+      const h = step.hashes[ih++];
+      if (!h)
+        return null;
+      all.push(h);
+    }
+  }
+  return all.length === count ? nodeHash(step.node, all) : null;
+}
+function verifySegment(seg, start) {
+  let h = start;
+  for (const s of seg) {
+    if (s.kind === "Shunt" || !h)
+      return null;
+    h = s.kind === "Leaf" ? leafHash(s.path, s.value) : segmentProofHash(s, h);
+  }
+  return h;
+}
+function segmentPathPrefix(seg) {
+  const parts = [];
+  for (const s of seg) {
+    if (s.kind === "Shunt")
+      return null;
+    if (s.kind === "Leaf")
+      parts.push(s.path);
+    else
+      parts.push(Uint8Array.of(s.chr), s.node.path);
+  }
+  return concat(parts.reverse());
+}
+function isWellFormed(p, expectedPath) {
+  if (p[0]?.kind !== "Leaf")
+    return false;
+  let i = 0;
+  let path = new Uint8Array;
+  while (i < p.length) {
+    const j = segmentEnd(p, i);
+    const prefix = segmentPathPrefix(p.slice(i, j));
+    if (!prefix)
+      return false;
+    if (i === 0) {
+      if (!bytesEqual(prefix, expectedPath))
+        return false;
+      path = prefix;
+    } else if (prefix.length > path.length || !bytesEqual(path.subarray(0, prefix.length), prefix))
+      return false;
+    i = j;
+    if (i >= p.length)
+      return false;
+    let k = i + 1;
+    while (k < p.length && isShunt(p[k]))
+      k++;
+    i = k;
+  }
+  return true;
+}
+function shuntHash(lead, idx, inserted, hashes) {
+  if (idx === 0n)
+    return null;
+  const all = lead ? [lead] : [];
+  let hi = 0;
+  for (let i = 0;i < hashes.length + 1; i++) {
+    if (idx - 1n === BigInt(i))
+      all.push(inserted);
+    else {
+      const h = hashes[hi++];
+      if (!h)
+        return null;
+      all.push(h);
+    }
+  }
+  return hashAll(all);
+}
+function verifySteps(proof, path, value, root, rootToBlock) {
+  if (!isWellFormed(proof, path))
+    return false;
+  const first = proof[0];
+  if (first?.kind !== "Leaf" || !bytesEqual(first.value, value))
+    return false;
+  let i = 0;
+  let j = segmentEnd(proof, i);
+  const nodeRoot = verifySegment(proof.slice(i, j), leafHash(first.path, first.value));
+  if (!nodeRoot)
+    return false;
+  i = j;
+  const head = proof[i];
+  if (!isShunt(head) || head.idx !== 0n)
+    return false;
+  let trieHash = head.hashes.length === 0 ? nodeRoot : hashAll([nodeRoot, ...head.hashes]);
+  i += 1;
+  if (i >= proof.length)
+    return bytesEqual(root, trieHash);
+  let backBlock = rootToBlock.get(hex(trieHash));
+  if (!backBlock || isShunt(proof[i]))
+    return false;
+  while (i < proof.length) {
+    j = segmentEnd(proof, i);
+    const nextNodeRoot = verifySegment(proof.slice(i, j), backBlock);
+    if (!nextNodeRoot)
+      return false;
+    i = j;
+    if (i >= proof.length)
+      return false;
+    j = i;
+    while (j < proof.length) {
+      const s = proof[j];
+      if (!isShunt(s) || s.idx === 0n)
+        break;
+      j++;
+    }
+    j -= 1;
+    if (j < i)
+      return false;
+    let penultimate = trieHash;
+    for (const s of proof.slice(i, j)) {
+      if (!isShunt(s))
+        return false;
+      const h = shuntHash(null, s.idx, penultimate, s.hashes);
+      if (!h)
+        return false;
+      penultimate = h;
+    }
+    const junction = proof[j];
+    if (!isShunt(junction))
+      return false;
+    const next = shuntHash(nextNodeRoot, junction.idx, penultimate, junction.hashes);
+    if (!next)
+      return false;
+    trieHash = next;
+    backBlock = rootToBlock.get(hex(trieHash));
+    if (!backBlock)
+      return false;
+    i = j + 1;
+    if (bytesEqual(trieHash, root))
+      break;
+  }
+  return bytesEqual(root, trieHash);
+}
+function marfProofAncestors(proof) {
+  let steps;
+  try {
+    steps = decodeProof(proof);
+  } catch {
+    return [];
+  }
+  const ids = new Set;
+  for (const s of steps) {
+    if (s.kind === "Leaf" || s.kind === "Shunt")
+      continue;
+    const ptr = s.node.ptrs.find((p) => p.id !== NodeId.Empty && p.chr === s.chr);
+    if (ptr && isBackptr(ptr.id))
+      ids.add(hex(ptr.backBlock));
+  }
+  return [...ids];
+}
+function verifyMarfProof(input) {
+  const rootToBlock = new Map;
+  for (const h of input.headers)
+    rootToBlock.set(hex(h.stateIndexRoot), blockId(h));
+  try {
+    const steps = decodeProof(input.proof);
+    return verifySteps(steps, input.path, input.value, input.root, rootToBlock);
+  } catch {
+    return false;
+  }
+}
+// src/witness.ts
+var WITNESS_VERSION = 3;
+var PATH_LEN = 32;
+var TRIE_HASH_EMPTY = unhex("c672b8d1ef56ed28ab87c3622c5114069bdd3ad7b8f9737498d0c01ecef0967a");
+var ZERO_BLOCK = new Uint8Array(32);
+function parseWitness(bytes) {
+  const r = new Reader(bytes);
+  const version = r.u8();
+  if (version !== WITNESS_VERSION)
+    throw new Error(`unsupported witness version ${version}`);
+  const ancestorRoots = Array.from({ length: r.u32() }, () => r.bytes(32));
+  const blockTable = Array.from({ length: r.u32() }, () => r.bytes(32));
+  const leaves = [];
+  const seen = new Set;
+  let nodes = 0;
+  const readNode = (prefix, expectedId) => {
+    nodes++;
+    const id = r.u8();
+    if (expectedId !== null && id !== expectedId)
+      throw new Error(`child id ${id} does not match its pointer id ${expectedId}`);
+    const path = r.bytes(r.u8());
+    const depth = prefix.length + path.length;
+    if (id === NodeId.Leaf) {
+      if (depth !== PATH_LEN)
+        throw new Error("leaf path does not complete 32 bytes");
+      const valueHash = r.bytes(32);
+      const full = Uint8Array.from([...prefix, ...path]);
+      const key = hex(full);
+      if (seen.has(key))
+        throw new Error(`duplicate leaf ${key}`);
+      seen.add(key);
+      leaves.push({ path: full, valueHash });
+      return leafHash(path, padValue(valueHash));
+    }
+    const count = NODE_PTR_COUNT[id];
+    if (count === undefined)
+      throw new Error(`bad node id ${id}`);
+    if (depth >= PATH_LEN)
+      throw new Error("interior node at full path depth");
+    const n = r.u16();
+    if (n !== count)
+      throw new Error(`node id ${id} has ${n} ptrs, expected ${count}`);
+    const ptrs = [];
+    for (let i = 0;i < n; i++) {
+      const pid = r.u8();
+      if (pid === NodeId.Empty) {
+        ptrs.push({ id: pid, chr: 0, backBlock: ZERO_BLOCK });
+        continue;
+      }
+      const chr = r.u8();
+      if (!isBackptr(pid)) {
+        ptrs.push({ id: pid, chr, backBlock: ZERO_BLOCK });
+        continue;
+      }
+      const block = blockTable[r.u32()];
+      if (!block)
+        throw new Error("backptr table index out of range");
+      ptrs.push({ id: pid, chr, backBlock: block });
+    }
+    const childPrefix = [...prefix, ...path];
+    const children = ptrs.map((p) => {
+      if (p.id === NodeId.Empty)
+        return TRIE_HASH_EMPTY;
+      if (isBackptr(p.id))
+        return p.backBlock;
+      return readNode([...childPrefix, p.chr], p.id);
+    });
+    return nodeHash({ id, path, ptrs }, children);
+  };
+  const nodeRoot = readNode([], null);
+  if (!r.done)
+    throw new Error("trailing bytes after witness");
+  const root = ancestorRoots.length === 0 ? nodeRoot : hashAll([nodeRoot, ...ancestorRoots]);
+  return { root, ancestorRoots, leaves, nodes };
+}
+var padValue = (valueHash) => {
+  const v = new Uint8Array(MARF_VALUE_SIZE);
+  v.set(valueHash);
+  return v;
+};
+var leafHolds = (leaf, value) => value.length === MARF_VALUE_SIZE && bytesEqual(padValue(leaf.valueHash), value);
+var INTERNAL_PREFIX = "__MARF_";
+function classifyBlockDiff(input) {
+  const writes = indexClaims(input.writes, (v) => marfValue(v));
+  const internal = indexClaims(input.internal, (v) => {
+    const value = unhex(v);
+    if (value.length !== MARF_VALUE_SIZE)
+      throw new Error(`internal value must be ${MARF_VALUE_SIZE} bytes`);
+    return value;
+  });
+  for (const { key } of internal.values())
+    if (!key.startsWith(INTERNAL_PREFIX))
+      throw new Error(`internal key must start with ${INTERNAL_PREFIX}: ${key}`);
+  const out = {
+    writes: [],
+    carried: [],
+    internal: [],
+    hidden: [],
+    missing: [],
+    complete: false
+  };
+  const matched = new Set;
+  for (const leaf of input.leaves) {
+    const pathHex = hex(leaf.path);
+    const write = writes.get(pathHex);
+    if (write && leafHolds(leaf, write.value)) {
+      out.writes.push({ ...leaf, key: write.key });
+      matched.add(pathHex);
+      continue;
+    }
+    const bookkeeping = internal.get(pathHex);
+    if (bookkeeping && leafHolds(leaf, bookkeeping.value)) {
+      out.internal.push({ ...leaf, key: bookkeeping.key });
+      continue;
+    }
+    const parent = write ? undefined : input.parentValue(pathHex);
+    if (parent !== undefined && leafHolds(leaf, unhex(parent)))
+      out.carried.push(leaf);
+    else
+      out.hidden.push(leaf);
+  }
+  for (const [pathHex, { key }] of writes)
+    if (!matched.has(pathHex))
+      out.missing.push(key);
+  out.complete = out.hidden.length === 0 && out.missing.length === 0;
+  return out;
+}
+function indexClaims(claims, toValue) {
+  const byPath = new Map;
+  for (const [key, value] of claims) {
+    const pathHex = hex(marfPath(key));
+    if (byPath.has(pathHex))
+      throw new Error(`duplicate claimed key ${key}`);
+    byPath.set(pathHex, { key, value: toValue(value) });
+  }
+  return byPath;
+}
+// src/signers.ts
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { deserializeCV } from "@secondlayer/stacks/clarity";
+import { c32address, hash160 } from "@secondlayer/stacks/utils";
+var MAINNET_P2PKH = 22;
+var SIGNERS_CONTRACT = "SP000000000000000000002Q6VF78.signers";
+function decodeSignerSet(value) {
+  const cv = deserializeCV(typeof value === "string" ? value : hex(value));
+  if (cv.type !== "some" || cv.value.type !== "list")
+    throw new Error("signer set must be (some (list ...))");
+  const set = new Map;
+  for (const entry of cv.value.value) {
+    if (entry.type !== "tuple")
+      throw new Error("signer entry must be a tuple");
+    const { signer, weight } = entry.value;
+    if (signer?.type !== "address" || weight?.type !== "uint")
+      throw new Error("signer entry needs (signer principal) (weight uint)");
+    if (set.has(signer.value))
+      throw new Error(`duplicate signer ${signer.value}`);
+    set.set(signer.value, BigInt(weight.value));
+  }
+  return set;
+}
+function verifySignerSignatures(header, set) {
+  const msg = signerSignatureHash(header);
+  let totalWeight = 0n;
+  for (const w of set.values())
+    totalWeight += w;
+  const threshold = (totalWeight * 7n + 9n) / 10n;
+  const out = {
+    valid: false,
+    signedWeight: 0n,
+    totalWeight,
+    threshold,
+    signers: [],
+    unknown: [],
+    duplicates: [],
+    invalid: 0
+  };
+  const seen = new Set;
+  for (const sig of header.signerSignatures) {
+    const who = recoverSigner(msg, sig);
+    if (!who)
+      out.invalid++;
+    else if (seen.has(who))
+      out.duplicates.push(who);
+    else {
+      seen.add(who);
+      const weight = set.get(who);
+      if (weight === undefined)
+        out.unknown.push(who);
+      else {
+        out.signers.push(who);
+        out.signedWeight += weight;
+      }
+    }
+  }
+  out.valid = totalWeight > 0n && out.signedWeight >= threshold && out.unknown.length === 0 && out.duplicates.length === 0 && out.invalid === 0;
+  return out;
+}
+function recoverSigner(msg, sig) {
+  try {
+    const s = secp256k1.Signature.fromBytes(sig, "recovered");
+    if (s.hasHighS())
+      return null;
+    const pubkey = s.recoverPublicKey(msg).toBytes(true);
+    return c32address(MAINNET_P2PKH, hex(hash160(pubkey)));
+  } catch {
+    return null;
+  }
+}
+// src/burn.ts
+import { ripemd160 } from "@noble/hashes/legacy.js";
+import { sha256 } from "@noble/hashes/sha2.js";
+var PREIMAGE_PREFIX = Uint8Array.of(23, 0, 0, 0);
+var BHH_START = 4;
+var BHH_END = 36;
+function verifyConsensusPreimage(consensusHash, preimage) {
+  if (consensusHash.length !== 20 || preimage.length < BHH_END)
+    return null;
+  if (!bytesEqual(preimage.subarray(0, BHH_START), PREIMAGE_PREFIX))
+    return null;
+  if (!bytesEqual(ripemd160(sha256(preimage)), consensusHash))
+    return null;
+  return hex(preimage.subarray(BHH_START, BHH_END));
+}
+var MAINNET_FIRST_BURN_HEIGHT = 666050;
+var MAINNET_REWARD_CYCLE_LENGTH = 2100;
+var MAINNET_PREPARE_LENGTH = 100;
+var cycleStart = (cycle, firstBurnHeight = MAINNET_FIRST_BURN_HEIGHT, cycleLength = MAINNET_REWARD_CYCLE_LENGTH) => firstBurnHeight + cycle * cycleLength;
+function rewardCycle(burnHeight, firstBurnHeight = MAINNET_FIRST_BURN_HEIGHT, cycleLength = MAINNET_REWARD_CYCLE_LENGTH) {
+  if (burnHeight < firstBurnHeight)
+    throw new Error(`burn height ${burnHeight} precedes the first burn block`);
+  return Math.floor((burnHeight - firstBurnHeight) / cycleLength);
+}
+// src/keys.ts
+import { serializeCV } from "@secondlayer/stacks/clarity";
+import { c32addressDecode } from "@secondlayer/stacks/utils";
+var StoreType = { DataMap: 0, Variable: 1, FungibleToken: 2 };
+function mapEntryKey(contractId, mapName, key) {
+  return `vm::${contractId}::${StoreType.DataMap}::${mapName}::${serializeCV(key)}`;
+}
+function dataVarKey(contractId, varName) {
+  return `vm::${contractId}::${StoreType.Variable}::${varName}`;
+}
+function ftBalanceKey(contractId, tokenName, holder) {
+  return `vm::${contractId}::${StoreType.FungibleToken}::${tokenName}::${principalJson(holder)}`;
+}
+function principalJson(principal) {
+  const dot = principal.indexOf(".");
+  const address = dot === -1 ? principal : principal.slice(0, dot);
+  const [version, hash160] = c32addressDecode(address);
+  const issuer = [version, Array.from(unhex(hash160))];
+  if (dot === -1)
+    return JSON.stringify({ Standard: issuer });
+  return JSON.stringify({
+    Contract: { issuer, name: principal.slice(dot + 1) }
+  });
+}
+// src/bitcoin/chain.ts
+import { bytesToHex as bytesToHex3, hexToBytes as hexToBytes3 } from "@noble/hashes/utils.js";
+
+// src/bitcoin/header.ts
+import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
+import { bytesToHex as bytesToHex2, hexToBytes as hexToBytes2 } from "@noble/hashes/utils.js";
+var HEADER_SIZE = 80;
+function toBytes(raw) {
+  return typeof raw === "string" ? hexToBytes2(raw) : raw;
+}
+function reverseBytes(bytes) {
+  return Uint8Array.from(bytes).reverse();
+}
+function parseHeader(raw) {
+  const bytes = toBytes(raw);
+  if (bytes.length !== HEADER_SIZE) {
+    throw new RangeError(`block header must be ${HEADER_SIZE} bytes, got ${bytes.length}`);
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, HEADER_SIZE);
+  return {
+    version: view.getInt32(0, true),
+    prevHash: bytesToHex2(reverseBytes(bytes.subarray(4, 36))),
+    merkleRoot: bytesToHex2(reverseBytes(bytes.subarray(36, 68))),
+    time: view.getUint32(68, true),
+    bits: view.getUint32(72, true),
+    nonce: view.getUint32(76, true)
+  };
+}
+function headerHash(raw) {
+  const bytes = toBytes(raw);
+  if (bytes.length !== HEADER_SIZE) {
+    throw new RangeError(`block header must be ${HEADER_SIZE} bytes, got ${bytes.length}`);
+  }
+  return sha2562(sha2562(bytes));
+}
+
+// src/bitcoin/pow.ts
+var POW_LIMIT = 0xffffn << 208n;
+var RETARGET_INTERVAL = 2016;
+var TARGET_TIMESPAN = 14 * 24 * 60 * 60;
+var TWO_256 = 1n << 256n;
+function decodeCompact(bits) {
+  const size = bits >>> 24;
+  let word = bits & 8388607;
+  let target;
+  if (size <= 3) {
+    word >>>= 8 * (3 - size);
+    target = BigInt(word);
+  } else {
+    target = BigInt(word) << BigInt(8 * (size - 3));
+  }
+  const negative = word !== 0 && (bits & 8388608) !== 0;
+  const overflow = word !== 0 && (size > 34 || word > 255 && size > 33 || word > 65535 && size > 32);
+  return { target: target & TWO_256 - 1n, negative, overflow };
+}
+function bitsToTarget(bits) {
+  const { target, negative, overflow } = decodeCompact(bits);
+  if (negative || overflow || target === 0n) {
+    throw new RangeError(`bits 0x${bits.toString(16).padStart(8, "0")} do not encode a valid target`);
+  }
+  return target;
+}
+function targetToBits(target) {
+  if (target < 0n)
+    throw new RangeError("target must be non-negative");
+  let size = target === 0n ? 0 : Math.ceil(target.toString(2).length / 8);
+  let compact = size <= 3 ? Number(target << BigInt(8 * (3 - size))) : Number(target >> BigInt(8 * (size - 3)));
+  if (compact & 8388608) {
+    compact >>>= 8;
+    size += 1;
+  }
+  return (size << 24 | compact) >>> 0;
+}
+function hashToBigInt(hash) {
+  let n = 0n;
+  for (let i = hash.length - 1;i >= 0; i--) {
+    n = n << 8n | BigInt(hash[i]);
+  }
+  return n;
+}
+function checkProofOfWork(hash, bits) {
+  const { target, negative, overflow } = decodeCompact(bits);
+  if (negative || overflow || target === 0n || target > POW_LIMIT) {
+    return false;
+  }
+  return hashToBigInt(hash) <= target;
+}
+function headerWork(bits) {
+  const target = bitsToTarget(bits);
+  return (TWO_256 - 1n - target) / (target + 1n) + 1n;
+}
+function nextRetargetBits(lastBits, firstTime, lastTime) {
+  let actual = lastTime - firstTime;
+  if (actual < TARGET_TIMESPAN / 4)
+    actual = TARGET_TIMESPAN / 4;
+  if (actual > TARGET_TIMESPAN * 4)
+    actual = TARGET_TIMESPAN * 4;
+  let target = bitsToTarget(lastBits) * BigInt(actual) / BigInt(TARGET_TIMESPAN);
+  if (target > POW_LIMIT)
+    target = POW_LIMIT;
+  return targetToBits(target);
+}
+
+// src/bitcoin/chain.ts
+var MEDIAN_TIME_SPAN = 11;
+var BIP65_HEIGHT = 388381;
+
+class HeaderValidationError extends Error {
+  height;
+  rule;
+  name = "HeaderValidationError";
+  constructor(height, rule, detail) {
+    super(`header at height ${height} failed ${rule}: ${detail}`);
+    this.height = height;
+    this.rule = rule;
+  }
+}
+var hex8 = (n) => `0x${n.toString(16).padStart(8, "0")}`;
+
+class HeaderChain {
+  base;
+  periodStartTime;
+  entries = [];
+  heights = new Map;
+  work = 0n;
+  constructor(base, periodStartTime) {
+    this.base = base;
+    this.periodStartTime = periodStartTime;
+  }
+  static fromCheckpoint(checkpoint) {
+    const { height } = checkpoint;
+    if (!Number.isSafeInteger(height) || height < 0) {
+      throw new HeaderValidationError(height, "checkpoint", "height must be a non-negative integer");
+    }
+    const raw = toRaw(checkpoint.header, height);
+    const header = parseHeader(raw);
+    try {
+      bitsToTarget(header.bits);
+    } catch (err) {
+      throw new HeaderValidationError(height, "checkpoint", err.message);
+    }
+    const atPeriodStart = height % RETARGET_INTERVAL === 0;
+    let periodStartTime = checkpoint.periodStartTime;
+    if (atPeriodStart) {
+      if (periodStartTime !== undefined && periodStartTime !== header.time) {
+        throw new HeaderValidationError(height, "checkpoint", `periodStartTime ${periodStartTime} disagrees with the period-start checkpoint's own time ${header.time}`);
+      }
+      periodStartTime = header.time;
+    } else if (periodStartTime === undefined) {
+      throw new HeaderValidationError(height, "checkpoint", `periodStartTime is required for a checkpoint inside a difficulty period (period starts at ${height - height % RETARGET_INTERVAL})`);
+    }
+    const chain = new HeaderChain(height, periodStartTime);
+    chain.push(raw, header);
+    return chain;
+  }
+  get tip() {
+    return this.entries[this.entries.length - 1];
+  }
+  get totalWork() {
+    return this.work;
+  }
+  get checkpointHeight() {
+    return this.base;
+  }
+  heightOf(hashHex) {
+    return this.heights.get(hashHex.toLowerCase());
+  }
+  headerAt(height) {
+    return this.entries[height - this.base];
+  }
+  append(headers) {
+    const before = this.entries.length;
+    const workBefore = this.work;
+    try {
+      for (const item of headers) {
+        const height = this.tip.height + 1;
+        const raw = toRaw(item, height);
+        this.validate(height, raw, parseHeader(raw));
+      }
+    } catch (err) {
+      for (const removed of this.entries.splice(before)) {
+        this.heights.delete(removed.hash);
+      }
+      this.work = workBefore;
+      throw err;
+    }
+  }
+  validate(height, raw, header) {
+    const prev = this.tip;
+    if (header.prevHash !== prev.hash) {
+      const known = this.heights.get(header.prevHash);
+      throw new HeaderValidationError(height, "prev-link", known === undefined ? `prevHash ${header.prevHash} does not match tip ${prev.hash} at ${prev.height}` : `prevHash points at height ${known}, not the tip at ${prev.height} (forks/reorgs are not supported)`);
+    }
+    const expectedBits = this.expectedBits(height, prev);
+    if (header.bits !== expectedBits) {
+      const atRetarget = height % RETARGET_INTERVAL === 0;
+      throw new HeaderValidationError(height, atRetarget ? "retarget" : "bits", atRetarget ? `bits ${hex8(header.bits)} != retargeted ${hex8(expectedBits)}` : `bits ${hex8(header.bits)} != previous ${hex8(expectedBits)} (only height % ${RETARGET_INTERVAL} == 0 may change difficulty)`);
+    }
+    const mtp = this.medianTimePast();
+    if (header.time <= mtp) {
+      throw new HeaderValidationError(height, "median-time-past", `time ${header.time} <= median of previous ${Math.min(MEDIAN_TIME_SPAN, this.entries.length)} blocks (${mtp})`);
+    }
+    if (height >= BIP65_HEIGHT && header.version < 4) {
+      throw new HeaderValidationError(height, "version", `version ${header.version} < 4 (required from height ${BIP65_HEIGHT})`);
+    }
+    const hash = headerHash(raw);
+    if (!checkProofOfWork(hash, header.bits)) {
+      throw new HeaderValidationError(height, "proof-of-work", `hash ${bytesToHex3(reverseBytes(hash))} exceeds target for bits ${hex8(header.bits)}`);
+    }
+    this.push(raw, header, hash);
+  }
+  expectedBits(height, prev) {
+    if (height % RETARGET_INTERVAL !== 0)
+      return prev.header.bits;
+    const firstHeight = height - RETARGET_INTERVAL;
+    const firstTime = firstHeight < this.base ? this.periodStartTime : this.headerAt(firstHeight).header.time;
+    return nextRetargetBits(prev.header.bits, firstTime, prev.header.time);
+  }
+  medianTimePast() {
+    const times = this.entries.slice(-MEDIAN_TIME_SPAN).map((e) => e.header.time).sort((a, b) => a - b);
+    return times[Math.floor(times.length / 2)];
+  }
+  push(raw, header, hash = headerHash(raw)) {
+    const height = this.base + this.entries.length;
+    const hashHex = bytesToHex3(reverseBytes(hash));
+    this.entries.push({ height, hash: hashHex, header, raw });
+    this.heights.set(hashHex, height);
+    this.work += headerWork(header.bits);
+  }
+}
+function toRaw(item, height) {
+  let raw;
+  try {
+    raw = typeof item === "string" ? hexToBytes3(item) : Uint8Array.from(item);
+  } catch {
+    throw new HeaderValidationError(height, "format", "header is not valid hex");
+  }
+  if (raw.length !== HEADER_SIZE) {
+    throw new HeaderValidationError(height, "format", `header must be ${HEADER_SIZE} bytes, got ${raw.length}`);
+  }
+  return raw;
+}
+// src/checkpoint.ts
+var MAINNET_CHECKPOINT = {
+  stacks: {
+    header: [
+      "01000000000088a9900000006629951a50e3616a1c1e0b8c05ba66615c7065053804c56e2a68dc605cf905df5a754c57",
+      "144e9ddde1191353b05f1a5e6d3c99244aeb006ba4f4db761cb1efecfb92693a8c08fefc766a4cd5ccfcb8f13789a809",
+      "e7ee0c2e6b7dfb64868cf1e4e6acc50513202acfab84553454b433248c0ef06cebda3c734c000000006aa28bfd013be3",
+      "826a60039f518d7021a4799f2e083dafaaaac7a2d56fda601d674d596d3046b9bbcd52e79fba491e54d92fdab0ca3ab9",
+      "9ccf346c6e6726fbd4c8579a02b80000000d0004f2d135dd684fcdf24973ad0e9d4f11ef10890a8159614b1df97d8f31",
+      "76532d1ce4ebdcbbf45afcd01d5bb298ef9556b232f877f3586d65303642dabc210059012d5f341c979fd10a1ce9b48f",
+      "4a38f68da5ccbb8749c02e164a99668328890ed706accfbec155202f63ff487a26aba793169341c2ff91a43ffed38f0e",
+      "941c3dc1012a12bb2148d6cf23dd05e228d29286e3bb87ff717712ecc2c9f0c4297c241ac41f879baeee87a570243a31",
+      "cf43e775862e71a7f51cb150bbc31f3a2f62a1772d00f8bdd615ab5b58841c7918d69cf98a030f52ca410c9b91a188ba",
+      "038138563ea35f8453075907fc3cdac7e3eff8fa9f61fcb53a1e14a102309fa297e420826bfe015628863a16f1bdc077",
+      "90c6eead0cfd7a0aa7222df6d8d41415427b0b4057eb972dc31bd413f1e425ef1bc738cc5c3b8507890bad0940bafdf2",
+      "220a6ecadb33ed002f9a476eb20c5e532bafa7b559b285932e1dab1159c93038d8cb0da8d55d25294cc8e6b0972efc08",
+      "fdf825407e3215d8d01531f5cddfe993db10be07b38c18fa006999eb6418eac4696bb42ca149f79832442754ea08b0e1",
+      "c6237feb522df034a3388c0de90b1a4652218b319f839ff16a132baa90dbbca2876f52b1a5750dc07001cffca3ed6e92",
+      "2483e6567f183a78a1c09d16846743f08c5cce93e7e06294c4a722283d31195722b6ce97087c6dd00eedecd1db77be10",
+      "9c298c322c53e83ea43201dd0684e8171ad29f6895ed9892d3932daeb0986f32992d6758db194ae9ba8eb256fdff3b61",
+      "af0cd448aafe5e4e62e7e75409dfcd3cef3913c792e412849a02550109083fa52598f5fa2907e840050c41db32163838",
+      "32aa7cb5e23de14ced47961e356b23e442f2a657ea89fed2845a6b380624dc12347e4d591c80e15016ae35fc005ae002",
+      "f1fc5837c21185b88b06cc8611cfb482c021df5329d878e2b4f221341a47e6fe02182c9250d25fe162f42a0bbe9b8ce2",
+      "f9a70aa2dcca9e955a61a0fe24016398a0fdf5e2541d3d0838d9f7e24b4093d27660a48cd71bf0728fe5d02e6d374a3e",
+      "aa67c91aee87635d7458bb1fe89755021fbe8d34e271fba1d765b065e266008a862c839aeec0d6a9940cfe44e0bc1586",
+      "2bd2ac23b3ab6fc59734a8171b44401b395984f0f906b2d15b4a3a24d2136a8ca925485f197197b3aa1bb2c46d02e000",
+      "01000000010100000000"
+    ].join(""),
+    cycle: 143,
+    signerSet: [
+      "0a0b0000001d0c00000002067369676e65720516f5061b1c62f399ecc0db8cbb21f8d481af079a380677656967687401",
+      "000000000000000000000000000002860c00000002067369676e65720516a3bbf2a4133fbd5bd1880982957b7a760347",
+      "b2dc0677656967687401000000000000000000000000000000090c00000002067369676e657205164f72f6b5a9f5d863",
+      "34b2f0fe701db51a7a246f3d0677656967687401000000000000000000000000000000990c00000002067369676e6572",
+      "051653ec8b4f51c8286dad6f4ff81ca2a3409d2f382d0677656967687401000000000000000000000000000000050c00",
+      "000002067369676e65720516dba631825ff0f15c7c5946b560070f8f5f5747cb06776569676874010000000000000000",
+      "00000000000000240c00000002067369676e6572051600d058b39f4495b412ff7eada763eaa6386eb90a067765696768",
+      "7401000000000000000000000000000002860c00000002067369676e65720516321ac33715d684d5e8d0cf427cd98557",
+      "6f64c6df06776569676874010000000000000000000000000000000b0c00000002067369676e6572051677a52718ba90",
+      "fca67984166b2a084edb9b3bd8f10677656967687401000000000000000000000000000000030c00000002067369676e",
+      "65720516a54a20479b3b65a461a427b9161b78e64db58ba70677656967687401000000000000000000000000000001a9",
+      "0c00000002067369676e65720516bc1a58c2a058a9e4150db25562e8331ef8a4267c0677656967687401000000000000",
+      "000000000000000000060c00000002067369676e657205161091d2da4c9ee17a340171c0d23c4304b54ef43f06776569",
+      "67687401000000000000000000000000000000680c00000002067369676e6572051654d01a0973ed139736a1a43032a6",
+      "a18d9295ec7206776569676874010000000000000000000000000000008d0c00000002067369676e657205160c49f5b6",
+      "c62f1163ddbb21f92aba86f17f7be4880677656967687401000000000000000000000000000000680c00000002067369",
+      "676e65720516ad16c79ac56b58f0797f78c5343853674606268006776569676874010000000000000000000000000000",
+      "00680c00000002067369676e657205169689e56df00385b6bd81fb6b7769d5b04088acb8067765696768740100000000",
+      "0000000000000000000000ad0c00000002067369676e65720516a4f7f81412f4413771a48825cfbe2062a774d4e90677",
+      "656967687401000000000000000000000000000003090c00000002067369676e65720516ed73a7398f1c3eb566f3bd7f",
+      "4bd43f52adf33d8f0677656967687401000000000000000000000000000000680c00000002067369676e65720516937b",
+      "3b43e0d94c9ef8f171892bce949709e1d41f0677656967687401000000000000000000000000000000250c0000000206",
+      "7369676e6572051631542aacfd6e04858181c3067b5eb07399ba89df0677656967687401000000000000000000000000",
+      "0000005b0c00000002067369676e6572051649f034cd1662a222dbc38a6acd64008ba7e5576606776569676874010000",
+      "00000000000000000000000000060c00000002067369676e65720516a20f660dea498c169897a39cb89ce0d98856e572",
+      "0677656967687401000000000000000000000000000000090c00000002067369676e6572051652d58897b3678f3a758f",
+      "a4b9270744fec0605b210677656967687401000000000000000000000000000000680c00000002067369676e65720516",
+      "31733264626dc5fef36eb683a5069d89f63b64cc0677656967687401000000000000000000000000000000090c000000",
+      "02067369676e65720516d80db618c2def577604cd8e40a3940b5b639b1ac067765696768740100000000000000000000",
+      "00000000000a0c00000002067369676e657205162042a380d946a82866465af8521a273efe6d2a600677656967687401",
+      "000000000000000000000000000000490c00000002067369676e6572051635e1b36efc22bc607db92f9100cb08e3473d",
+      "602506776569676874010000000000000000000000000000006b0c00000002067369676e657205164843b97054e43dd1",
+      "a8571fc1e72949c5bedfb7e906776569676874010000000000000000000000000000004d0c00000002067369676e6572",
+      "05164883355670025c19ecae644ffa20e75ce1d730ad0677656967687401000000000000000000000000000000090c00",
+      "000002067369676e65720516089ffd0e0ecd61d9e3c8ee42ef94148acf88aa8806776569676874010000000000000000",
+      "0000000000000015"
+    ].join("")
+  },
+  bitcoin: {
+    height: 967680,
+    header: "00000030410ccb1cba623e26f2e02f3fcb0e7f06f66998b68cb5010000000000000000003d16ae2558e8ec7b8dd369ee29bb2733fbd39bcc1058c681970a36a7f1a2bdea1135ae6ac51e0217480c3581"
+  }
+};
+// src/source.ts
+class SourceError extends Error {
+  url;
+  status;
+  name = "SourceError";
+  constructor(url, status, detail) {
+    super(`${url}: ${detail}`);
+    this.url = url;
+    this.status = status;
+  }
+}
+var MAX_ATTEMPTS = 3;
+var MAX_RETRY_SECONDS = 10;
+async function get(url, opts, attempt = 1) {
+  const doFetch = opts.fetch ?? fetch;
+  let res;
+  try {
+    res = await doFetch(url, { headers: opts.headers });
+  } catch (err) {
+    throw new SourceError(url, null, err.message);
+  }
+  if (res.status === 404)
+    return null;
+  if (res.status === 503 && attempt < MAX_ATTEMPTS) {
+    const header = res.headers.get("retry-after");
+    const seconds = header === null ? 1 : Number(header);
+    const wait = Number.isFinite(seconds) ? Math.min(Math.max(seconds, 0), MAX_RETRY_SECONDS) : 1;
+    await new Promise((r) => setTimeout(r, wait * 1000));
+    return get(url, opts, attempt + 1);
+  }
+  if (!res.ok)
+    throw new SourceError(url, res.status, `HTTP ${res.status}`);
+  return res;
+}
+async function getJson(url, opts) {
+  const res = await get(url, opts);
+  return res ? await res.json() : null;
+}
+async function getBytes(url, opts) {
+  const res = await get(url, opts);
+  return res ? new Uint8Array(await res.arrayBuffer()) : null;
+}
+var required = (url, v) => {
+  if (v === null)
+    throw new SourceError(url, 404, "not found");
+  return v;
+};
+var trimSlash = (s) => s.replace(/\/+$/, "");
+var toMarf = (url, j) => {
+  if (j === null)
+    return null;
+  const proof = j.proof ?? j.marf_proof;
+  if (typeof proof !== "string" || typeof j.data !== "string")
+    throw new SourceError(url, 200, "MARF answer needs data and proof");
+  return { data: j.data, proof: unhex(proof) };
+};
+var VM_WRITE_TYPES = [
+  "var_set",
+  "map_set",
+  "map_insert",
+  "map_delete"
+];
+var PAGE = 1000;
+async function pages(field, url, http) {
+  const out = [];
+  let cursor = null;
+  for (;; ) {
+    const page = cursor ? `${url}&cursor=${encodeURIComponent(cursor)}` : url;
+    const j = await getJson(page, http);
+    if (j === null)
+      return cursor === null ? null : out;
+    const rows = j[field];
+    if (!Array.isArray(rows))
+      throw new SourceError(page, 200, `answer has no ${field} array`);
+    out.push(...rows);
+    const next = j.next_cursor;
+    if (rows.length < PAGE || typeof next !== "string" || next === cursor)
+      return out;
+    cursor = next;
+  }
+}
+
+class SecondlayerProofSource {
+  getBlock;
+  getMarfProof;
+  getWitness;
+  getBurnPreimage;
+  getBitcoinHeaders;
+  getStateWrites;
+  getVmEvents;
+  constructor(opts) {
+    const base = trimSlash(opts.baseUrl);
+    const http = {
+      headers: { authorization: `Bearer ${opts.apiKey}` },
+      fetch: opts.fetch
+    };
+    this.getBlock = async (ref) => {
+      const url = typeof ref === "number" ? `${base}/v1/proofs/block/height/${ref}` : `${base}/v1/proofs/block/${ref}`;
+      return required(url, await getBytes(url, http));
+    };
+    this.getMarfProof = async (pathHex, tipId) => {
+      const url = `${base}/v1/proofs/marf/${pathHex}?tip=${tipId}`;
+      return toMarf(url, await getJson(url, http));
+    };
+    this.getWitness = async (blockId) => {
+      const url = `${base}/v1/proofs/witness/${blockId}`;
+      return required(url, await getBytes(url, http));
+    };
+    this.getBurnPreimage = async (consensusHash) => {
+      const url = `${base}/v1/proofs/burn/${consensusHash}`;
+      const j = required(url, await getJson(url, http));
+      return { preimage: unhex(j.preimage), burnHeight: j.burn_height };
+    };
+    this.getBitcoinHeaders = async (from, count) => {
+      const url = `${base}/v1/proofs/bitcoin-headers?from=${from}&count=${count}`;
+      const j = required(url, await getJson(url, http));
+      if (j.from !== from)
+        throw new SourceError(url, 200, `headers start at ${j.from}`);
+      return j.headers;
+    };
+    this.getStateWrites = (height) => pages("state_writes", `${base}/v1/index/state-writes?block_height=${height}&limit=${PAGE}`, http);
+    this.getVmEvents = async (height) => {
+      const out = [];
+      for (const type of VM_WRITE_TYPES) {
+        const url = `${base}/v1/index/events?event_type=${type}&from_height=${height}&to_height=${height}&limit=${PAGE}`;
+        out.push(...await pages("events", url, http) ?? []);
+      }
+      return out.sort((a, b) => a.event_index - b.event_index);
+    };
+  }
+}
+
+class NodeRpcProofSource {
+  getBlock;
+  getMarfProof;
+  constructor(opts) {
+    const base = trimSlash(opts.nodeUrl);
+    const http = { fetch: opts.fetch };
+    this.getBlock = async (ref) => {
+      const url = typeof ref === "number" ? `${base}/v3/blocks/height/${ref}` : `${base}/v3/blocks/${ref}`;
+      return required(url, await getBytes(url, http));
+    };
+    this.getMarfProof = async (pathHex, tipId) => {
+      const url = `${base}/v2/clarity/marf/${pathHex}?tip=${tipId}&proof=1`;
+      return toMarf(url, await getJson(url, http));
+    };
+  }
+}
+// src/state.ts
+var INTERNAL = {
+  self: "__MARF_BLOCK_HEIGHT_SELF",
+  heightToHash: "__MARF_BLOCK_HEIGHT_TO_HASH",
+  hashToHeight: "__MARF_BLOCK_HASH_TO_HEIGHT"
+};
+var heightValue = (h) => {
+  const v = new Uint8Array(MARF_VALUE_SIZE);
+  new DataView(v.buffer).setUint32(0, h, true);
+  return hex(v);
+};
+var padded = (b32) => `${hex(b32)}${"00".repeat(8)}`;
+function internalEntries(height, parentBlockId, leaves) {
+  const out = [[INTERNAL.self, heightValue(height)]];
+  const ownKey = `${INTERNAL.heightToHash}::${height}`;
+  const ownPath = marfPath(ownKey);
+  const own = leaves.find((l) => bytesEqual(l.path, ownPath));
+  if (own) {
+    out.push([ownKey, padded(own.valueHash)]);
+    out.push([
+      `${INTERNAL.hashToHeight}::${hex(own.valueHash)}`,
+      heightValue(height)
+    ]);
+  }
+  if (height > 0) {
+    out.push([
+      `${INTERNAL.heightToHash}::${height - 1}`,
+      padded(parentBlockId)
+    ]);
+    out.push([
+      `${INTERNAL.hashToHeight}::${hex(parentBlockId)}`,
+      heightValue(height - 1)
+    ]);
+  }
+  return out;
+}
+var utf8 = new TextDecoder("utf-8", { fatal: true });
+var strip0x = (s) => s.startsWith("0x") ? s.slice(2) : s;
+var leafHex = (l) => ({
+  path: hex(l.path),
+  valueHash: hex(l.valueHash)
+});
+function lastWrites(writes, failures) {
+  const out = new Map;
+  for (const w of [...writes].sort((a, b) => a.ordinal - b.ordinal)) {
+    try {
+      out.set(w.key, {
+        value: utf8.decode(unhex(strip0x(w.value_hex))),
+        txIndex: w.tx_index
+      });
+    } catch {
+      failures.push({
+        step: "names",
+        code: "bad-write",
+        message: `state write ${w.ordinal} value is not UTF-8 hex`,
+        key: w.key,
+        ordinal: w.ordinal
+      });
+    }
+  }
+  return out;
+}
+function rowWrite(row) {
+  const need = (v, name) => {
+    if (!v)
+      throw new Error(`${row.event_type} row has no ${name}`);
+    return v;
+  };
+  if (row.event_type === "var_set")
+    return [
+      dataVarKey(row.contract_id, need(row.var_name, "var_name")),
+      strip0x(need(row.raw_value, "raw_value")).toLowerCase()
+    ];
+  const key = `vm::${row.contract_id}::0::${need(row.map, "map")}::${strip0x(need(row.raw_key, "raw_key")).toLowerCase()}`;
+  if (row.event_type === "map_delete")
+    return [key, "09"];
+  return [key, `0a${strip0x(need(row.raw_value, "raw_value")).toLowerCase()}`];
+}
+function checkRows(rows, leaves, failures) {
+  const byPath = new Map(leaves.map((l) => [hex(l.path), l]));
+  const named = [];
+  for (const row of [...rows].sort((a, b) => a.event_index - b.event_index)) {
+    try {
+      const [key, value] = rowWrite(row);
+      named.push({ row, key, path: hex(marfPath(key)), value });
+    } catch (err) {
+      failures.push({
+        step: "rows",
+        code: "bad-row",
+        message: err.message,
+        ordinal: row.event_index
+      });
+    }
+  }
+  const last = new Map(named.map((n, i) => [n.path, i]));
+  named.forEach((n, i) => {
+    const leaf = byPath.get(n.path);
+    const at = { key: n.key, path: n.path, ordinal: n.row.event_index };
+    if (!leaf)
+      failures.push({
+        step: "rows",
+        code: "key-not-written",
+        message: `${n.row.event_type} row ${n.row.event_index} names a key the block did not write`,
+        ...at
+      });
+    else if (last.get(n.path) === i && padded(leaf.valueHash) !== hex(marfValue(n.value)))
+      failures.push({
+        step: "rows",
+        code: "value-mismatch",
+        message: `${n.row.event_type} row ${n.row.event_index} value differs from the block's leaf`,
+        ...at
+      });
+  });
+  return named.length;
+}
+async function verifyBlockState(input) {
+  const out = { rowsChecked: 0, notes: [], failures: [] };
+  let witness;
+  try {
+    witness = parseWitness(input.witness);
+  } catch (err) {
+    out.failures.push({
+      step: "witness",
+      code: "malformed",
+      message: err.message
+    });
+    return out;
+  }
+  if (!bytesEqual(witness.root, input.stateRoot)) {
+    out.failures.push({
+      step: "witness",
+      code: "root-mismatch",
+      message: `witness root ${hex(witness.root)} != header state_index_root ${hex(input.stateRoot)}`
+    });
+    return out;
+  }
+  const { leaves } = witness;
+  const internal = internalEntries(input.height, input.parentBlockId, leaves);
+  const named = input.writes !== null;
+  const last = lastWrites(input.writes ?? [], out.failures);
+  const writes = [...last].map(([k, w]) => [k, w.value]);
+  const first = classifyBlockDiff({
+    leaves,
+    writes,
+    internal,
+    parentValue: () => {
+      return;
+    }
+  });
+  const inParent = new Map((input.parentLeaves ?? []).map((l) => [hex(l.path), hex(l.valueHash)]));
+  const carried = new Map;
+  for (const leaf of first.hidden) {
+    const pathHex = hex(leaf.path);
+    if (inParent.get(pathHex) === hex(leaf.valueHash) || named && await input.parentHolds?.(leaf))
+      carried.set(pathHex, padded(leaf.valueHash));
+  }
+  const d = classifyBlockDiff({
+    leaves,
+    writes,
+    internal,
+    parentValue: (p) => carried.get(p)
+  });
+  out.diff = {
+    named,
+    writes: named ? d.writes.map((l) => ({
+      ...leafHex(l),
+      key: l.key,
+      txIndex: last.get(l.key)?.txIndex ?? null,
+      named: true
+    })) : d.hidden.map((l) => ({ ...leafHex(l), named: false })),
+    carried: d.carried.map(leafHex),
+    internal: d.internal.map((l) => ({ ...leafHex(l), key: l.key }))
+  };
+  if (!named)
+    out.notes.push(`source has no state_writes for block ${input.height}: ${d.hidden.length} written leaves are proven in the block but unnamed`);
+  else {
+    for (const l of d.hidden)
+      out.failures.push({
+        step: "names",
+        code: "hidden-write",
+        message: `leaf ${hex(l.path)} is not a named write, a carried parent value or MARF bookkeeping`,
+        path: hex(l.path)
+      });
+    for (const key of d.missing)
+      out.failures.push({
+        step: "names",
+        code: "missing-write",
+        message: `state write ${key} has no leaf holding its value`,
+        key,
+        path: hex(marfPath(key))
+      });
+  }
+  if (input.rows)
+    out.rowsChecked = checkRows(input.rows, leaves, out.failures);
+  return out;
+}
+// src/verify-block.ts
+import { uintCV } from "@secondlayer/stacks/clarity";
+class Broken extends Error {
+  failure;
+  constructor(failure) {
+    super(failure.message);
+    this.failure = failure;
+  }
+}
+var fail = (f) => {
+  throw new Broken(f);
+};
+async function fetchFor(step, what, call, extra = {}) {
+  try {
+    return await call();
+  } catch (err) {
+    if (err instanceof Broken)
+      throw err;
+    return fail({
+      step,
+      code: "unavailable",
+      message: `${what}: ${err.message}`,
+      ...extra
+    });
+  }
+}
+var BITCOIN_BATCH = 2016;
+async function findAnchor(low, high, window, probe, maxProbes = 32) {
+  let [lo, hi] = [low, high];
+  const target = (window[0] + window[1]) / 2;
+  let bisect = false;
+  for (let i = 0;i < maxProbes; i++) {
+    const span = hi.height - lo.height;
+    if (span <= 1)
+      return null;
+    let h = Math.floor((lo.height + hi.height) / 2);
+    if (!bisect && lo.burn !== undefined && hi.burn !== undefined && hi.burn > lo.burn)
+      h = lo.height + Math.round((target - lo.burn) * span / (hi.burn - lo.burn));
+    h = Math.min(Math.max(h, lo.height + 1), hi.height - 1);
+    const p = await probe(h);
+    if (p.height <= lo.height || p.height >= hi.height)
+      return null;
+    if (p.burn >= window[0] && p.burn < window[1])
+      return p;
+    if (p.burn < window[0])
+      lo = p;
+    else
+      hi = p;
+    bisect = hi.height - lo.height > span / 2;
+  }
+  return null;
+}
+
+class BlockVerifier {
+  source;
+  checkpoint;
+  rows;
+  chain;
+  sets = new Map;
+  anchors = new Map;
+  headers = new Map;
+  burns = new Map;
+  preimages = new Map;
+  start;
+  constructor(opts) {
+    this.source = opts.source;
+    this.checkpoint = opts.checkpoint ?? MAINNET_CHECKPOINT;
+    this.rows = opts.rows ?? false;
+    const { stacks } = this.checkpoint;
+    const header = parseNakamotoHeader(unhex(stacks.header));
+    this.start = { header, id: hex(blockId(header)) };
+    this.headers.set(this.start.id, header);
+    this.sets.set(stacks.cycle, decodeSignerSet(stacks.signerSet));
+    this.chain = HeaderChain.fromCheckpoint(this.checkpoint.bitcoin);
+  }
+  async verify(ref) {
+    const out = { ok: false, notes: [], failures: [] };
+    try {
+      await this.run(ref, out);
+    } catch (err) {
+      if (!(err instanceof Broken))
+        throw err;
+      out.failures.unshift(err.failure);
+    }
+    out.ok = out.failures.length === 0;
+    return out;
+  }
+  async run(ref, out) {
+    const src = this.source;
+    const raw = await fetchFor("block", `block ${ref}`, () => src.getBlock(ref));
+    const header = parseHeader2(raw, "block");
+    const id = hex(blockId(header));
+    const height = Number(header.chainLength);
+    if (typeof ref === "string" && id !== ref.replace(/^0x/, "").toLowerCase())
+      fail({
+        step: "block",
+        code: "id-mismatch",
+        message: `source returned block ${id} for ${ref}`
+      });
+    if (typeof ref === "number" && height !== ref)
+      fail({
+        step: "block",
+        code: "height-mismatch",
+        message: `source returned height ${height} for ${ref}`
+      });
+    out.height = height;
+    out.blockId = id;
+    out.stateRoot = hex(header.stateIndexRoot);
+    const burn = await this.bindBurn(header, "burn");
+    const cycle = rewardCycle(burn.burnHeight);
+    out.burnHeight = burn.burnHeight;
+    out.bitcoinBlockHash = burn.hash;
+    out.cycle = cycle;
+    const set = await this.signerSet(cycle, {
+      height,
+      burn: burn.burnHeight
+    });
+    const sig = verifySignerSignatures(header, set);
+    out.signerWeight = sig.signedWeight;
+    out.totalWeight = sig.totalWeight;
+    out.threshold = sig.threshold;
+    if (!sig.valid)
+      fail(signatureFailure(sig, "signatures", cycle));
+    const witness = await fetchFor("witness", `witness ${id}`, () => src.getWitness(id));
+    const { getStateWrites, getVmEvents } = this.rows ? src : {};
+    const writes = getStateWrites ? await fetchFor("names", `state_writes ${height}`, () => getStateWrites.call(src, height)) : null;
+    const rows = getVmEvents ? await fetchFor("rows", `vm_events ${height}`, () => getVmEvents.call(src, height)) : undefined;
+    const parentId = hex(header.parentBlockId);
+    const state = await verifyBlockState({
+      height,
+      parentBlockId: header.parentBlockId,
+      stateRoot: header.stateIndexRoot,
+      witness,
+      writes,
+      rows,
+      parentLeaves: await this.parentLeaves(parentId, out.notes),
+      parentHolds: (leaf) => this.parentHolds(parentId, leaf)
+    });
+    out.diff = state.diff;
+    if (rows)
+      out.rowsChecked = state.rowsChecked;
+    out.notes.push(...state.notes);
+    out.failures.push(...state.failures);
+  }
+  async header(id, step, extra = {}) {
+    const known = this.headers.get(id);
+    if (known)
+      return known;
+    const raw = await fetchFor(step, `block ${id}`, () => this.source.getBlock(id), extra);
+    const header = parseHeader2(raw, step);
+    if (hex(blockId(header)) !== id)
+      fail({
+        step,
+        code: "id-mismatch",
+        message: `source returned another block for ${id}`,
+        blockId: id,
+        ...extra
+      });
+    this.headers.set(id, header);
+    return header;
+  }
+  async proveAt(tip, path, value, proof, step, extra = {}) {
+    const headers = [tip];
+    for (const id of marfProofAncestors(proof))
+      headers.push(await this.header(id, step, extra));
+    return verifyMarfProof({
+      proof,
+      path,
+      value,
+      root: tip.stateIndexRoot,
+      headers
+    });
+  }
+  async parentLeaves(parentId, notes) {
+    try {
+      const parent = await this.header(parentId, "names");
+      const w = parseWitness(await this.source.getWitness(parentId));
+      if (bytesEqual(w.root, parent.stateIndexRoot))
+        return w.leaves;
+      notes.push(`parent witness ${parentId} root does not match its header`);
+    } catch (err) {
+      notes.push(`parent witness ${parentId} unavailable: ${err.message}`);
+    }
+    return;
+  }
+  async parentHolds(parentId, leaf) {
+    const parent = await this.header(parentId, "names");
+    const pathHex = hex(leaf.path);
+    const answer = await fetchFor("names", `MARF ${pathHex} at parent`, () => this.source.getMarfProof(pathHex, parentId));
+    if (!answer)
+      return false;
+    const value = new Uint8Array(MARF_VALUE_SIZE);
+    value.set(leaf.valueHash);
+    return this.proveAt(parent, leaf.path, value, answer.proof, "names");
+  }
+  async bindBurn(header, step, extra = {}) {
+    const ch = hex(header.consensusHash);
+    const known = this.burns.get(ch);
+    if (known)
+      return known;
+    const bp = await fetchFor(step, `burn preimage ${ch}`, () => this.preimage(ch), extra);
+    const hash = verifyConsensusPreimage(header.consensusHash, bp.preimage);
+    if (!hash)
+      return fail({
+        step,
+        code: "preimage-mismatch",
+        message: `preimage does not hash to consensus hash ${ch}`,
+        ...extra
+      });
+    if (bp.burnHeight < this.chain.checkpointHeight)
+      fail({
+        step,
+        code: "before-checkpoint",
+        message: `burn height ${bp.burnHeight} is below the Bitcoin checkpoint ${this.chain.checkpointHeight}`,
+        ...extra
+      });
+    await this.syncBitcoin(bp.burnHeight);
+    const burnHeight = this.chain.heightOf(hash);
+    if (burnHeight === undefined)
+      return fail({
+        step,
+        code: "burn-not-in-chain",
+        message: `burn block ${hash} is not in the verified Bitcoin chain (synced ${this.chain.checkpointHeight}..${this.chain.tip.height})`,
+        ...extra
+      });
+    const bound = { burnHeight, hash };
+    this.burns.set(ch, bound);
+    return bound;
+  }
+  async syncBitcoin(height) {
+    while (this.chain.tip.height < height) {
+      const from = this.chain.tip.height + 1;
+      const count = Math.min(BITCOIN_BATCH, height - from + 1);
+      const headers = await fetchFor("bitcoin", `bitcoin headers ${from}`, () => this.source.getBitcoinHeaders(from, count));
+      if (headers.length === 0)
+        fail({
+          step: "bitcoin",
+          code: "unavailable",
+          message: `source has no Bitcoin headers from ${from}`
+        });
+      try {
+        this.chain.append(headers);
+      } catch (err) {
+        if (!(err instanceof HeaderValidationError))
+          throw err;
+        fail({ step: "bitcoin", code: "invalid-header", message: err.message });
+      }
+    }
+  }
+  async signerSet(cycle, target) {
+    const known = this.sets.get(cycle);
+    if (known)
+      return known;
+    const first = this.checkpoint.stacks.cycle;
+    if (cycle < first)
+      fail({
+        step: "signer-set",
+        code: "before-checkpoint",
+        message: `cycle ${cycle} precedes the checkpoint's cycle ${first}`,
+        cycle
+      });
+    let lo = await this.startPoint();
+    for (let c = first;c < cycle; c++) {
+      const next = this.sets.get(c + 1);
+      if (next) {
+        lo = this.anchors.get(c + 1) ?? lo;
+        continue;
+      }
+      const anchor = await this.locateAnchor(c + 1, lo, target);
+      this.sets.set(c + 1, await this.proveNextSet(c + 1, anchor));
+      this.anchors.set(c + 1, anchor);
+      lo = anchor;
+    }
+    return this.sets.get(cycle);
+  }
+  async startPoint() {
+    const { header } = this.start;
+    const height = Number(header.chainLength);
+    try {
+      return { height, burn: await this.burnHint(header) };
+    } catch {
+      return { height };
+    }
+  }
+  async burnHint(header) {
+    const ch = hex(header.consensusHash);
+    return this.burns.get(ch)?.burnHeight ?? (await this.preimage(ch)).burnHeight;
+  }
+  async preimage(ch) {
+    let bp = this.preimages.get(ch);
+    if (!bp) {
+      bp = await this.source.getBurnPreimage(ch);
+      this.preimages.set(ch, bp);
+    }
+    return bp;
+  }
+  async locateAnchor(cycle, lo, hi) {
+    const start = cycleStart(cycle);
+    const window = [start - MAINNET_PREPARE_LENGTH, start];
+    const probe = async (h) => {
+      const raw = await fetchFor("signer-set", `block at height ${h}`, () => this.source.getBlock(h), { cycle });
+      const header = parseHeader2(raw, "signer-set");
+      const id = hex(blockId(header));
+      this.headers.set(id, header);
+      const burn = await fetchFor("signer-set", `burn hint for block ${id}`, () => this.burnHint(header), { cycle, blockId: id });
+      return { height: Number(header.chainLength), burn, header, id };
+    };
+    const anchor = await findAnchor(lo, hi, window, probe);
+    if (!anchor)
+      return fail({
+        step: "signer-set",
+        code: "anchor-not-found",
+        message: `no block with a burn height in ${window[0]}..${window[1] - 1} (cycle ${cycle} prepare phase) between heights ${lo.height} and ${hi.height}`,
+        cycle
+      });
+    return anchor;
+  }
+  async proveNextSet(cycle, anchor) {
+    const at = { cycle, blockId: anchor.id };
+    const { burnHeight } = await this.bindBurn(anchor.header, "signer-set", at);
+    const start = cycleStart(cycle);
+    if (burnHeight < start - MAINNET_PREPARE_LENGTH || burnHeight >= start)
+      fail({
+        step: "signer-set",
+        code: "anchor-outside-window",
+        message: `anchor burn height ${burnHeight} is outside cycle ${cycle}'s prepare phase ${start - MAINNET_PREPARE_LENGTH}..${start - 1}`,
+        ...at
+      });
+    const signing = rewardCycle(burnHeight);
+    const sig = verifySignerSignatures(anchor.header, this.sets.get(signing));
+    if (!sig.valid)
+      fail({
+        ...signatureFailure(sig, "signer-set", signing),
+        ...at,
+        code: "anchor-unsigned"
+      });
+    const path = marfPath(mapEntryKey(SIGNERS_CONTRACT, "cycle-signer-set", uintCV(cycle)));
+    const answer = await fetchFor("signer-set", `signer set ${cycle} at ${anchor.id}`, () => this.source.getMarfProof(hex(path), anchor.id), at);
+    const value = answer?.data.replace(/^0x/, "") ?? "";
+    const proven = answer !== null && await this.proveAt(anchor.header, path, marfValue(value), answer.proof, "signer-set", at);
+    if (!proven)
+      fail({
+        step: "signer-set",
+        code: "set-proof-invalid",
+        message: `signer set ${cycle} is not proven in anchor ${anchor.id}'s state`,
+        ...at
+      });
+    let set;
+    try {
+      set = decodeSignerSet(value);
+    } catch (err) {
+      return fail({
+        step: "signer-set",
+        code: "set-proof-invalid",
+        message: `signer set ${cycle}: ${err.message}`,
+        ...at
+      });
+    }
+    return set;
+  }
+}
+function parseHeader2(raw, step) {
+  try {
+    return parseNakamotoHeader(raw);
+  } catch (err) {
+    return fail({
+      step,
+      code: "invalid-header",
+      message: `block bytes do not parse: ${err.message}`
+    });
+  }
+}
+function signatureFailure(sig, step, cycle) {
+  const weight = `${sig.signedWeight}/${sig.totalWeight} signed, threshold ${sig.threshold}`;
+  if (sig.unknown.length)
+    return {
+      step,
+      code: "unknown-signer",
+      message: `${sig.unknown.length} signer(s) not in cycle ${cycle}'s set (${weight})`,
+      cycle
+    };
+  if (sig.duplicates.length)
+    return {
+      step,
+      code: "duplicate-signer",
+      message: `${sig.duplicates.length} duplicate signature(s) (${weight})`,
+      cycle
+    };
+  if (sig.invalid)
+    return {
+      step,
+      code: "bad-signature",
+      message: `${sig.invalid} signature(s) do not recover (${weight})`,
+      cycle
+    };
+  return {
+    step,
+    code: "below-threshold",
+    message: `cycle ${cycle} signers: ${weight}`,
+    cycle
+  };
+}
+var verifyBlock = (ref, opts) => new BlockVerifier(opts).verify(ref);
+export {
+  BlockVerifier,
+  HeaderChain,
+  HeaderValidationError,
+  MAINNET_CHECKPOINT,
+  MAINNET_FIRST_BURN_HEIGHT,
+  MAINNET_PREPARE_LENGTH,
+  MAINNET_REWARD_CYCLE_LENGTH,
+  NodeRpcProofSource,
+  SIGNERS_CONTRACT,
+  SecondlayerProofSource,
+  SourceError,
+  blockId,
+  classifyBlockDiff,
+  cycleStart,
+  dataVarKey,
+  decodeSignerSet,
+  ftBalanceKey,
+  hex,
+  mapEntryKey,
+  marfPath,
+  marfProofAncestors,
+  marfValue,
+  parseNakamotoHeader,
+  parseWitness,
+  rewardCycle,
+  signerSignatureHash,
+  unhex,
+  verifyBlock,
+  verifyBlockState,
+  verifyConsensusPreimage,
+  verifyMarfProof,
+  verifySignerSignatures
+};
+
+//# debugId=67FB81E2AAB4645564756E2164756E21
+//# sourceMappingURL=index.js.map