@orangecheck/stamp-ots 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,5 +1,9 @@
 'use strict';
 
+var sha2 = require('@noble/hashes/sha2');
+var legacy = require('@noble/hashes/legacy');
+var sha3 = require('@noble/hashes/sha3');
+
 // src/types.ts
 function toStampOts(p) {
   return {
@@ -128,12 +132,12 @@ function createCalendarClient(url, opts = {}) {
       const buf = await resp.arrayBuffer();
       return new Uint8Array(buf);
     },
-    async fetchProof(digest, signal) {
-      if (digest.byteLength !== 32) {
-        throw new Error("OTS: digest must be exactly 32 bytes");
+    async fetchProof(commitment, signal) {
+      if (commitment.byteLength === 0 || commitment.byteLength > 64) {
+        throw new Error("OTS: commitment must be 1-64 bytes");
       }
       const ac = withTimeout(signal, timeoutMs);
-      const resp = await fetchImpl(`${base}/timestamp/${hexEncode(digest)}`, {
+      const resp = await fetchImpl(`${base}/timestamp/${hexEncode(commitment)}`, {
         method: "GET",
         headers: { Accept: "application/vnd.opentimestamps.v1" },
         signal: ac.signal
@@ -202,71 +206,300 @@ async function submitToCalendars(idHex, opts = {}) {
     upgradedAt: null
   };
 }
-
-// src/upgrade.ts
-async function upgradeProof(current, idHex, opts) {
-  if (current.status === "confirmed") return current;
-  const digest = hexDecode(idHex);
-  const clients = current.calendars.map(
-    (url) => createCalendarClient(url, { fetch: opts.fetch, timeoutMs: opts.timeoutMs })
-  );
-  if (clients.length === 0) {
-    throw new Error("upgradeProof: no calendars listed in current proof");
+var HEADER_MAGIC = new Uint8Array([
+  0,
+  79,
+  112,
+  101,
+  110,
+  84,
+  105,
+  109,
+  101,
+  115,
+  116,
+  97,
+  109,
+  112,
+  115,
+  0,
+  0,
+  80,
+  114,
+  111,
+  111,
+  102,
+  0,
+  191,
+  137,
+  226,
+  232,
+  132,
+  232,
+  146,
+  148
+]);
+var TAG_BITCOIN = "0588960d73d71901";
+var TAG_PENDING = "83dfe30d2ef90c8e";
+var MAX_DEPTH = 256;
+var MAX_MSG = 4096;
+var Reader = class {
+  constructor(buf) {
+    this.buf = buf;
+    this.pos = 0;
   }
-  const attempts = await Promise.allSettled(
-    clients.map(async (c) => {
-      const proof = await c.fetchProof(digest, opts.signal);
-      if (!proof) return null;
-      const anchor = await opts.parseAnchor(proof);
-      return { url: c.url, proof, anchor };
-    })
-  );
-  for (const r of attempts) {
-    if (r.status !== "fulfilled" || r.value === null) continue;
-    const { url, proof, anchor } = r.value;
-    if (anchor) {
-      return {
-        status: "confirmed",
-        proof: base64Encode(proof),
-        calendars: uniqueFirst(current.calendars, url),
-        blockHeight: anchor.blockHeight,
-        blockHash: anchor.blockHash,
-        upgradedAt: (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d+Z$/, "Z")
-      };
+  byte() {
+    if (this.pos >= this.buf.length) throw new Error("ots: unexpected end of proof");
+    return this.buf[this.pos++];
+  }
+  bytes(n) {
+    if (n < 0 || this.pos + n > this.buf.length) throw new Error("ots: unexpected end of proof");
+    const out = this.buf.subarray(this.pos, this.pos + n);
+    this.pos += n;
+    return out;
+  }
+  varuint() {
+    let value = 0;
+    let shift = 0;
+    for (; ; ) {
+      const b = this.byte();
+      value += (b & 127) * 2 ** shift;
+      if (!(b & 128)) return value;
+      shift += 7;
+      if (shift > 49) throw new Error("ots: varuint too large");
     }
   }
-  let longest = null;
-  for (const r of attempts) {
-    if (r.status !== "fulfilled" || r.value === null) continue;
-    if (!longest || r.value.proof.byteLength > longest.proof.byteLength) {
-      longest = { url: r.value.url, proof: r.value.proof };
+  varbytes(max) {
+    const n = this.varuint();
+    if (n > max) throw new Error("ots: varbytes too long");
+    return this.bytes(n);
+  }
+  get done() {
+    return this.pos === this.buf.length;
+  }
+};
+var UNARY = {
+  2: "sha1",
+  3: "ripemd160",
+  8: "sha256",
+  103: "keccak256",
+  242: "reverse",
+  243: "hexlify"
+};
+function applyOp(op, msg) {
+  switch (op.kind) {
+    case "sha256":
+      return sha2.sha256(msg);
+    case "ripemd160":
+      return legacy.ripemd160(msg);
+    case "sha1":
+      return legacy.sha1(msg);
+    case "keccak256":
+      return sha3.keccak_256(msg);
+    case "reverse":
+      return new Uint8Array(msg).reverse();
+    case "hexlify":
+      return new TextEncoder().encode(hexEncode(msg));
+    case "append":
+      return concat(msg, op.arg);
+    case "prepend":
+      return concat(op.arg, msg);
+  }
+}
+function readOp(r, tag) {
+  const unary = UNARY[tag];
+  if (unary) return { kind: unary };
+  if (tag === 240) return { kind: "append", arg: r.varbytes(MAX_MSG) };
+  if (tag === 241) return { kind: "prepend", arg: r.varbytes(MAX_MSG) };
+  throw new Error(`ots: unknown op tag 0x${tag.toString(16)}`);
+}
+function readAttestation(r) {
+  const tag = hexEncode(r.bytes(8));
+  const payload = r.varbytes(8192);
+  const p = new Reader(payload);
+  if (tag === TAG_BITCOIN) return { kind: "bitcoin", height: p.varuint() };
+  if (tag === TAG_PENDING) return { kind: "pending", uri: new TextDecoder().decode(p.varbytes(1e3)) };
+  return { kind: "unknown", tag, payload };
+}
+function readTimestamp(r, msg, depth) {
+  if (depth > MAX_DEPTH) throw new Error("ots: proof too deep");
+  const node = { msg, attestations: [], ops: [] };
+  const item = (tag2) => {
+    if (tag2 === 0) {
+      node.attestations.push(readAttestation(r));
+      return;
     }
+    const op = readOp(r, tag2);
+    const next = applyOp(op, msg);
+    if (next.length > MAX_MSG) throw new Error("ots: message too long");
+    node.ops.push({ op, child: readTimestamp(r, next, depth + 1) });
+  };
+  let tag = r.byte();
+  while (tag === 255) {
+    item(r.byte());
+    tag = r.byte();
   }
-  if (longest) {
-    const currentBytes = base64Decode(current.proof);
-    if (longest.proof.byteLength > currentBytes.byteLength) {
-      return {
-        status: "pending",
-        proof: base64Encode(longest.proof),
-        calendars: uniqueFirst(current.calendars, longest.url),
-        blockHeight: null,
-        blockHash: null,
-        upgradedAt: null
-      };
+  item(tag);
+  return node;
+}
+function parseTimestamp(bytes, digest) {
+  const r = new Reader(bytes);
+  const ts = readTimestamp(r, digest, 0);
+  if (!r.done) throw new Error("ots: trailing bytes after timestamp");
+  return ts;
+}
+function isDetached(bytes) {
+  return bytes.length > HEADER_MAGIC.length && bytesEqual(bytes.subarray(0, HEADER_MAGIC.length), HEADER_MAGIC);
+}
+function parseDetached(bytes) {
+  if (!isDetached(bytes)) throw new Error("ots: missing detached-file header");
+  const r = new Reader(bytes.subarray(HEADER_MAGIC.length));
+  const major = r.varuint();
+  if (major !== 1) throw new Error(`ots: unsupported file version ${major}`);
+  if (r.byte() !== 8) throw new Error("ots: only sha256 file digests are supported");
+  const digest = new Uint8Array(r.bytes(32));
+  const timestamp = readTimestamp(r, digest, 0);
+  if (!r.done) throw new Error("ots: trailing bytes after timestamp");
+  return { digest, timestamp };
+}
+function parseProof(bytes, digest) {
+  if (!isDetached(bytes)) return parseTimestamp(bytes, digest);
+  const d = parseDetached(bytes);
+  if (!bytesEqual(d.digest, digest)) throw new Error("ots: proof commits to a different digest");
+  return d.timestamp;
+}
+function attestations(ts) {
+  const out = [];
+  const walk = (n) => {
+    for (const a of n.attestations) out.push({ msg: n.msg, attestation: a });
+    for (const { child } of n.ops) walk(child);
+  };
+  walk(ts);
+  return out;
+}
+function bitcoinAnchors(ts) {
+  return attestations(ts).flatMap(
+    ({ msg, attestation }) => attestation.kind === "bitcoin" ? [{ blockHeight: attestation.height, merkleRoot: msg }] : []
+  ).sort((a, b) => a.blockHeight - b.blockHeight);
+}
+function pendingCommitments(ts) {
+  return attestations(ts).flatMap(
+    ({ msg, attestation }) => attestation.kind === "pending" ? [{ uri: attestation.uri, commitment: msg }] : []
+  );
+}
+function mergeAt(ts, upgrade) {
+  if (bytesEqual(ts.msg, upgrade.msg)) {
+    for (const a of upgrade.attestations) {
+      if (!ts.attestations.some((b) => attestationKey(b) === attestationKey(a))) ts.attestations.push(a);
     }
+    for (const { op, child } of upgrade.ops) {
+      const same = ts.ops.find((o) => opKey(o.op) === opKey(op));
+      if (same) mergeAt(same.child, child);
+      else ts.ops.push({ op, child });
+    }
+    return true;
   }
-  return current;
+  return ts.ops.some(({ child }) => mergeAt(child, upgrade));
+}
+function writeVaruint(out, n) {
+  do {
+    let b = n % 128;
+    n = Math.floor(n / 128);
+    if (n > 0) b |= 128;
+    out.push(b);
+  } while (n > 0);
 }
-function uniqueFirst(arr, first) {
-  const out = [first];
-  for (const x of arr) if (x !== first && !out.includes(x)) out.push(x);
+function writeVarbytes(out, bytes) {
+  writeVaruint(out, bytes.length);
+  out.push(...bytes);
+}
+var OP_TAG = {
+  sha1: 2,
+  ripemd160: 3,
+  sha256: 8,
+  keccak256: 103,
+  append: 240,
+  prepend: 241,
+  reverse: 242,
+  hexlify: 243
+};
+function writeAttestation(out, a) {
+  const payload = [];
+  let tag;
+  if (a.kind === "bitcoin") {
+    tag = TAG_BITCOIN;
+    writeVaruint(payload, a.height);
+  } else if (a.kind === "pending") {
+    tag = TAG_PENDING;
+    writeVarbytes(payload, new TextEncoder().encode(a.uri));
+  } else {
+    tag = a.tag;
+    payload.push(...a.payload);
+  }
+  out.push(0);
+  for (let i = 0; i < 16; i += 2) out.push(parseInt(tag.slice(i, i + 2), 16));
+  writeVarbytes(out, new Uint8Array(payload));
+}
+function writeTimestamp(out, ts) {
+  const items = [
+    ...ts.attestations.map((a) => () => writeAttestation(out, a)),
+    ...ts.ops.map(({ op, child }) => () => {
+      out.push(OP_TAG[op.kind]);
+      if (op.kind === "append" || op.kind === "prepend") writeVarbytes(out, op.arg);
+      writeTimestamp(out, child);
+    })
+  ];
+  if (items.length === 0) throw new Error("ots: cannot serialize an empty timestamp node");
+  items.forEach((write, i) => {
+    if (i < items.length - 1) out.push(255);
+    write();
+  });
+}
+function serializeTimestamp(ts) {
+  const out = [];
+  writeTimestamp(out, ts);
+  return new Uint8Array(out);
+}
+function attestationKey(a) {
+  if (a.kind === "bitcoin") return `b:${a.height}`;
+  if (a.kind === "pending") return `p:${a.uri}`;
+  return `u:${a.tag}:${hexEncode(a.payload)}`;
+}
+function opKey(op) {
+  return "arg" in op ? `${op.kind}:${hexEncode(op.arg)}` : op.kind;
+}
+function concat(a, b) {
+  const out = new Uint8Array(a.length + b.length);
+  out.set(a, 0);
+  out.set(b, a.length);
   return out;
 }
+function bytesEqual(a, b) {
+  if (a.byteLength !== b.byteLength) return false;
+  for (let i = 0; i < a.byteLength; i++) if (a[i] !== b[i]) return false;
+  return true;
+}
 
 // src/anchor.ts
+async function walkOtsProof(input) {
+  try {
+    const anchors = bitcoinAnchors(parseProof(input.proofBytes, input.digest));
+    return anchors.find((a) => a.blockHeight === input.blockHeight) ?? anchors[0] ?? null;
+  } catch {
+    return null;
+  }
+}
+function blockHashOf(header) {
+  return hexEncode(sha2.sha256(sha2.sha256(header)).reverse());
+}
 function makeAnchorVerifier(cfg) {
-  return async (input) => {
-    const walked = await cfg.walkProof({ proofBytes: input.proofBytes, digest: input.digest });
+  const walkProof = cfg.walkProof ?? walkOtsProof;
+  const verifier = async (input) => {
+    const walked = await walkProof({
+      proofBytes: input.proofBytes,
+      digest: input.digest,
+      blockHeight: input.blockHeight
+    });
     if (!walked) {
       return { ok: false, reason: "proof could not be walked to a Bitcoin commitment" };
     }
@@ -277,50 +510,122 @@ function makeAnchorVerifier(cfg) {
       };
     }
     const header = await cfg.headerSource.getHeaderAt(input.blockHeight);
-    if (!header) {
+    if (!header || header.byteLength !== 80) {
       return { ok: false, reason: `no block header available at height ${input.blockHeight}` };
     }
-    if (header.byteLength < 80) {
-      return { ok: false, reason: "malformed Bitcoin header (too short)" };
+    if (blockHashOf(header) !== input.blockHash.toLowerCase()) {
+      return { ok: false, reason: "block header does not hash to the declared block hash" };
     }
-    const headerMerkleLE = header.subarray(36, 68);
-    const headerMerkleBE = new Uint8Array(headerMerkleLE).reverse();
-    const matchesLE = bytesEqual(headerMerkleLE, walked.merkleRoot);
-    const matchesBE = bytesEqual(headerMerkleBE, walked.merkleRoot);
-    if (!matchesLE && !matchesBE) {
+    const headerMerkle = header.subarray(36, 68);
+    if (!bytesEqual(headerMerkle, walked.merkleRoot)) {
       return { ok: false, reason: "block header Merkle root does not match walked proof root" };
     }
-    return { ok: true, merkleRoot: hexEncode(matchesBE ? headerMerkleBE : headerMerkleLE) };
+    return { ok: true, merkleRoot: hexEncode(headerMerkle) };
   };
-}
-function bytesEqual(a, b) {
-  if (a.byteLength !== b.byteLength) return false;
-  for (let i = 0; i < a.byteLength; i++) if (a[i] !== b[i]) return false;
-  return true;
-}
-function adaptAnchorVerifier(verifier, digestLookup) {
-  return async (proofB64, blockHeight, blockHash) => {
+  return async (proofB64, blockHeight, blockHash, envelopeId) => {
     const r = await verifier({
       proofBytes: base64Decode(proofB64),
-      digest: digestLookup(blockHash),
+      digest: hexDecode(envelopeId),
       blockHeight,
       blockHash
     });
     return r.ok;
   };
 }
+async function makeDefaultAnchorVerifier(opts) {
+  return makeAnchorVerifier({ headerSource: opts.headerSource });
+}
+function mempoolHeaderSource(opts = {}) {
+  const base = (opts.baseUrl ?? "https://mempool.space/api").replace(/\/+$/, "");
+  const fetchImpl = opts.fetch ?? globalThis.fetch.bind(globalThis);
+  return {
+    async getHeaderAt(height) {
+      const h = await fetchImpl(`${base}/block-height/${height}`);
+      if (!h.ok) return null;
+      const hash = (await h.text()).trim();
+      if (!/^[0-9a-f]{64}$/.test(hash)) return null;
+      const r = await fetchImpl(`${base}/block/${hash}/header`);
+      if (!r.ok) return null;
+      const hex = (await r.text()).trim();
+      return /^[0-9a-f]{160}$/.test(hex) ? hexDecode(hex) : null;
+    }
+  };
+}
+
+// src/upgrade.ts
+var norm = (u) => u.replace(/\/+$/, "");
+async function upgradeProof(current, idHex, opts) {
+  if (current.status === "confirmed") return current;
+  if (!opts.headerSource && !opts.parseAnchor) {
+    throw new Error("upgradeProof: pass headerSource or parseAnchor");
+  }
+  const before = base64Decode(current.proof);
+  const tree = parseProof(before, hexDecode(idHex));
+  const listed = new Set(current.calendars.map(norm));
+  const pending = pendingCommitments(tree).filter((p) => listed.has(norm(p.uri)));
+  if (pending.length === 0 && bitcoinAnchors(tree).length === 0) {
+    throw new Error("upgradeProof: proof has no pending attestation from a listed calendar");
+  }
+  const answered = [];
+  await Promise.allSettled(
+    pending.map(async ({ uri, commitment }) => {
+      const client = createCalendarClient(uri, { fetch: opts.fetch, timeoutMs: opts.timeoutMs });
+      const bytes = await client.fetchProof(commitment, opts.signal);
+      if (!bytes) return;
+      if (mergeAt(tree, parseTimestamp(bytes, commitment))) answered.push(norm(uri));
+    })
+  );
+  const merged = serializeTimestamp(tree);
+  const anchor = await resolveAnchor(merged, tree, opts);
+  const calendars = [...answered, ...current.calendars.filter((c) => !answered.includes(norm(c)))];
+  if (anchor) {
+    return {
+      status: "confirmed",
+      proof: base64Encode(merged),
+      calendars,
+      blockHeight: anchor.blockHeight,
+      blockHash: anchor.blockHash,
+      upgradedAt: (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d+Z$/, "Z")
+    };
+  }
+  if (!bytesEqual(merged, before)) {
+    return { ...current, proof: base64Encode(merged), calendars };
+  }
+  return current;
+}
+async function resolveAnchor(merged, tree, opts) {
+  if (opts.parseAnchor) return opts.parseAnchor(merged);
+  for (const a of bitcoinAnchors(tree)) {
+    const header = await opts.headerSource.getHeaderAt(a.blockHeight);
+    if (header && header.byteLength === 80 && bytesEqual(header.subarray(36, 68), a.merkleRoot)) {
+      return { blockHeight: a.blockHeight, blockHash: blockHashOf(header) };
+    }
+  }
+  return null;
+}
 
 exports.DEFAULT_CALENDARS = DEFAULT_CALENDARS;
-exports.adaptAnchorVerifier = adaptAnchorVerifier;
+exports.attestations = attestations;
 exports.base64Decode = base64Decode;
 exports.base64Encode = base64Encode;
+exports.bitcoinAnchors = bitcoinAnchors;
+exports.blockHashOf = blockHashOf;
 exports.createCalendarClient = createCalendarClient;
 exports.fromStampOts = fromStampOts;
 exports.hexDecode = hexDecode;
 exports.hexEncode = hexEncode;
 exports.makeAnchorVerifier = makeAnchorVerifier;
+exports.makeDefaultAnchorVerifier = makeDefaultAnchorVerifier;
+exports.mempoolHeaderSource = mempoolHeaderSource;
+exports.mergeAt = mergeAt;
+exports.parseDetached = parseDetached;
+exports.parseProof = parseProof;
+exports.parseTimestamp = parseTimestamp;
+exports.pendingCommitments = pendingCommitments;
+exports.serializeTimestamp = serializeTimestamp;
 exports.submitToCalendars = submitToCalendars;
 exports.toStampOts = toStampOts;
 exports.upgradeProof = upgradeProof;
+exports.walkOtsProof = walkOtsProof;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map