@orangecheck/vote-cli 0.7.4 → 0.7.6

package/dist/cli.js

@@ -1,19 +1,22 @@
 #!/usr/bin/env node
+import { createRequire } from 'module';
 import { Command, Option } from 'commander';
 import WebSocket from 'ws';
 import { generateX25519KeyPair, hexEncode, utf8Encode, hexDecode, utf8Decode } from '@orangecheck/lock-crypto';
-import { ballotId, lastAnchorHeight, ANCHOR_FINAL_CONFIRMATIONS, pollId, verifyPoll, canonicalBytes, commit, isAnchoredPoll, resolveCloseBlock, mempoolBlockTimeSource, anchoredTallyIsFinal, revealId, distinctBallotCopies, anchorHeightFromStamps, verifyReveal, resolvePollSnapshot, tally, ballotStampContent } from '@orangecheck/vote-core';
+import { isAnchoredPoll, ballotId, lastAnchorHeight, ANCHOR_FINAL_CONFIRMATIONS, pollId, verifyPoll, canonicalBytes, commit, anchoredTallyIsFinal, revealId, distinctBallotCopies, resolveCloseBlock, mempoolBlockTimeSource, anchorHeightFromStamps, resolvePollSnapshot, tally, ballotStampContent, verifyBallot, verifyReveal } from '@orangecheck/vote-core';
 import { schnorr } from '@noble/curves/secp256k1';
 import { sha256 } from '@noble/hashes/sha256';
 import { randomBytes, bytesToHex, hexToBytes } from '@noble/hashes/utils';
 import { verifySignature, addressFromPrivateKey, signMessage } from '@orangecheck/bip322';
-import { stamp, canonicalizeEnvelope, parseStamp, computeEnvelopeId } from '@orangecheck/stamp-core';
+import { stamp, verify, canonicalizeEnvelope, parseStamp, computeEnvelopeId } from '@orangecheck/stamp-core';
 import { mempoolHeaderSource, submitToCalendars, toStampOts, verifiedAnchor } from '@orangecheck/stamp-ots';
-import { DEFAULT_RELAYS, publishEvent, queryEvents } from '@orangecheck/nostr-core';
+import { DEFAULT_RELAYS, queryEvents, publishEvent, verifyEvent, matchFilter } from '@orangecheck/nostr-core';
 import { createInterface } from 'readline/promises';
+import { readFileSync } from 'fs';
 import { seal, unseal } from '@orangecheck/lock-core';
 
 var QUERY_TIMEOUT_MS = 8e3;
+var PAGED_READ_DEADLINE_MS = 2 * QUERY_TIMEOUT_MS;
 function reachedEose(relayStatus) {
   return relayStatus.some((r) => r.eose);
 }
@@ -21,14 +24,25 @@ async function query(filter, relays) {
   const { events, relayStatus } = await queryEvents(filter, relays, QUERY_TIMEOUT_MS);
   return { events, complete: reachedEose(relayStatus) };
 }
-function fetchPollEvents(pollId3, relays) {
-  return query({ kinds: [30080], "#d": [`oc-vote:poll:${pollId3}`] }, relays);
+function fetchPollEvents(pollId5, relays) {
+  return query({ kinds: [30080], "#d": [`oc-vote:poll:${pollId5}`] }, relays);
 }
-function fetchBallotEvents(pollId3, relays, queryFn) {
-  return queryPaged({ kinds: [30081], "#t": [pollId3] }, relays, queryFn);
+function fetchBallotEvents(pollId5, relays, queryFn) {
+  return queryPaged({ kinds: [30081], "#t": [pollId5] }, relays, queryFn);
 }
 var PAGE_SIZE = 100;
 var MAX_PAGES = 20;
+var WRITE_QUORUM = 2;
+function readFloor(asked) {
+  return Math.max(1, asked - WRITE_QUORUM + 1);
+}
+function readShortfall(reads) {
+  const cut = reads.filter((r) => r.truncated).map((r) => r.relay);
+  if (cut.length) return `was cut short on ${cut.join(", ")}`;
+  const finished = reads.filter((r) => r.answered).length;
+  const floor = readFloor(reads.length);
+  return finished < floor ? `finished on ${finished} of ${reads.length} relays, fewer than the ${floor} a count needs` : null;
+}
 async function pageRelay(filter, relay, queryFn) {
   const byId = /* @__PURE__ */ new Map();
   const done = (answered, truncated = false) => ({
@@ -36,21 +50,27 @@ async function pageRelay(filter, relay, queryFn) {
     read: { relay, answered, truncated }
   });
   let until;
+  const deadlineAt = Date.now() + PAGED_READ_DEADLINE_MS;
   for (let page = 0; page < MAX_PAGES; page++) {
+    const budget = Math.min(QUERY_TIMEOUT_MS, deadlineAt - Date.now());
+    if (budget <= 0) return done(false, true);
     const { events, relayStatus } = await queryFn(
       { ...filter, limit: PAGE_SIZE, ...until !== void 0 ? { until } : {} },
       [relay],
-      QUERY_TIMEOUT_MS
+      budget
     );
     const status = relayStatus.find((s) => s.relay === relay) ?? relayStatus[0];
-    if (!status?.eose) return done(false);
+    const sent = (status?.events ?? 0) + (status?.rejected ?? 0);
+    const known = byId.size;
     for (const e of events) byId.set(e.id, e);
-    if (events.length < PAGE_SIZE) return done(true);
+    if (!status?.eose) return done(false, page > 0 || sent > 0);
+    if (sent < PAGE_SIZE) return done(true);
+    if (byId.size === known) return done(false, true);
     const oldest = Math.min(...events.map((e) => e.created_at));
-    if (events.every((e) => e.created_at === oldest)) return done(true, true);
+    if (events.every((e) => e.created_at === oldest)) return done(false, true);
     until = oldest;
   }
-  return done(true, true);
+  return done(false, true);
 }
 async function queryPaged(filter, relays = DEFAULT_RELAYS, queryFn = queryEvents) {
   const results = await Promise.all(relays.map((r) => pageRelay(filter, r, queryFn)));
@@ -58,12 +78,12 @@ async function queryPaged(filter, relays = DEFAULT_RELAYS, queryFn = queryEvents
   for (const r of results) for (const e of r.events) byId.set(e.id, e);
   return {
     events: [...byId.values()].sort((a, b) => b.created_at - a.created_at),
-    complete: results.some((r) => r.read.answered),
+    complete: readShortfall(results.map((r) => r.read)) === null,
     relays: results.map((r) => r.read)
   };
 }
-function fetchRevealEvents(pollId3, relays) {
-  return query({ kinds: [30082], "#d": [`oc-vote:reveal:${pollId3}`] }, relays);
+function fetchRevealEvents(pollId5, relays, queryFn) {
+  return queryPaged({ kinds: [30082], "#d": [`oc-vote:reveal:${pollId5}`] }, relays, queryFn);
 }
 function fetchRecentPolls(limit = 30, relays) {
   return query({ kinds: [30080], "#t": ["oc-vote-poll"], limit }, relays);
@@ -142,15 +162,17 @@ async function anchoredChain(poll, ballotIds, opts) {
   );
   if (!close.ok) throw new Error(`the block at the deadline could not be read (${close.code}): ${close.reason}`);
   const read = await fetchBallotStamps(ballotIds, opts.relays ?? DEFAULT_RELAYS, opts.queryFn);
-  if (!read.relays.some((r) => r.answered)) throw new Error("no relay finished answering the stamp query; try again");
+  if (!read.relays.some((r) => r.answered || r.truncated)) {
+    throw new Error("no relay finished answering the stamp query; try again");
+  }
   const headers = opts.headers ?? cachedHeaders(mempoolHeaderSource(opts.mempoolBase ? { baseUrl: opts.mempoolBase } : {}));
   const verify = stampAnchorVerifier(headers);
   const heights = /* @__PURE__ */ new Map();
   for (const [id, copies] of read.stamps) heights.set(id, await anchorHeightFromStamps(id, copies, (s) => verify(s)));
   const stampsDone = read.relays.filter((r) => r.answered && !r.truncated).map((r) => r.relay);
-  const ballotsCut = opts.ballotRelays.filter((r) => r.truncated).map((r) => r.relay);
+  const ballotsShort = readShortfall(opts.ballotRelays);
   const stampsMissing = opts.ballotRelays.filter((r) => r.answered && !stampsDone.includes(r.relay)).map((r) => r.relay);
-  const incomplete = ballotsCut.length ? `the ballot lookup was cut short on ${ballotsCut.join(", ")}` : stampsMissing.length ? `the stamp lookup did not finish on ${stampsMissing.join(", ")}` : null;
+  const incomplete = ballotsShort ? `the ballot lookup ${ballotsShort}` : stampsMissing.length ? `the stamp lookup did not finish on ${stampsMissing.join(", ")}` : null;
   const finalAt = close.height === null ? null : lastAnchorHeight(close.height) + ANCHOR_FINAL_CONFIRMATIONS;
   const finalBlocked = incomplete && finalAt !== null && close.tip >= finalAt ? incomplete : null;
   return {
@@ -243,6 +265,215 @@ function buildStampEvent(env) {
   const { tags, content } = stampEventParts(env);
   return sign(STAMP_KIND, tags, content);
 }
+async function bip322Verify(args) {
+  return verifySignature(args.address, args.message, args.signature);
+}
+
+// src/quorum.ts
+function writeQuorum(asked) {
+  return Math.max(1, Math.min(WRITE_QUORUM, asked));
+}
+function isIn(serving, asked) {
+  return serving >= writeQuorum(asked);
+}
+function parsed(content, kind) {
+  try {
+    const o = JSON.parse(content);
+    return o && typeof o === "object" && o.kind === kind ? o : null;
+  } catch {
+    return null;
+  }
+}
+function ballotOf(ev) {
+  return parsed(ev.content, "oc-vote/ballot");
+}
+function pollOf(ev) {
+  return parsed(ev.content, "oc-vote/poll");
+}
+function revealOf(ev) {
+  return parsed(ev.content, "oc-vote/reveal");
+}
+function stampIn(content) {
+  try {
+    return parseStamp(JSON.parse(content));
+  } catch {
+    return null;
+  }
+}
+function stampOf(ev) {
+  return stampIn(ev.content);
+}
+function safely(id, x) {
+  try {
+    return id(x);
+  } catch {
+    return null;
+  }
+}
+async function relaysServing(filter, accept, opts = {}) {
+  const relays = opts.relays ?? DEFAULT_RELAYS;
+  const query2 = opts.query ?? queryEvents;
+  const checked = /* @__PURE__ */ new Map();
+  const valid = (ev) => {
+    if (!verifyEvent(ev) || !matchFilter(ev, filter)) return Promise.resolve(false);
+    let check = checked.get(ev.content);
+    if (!check) {
+      check = accept(ev.content).catch(() => false);
+      checked.set(ev.content, check);
+    }
+    return check;
+  };
+  const held = await Promise.all(
+    relays.map(async (url) => {
+      const read = await pageRelay(filter, url, query2).catch(() => null);
+      for (const ev of read?.events ?? []) if (await valid(ev)) return url;
+      return null;
+    })
+  );
+  return held.filter((u) => u !== null);
+}
+function relaysServingBallot(ballot, opts = {}) {
+  const id = ballotId(ballot);
+  const verify = opts.verify ?? bip322Verify;
+  const filter = { kinds: [30081], "#d": [`oc-vote:ballot:${ballot.poll_id}:${ballot.voter}`], "#t": [ballot.poll_id] };
+  return relaysServing(
+    filter,
+    async (content) => {
+      const copy = parsed(content, "oc-vote/ballot");
+      return !!copy && safely(ballotId, copy) === id && (await verifyBallot(copy, verify)).ok;
+    },
+    opts
+  );
+}
+function relaysServingPoll(poll, opts = {}) {
+  const id = pollId(poll);
+  const verify = opts.verify ?? bip322Verify;
+  return relaysServing(
+    { kinds: [30080], "#d": [`oc-vote:poll:${id}`] },
+    async (content) => {
+      const copy = parsed(content, "oc-vote/poll");
+      return !!copy && safely(pollId, copy) === id && (await verifyPoll(copy, verify)).ok;
+    },
+    opts
+  );
+}
+function relaysServingReveal(reveal, poll, opts = {}) {
+  const id = revealId(reveal);
+  const verify = opts.verify ?? bip322Verify;
+  return relaysServing(
+    { kinds: [30082], "#d": [`oc-vote:reveal:${reveal.poll_id}`] },
+    async (content) => {
+      const copy = parsed(content, "oc-vote/reveal");
+      return !!copy && safely(revealId, copy) === id && (await verifyReveal(copy, poll, verify, Date.now(), opts.chain)).ok;
+    },
+    opts
+  );
+}
+var stampSigVerifier = (verify) => (message, signature, address) => Promise.resolve(verify({ address, message, signature }));
+function relaysServingStamp(env, opts = {}) {
+  const verify$1 = opts.verify ?? bip322Verify;
+  return relaysServing(
+    { kinds: [STAMP_KIND], "#d": [`oc-stamp:${env.id}`] },
+    async (content) => {
+      const copy = stampIn(content);
+      if (!copy || copy.id !== env.id) return false;
+      return (await verify({ envelope: copy, verifyBip322: stampSigVerifier(verify$1) })).ok;
+    },
+    opts
+  );
+}
+async function castEvent(event, serving, readBack, opts = {}) {
+  const relays = opts.relays ?? DEFAULT_RELAYS;
+  const missing = relays.filter((r) => !serving.includes(r));
+  if (missing.length > 0) await (opts.publish ?? publishEvent)(event, missing);
+  return readBack();
+}
+function castBallot(event, ballot, serving, opts = {}) {
+  return castEvent(event, serving, () => relaysServingBallot(ballot, opts), opts);
+}
+
+// src/report.ts
+var NOT_IN_YET = 2;
+function standingIsIn(s) {
+  return isIn(s.serving.length, s.relays.length);
+}
+function standingJson(s) {
+  return { in: standingIsIn(s), served_by: s.serving, asked: s.relays.length, quorum: writeQuorum(s.relays.length) };
+}
+var LABEL = { poll: "published:", ballot: "in:", reveal: "published:", stamp: "stamp:" };
+var MISSED = {
+  poll: "so no one can find it",
+  ballot: "so a count would not see it",
+  reveal: "so a count would not see it",
+  stamp: "so a final count would not see it"
+};
+var SURE = {
+  poll: "it is sure to be found",
+  ballot: "a count is sure to see it",
+  reveal: "a count is sure to see it",
+  stamp: "a final count is sure to see it"
+};
+function standingLines(s, file) {
+  const asked = s.relays.length;
+  const n = s.serving.length;
+  const label = `  ${LABEL[s.kind].padEnd(12)}`;
+  const lines = [];
+  if (standingIsIn(s)) {
+    lines.push(`${label}yes, ${n} of ${asked} relays serve it back`);
+    if (s.kind === "stamp") lines.push(`              a Bitcoin block usually anchors it within an hour or two`);
+  } else if (n === 0) {
+    lines.push(`${label}not yet: no relay serves it back, ${MISSED[s.kind]}`);
+  } else {
+    lines.push(
+      `${label}not yet: only ${n} of ${asked} relays serves it back, and ${SURE[s.kind]} only once ${writeQuorum(asked)} do`
+    );
+  }
+  for (const relay of s.relays) lines.push(`    ${s.serving.includes(relay) ? "\u2713" : "\u2717"} ${relay}`);
+  if (standingIsIn(s)) return lines;
+  if (s.kind === "stamp") lines.push(`              vote.ochk.io's anchorer also stamps every ballot it sees`);
+  if (file) {
+    lines.push(`  again:      oc-vote republish ${file}`);
+    lines.push(`              sends the same signed ${s.kind}, with nothing new to sign`);
+  } else {
+    lines.push(`  again:      save the signed event below to a file and run oc-vote republish <file>;`);
+    lines.push(`              it sends the same signed ${s.kind}, with nothing new to sign`);
+    lines.push(`  event:      ${JSON.stringify(s.event)}`);
+  }
+  return lines;
+}
+function report(r) {
+  const stamp2 = r.stamp && "kind" in r.stamp ? r.stamp : null;
+  if (!standingIsIn(r.main) || stamp2 && !standingIsIn(stamp2)) process.exitCode = NOT_IN_YET;
+  if (r.json) {
+    const stampJson = r.stamp ? "kind" in r.stamp ? { ...standingJson(r.stamp), event: r.stamp.event } : r.stamp : null;
+    process.stdout.write(
+      JSON.stringify(
+        {
+          [r.id[0]]: r.id[1],
+          ...standingJson(r.main),
+          ...stampJson ? { stamp: stampJson } : {},
+          ...r.jsonExtra,
+          event: r.main.event
+        },
+        null,
+        2
+      ) + "\n"
+    );
+    return;
+  }
+  const lines = [`  ${`${r.id[0]}:`.padEnd(12)}${r.id[1]}`];
+  for (const [k, v] of r.heading ?? []) lines.push(`  ${`${k}:`.padEnd(12)}${v}`);
+  lines.push(...standingLines(r.main, r.file));
+  if (stamp2) lines.push(...standingLines(stamp2));
+  else if (r.stamp && "error" in r.stamp) {
+    lines.push(`  stamp:      not made here (${r.stamp.error}); vote.ochk.io's anchorer stamps every ballot it sees`);
+  }
+  lines.push(...r.tail ?? []);
+  process.stdout.write(`
+${lines.join("\n")}
+
+`);
+}
 async function promptForSignature(address, id, preset) {
   if (preset && preset.trim()) return preset.trim();
   process.stderr.write(
@@ -308,60 +539,28 @@ async function runCreate(opts) {
   const sigValue = await promptForSignature(opts.creator, pid, opts.sig);
   draft.sig.value = sigValue;
   const event = buildPollEvent(draft);
-  const results = await publishEvent(event, opts.relays ?? DEFAULT_RELAYS);
-  const okCount = results.filter((r) => r.ok).length;
-  if (opts.json) {
-    process.stdout.write(
-      JSON.stringify(
-        {
-          poll_id: pid,
-          published: okCount,
-          total: results.length,
-          relays: results,
-          poll: draft,
-          ...reveal_sk ? { reveal_sk, reveal_pk } : {},
-          url: `https://vote.ochk.io/p/${pid}`
-        },
-        null,
-        2
-      ) + "\n"
-    );
-    return;
-  }
-  const w = (s) => process.stdout.write(s);
-  w(`
-  poll_id:    ${pid}
-`);
-  w(`  published:  ${okCount}/${results.length} relays
-`);
-  for (const r of results) {
-    w(`    ${r.ok ? "\u2713" : "\u2717"} ${r.relay}${r.reason ? ` (${r.reason})` : ""}
-`);
-  }
-  w(`  url:        https://vote.ochk.io/p/${pid}
-`);
+  const relays = opts.relays ?? DEFAULT_RELAYS;
+  const serving = await castEvent(event, [], () => relaysServingPoll(draft, { relays }), { relays });
+  const url = `https://vote.ochk.io/p/${pid}`;
+  const tail = [`  url:        ${url}`];
   if (reveal_sk) {
-    w(`
-  SECRET MODE \u2014 save these or the poll is abandoned at deadline:
-`);
-    w(`    reveal_pk:  ${reveal_pk}
-`);
-    w(`    reveal_sk:  ${reveal_sk}
-`);
-    w(`  to publish the reveal:
-`);
-    w(`    oc-vote reveal --poll ${pid} --reveal-sk ${reveal_sk} --creator ${opts.creator}
-`);
+    tail.push(
+      "",
+      "  SECRET MODE \u2014 save these or the poll is abandoned at deadline:",
+      `    reveal_pk:  ${reveal_pk}`,
+      `    reveal_sk:  ${reveal_sk}`,
+      "  to publish the reveal:",
+      `    oc-vote reveal --poll ${pid} --reveal-sk ${reveal_sk} --creator ${opts.creator}`
+    );
   }
-  w(`
-  canonical bytes:
-`);
-  w(canonicalBytes({ ...draft, sig: { ...draft.sig, value: "" } }));
-  w(`
-`);
-}
-async function bip322Verify(args) {
-  return verifySignature(args.address, args.message, args.signature);
+  tail.push("", "  canonical bytes:", canonicalBytes({ ...draft, sig: { ...draft.sig, value: "" } }).trimEnd());
+  report({
+    id: ["poll_id", pid],
+    main: { kind: "poll", event, relays, serving },
+    json: Boolean(opts.json),
+    jsonExtra: { poll: draft, ...reveal_sk ? { reveal_sk, reveal_pk } : {}, url },
+    tail
+  });
 }
 function parse(ev) {
   try {
@@ -388,13 +587,24 @@ async function findPoll(fetched, pid, verify) {
   );
 }
 function requireComplete(fetched, what) {
-  if (!fetched.complete) throw new Error(`no relay finished answering the ${what} query; try again`);
-  return fetched.events;
+  if (fetched.complete) return fetched.events;
+  const short = "relays" in fetched ? readShortfall(fetched.relays) : null;
+  throw new Error(
+    short ? `can't count: the ${what} lookup ${short}, so ${what}s may be missing; try again` : `no relay finished answering the ${what} query; try again`
+  );
+}
+function ballotsToCount(fetched, anchored) {
+  if (!anchored) return requireComplete(fetched, "ballot");
+  if (fetched.relays.some((r) => r.answered || r.truncated)) return fetched.events;
+  throw new Error("no relay finished answering the ballot query; try again");
 }
 async function selectReveal(events, poll, verify, chain) {
-  for (const ev of events) {
-    const r = parse(ev);
-    if (r && (await verifyReveal(r, poll, verify, Date.now(), chain)).ok) return r;
+  return (await findReveal(events, poll, verify, chain))?.reveal ?? null;
+}
+async function findReveal(events, poll, verify, chain) {
+  for (const event of events) {
+    const reveal = parse(event);
+    if (reveal && (await verifyReveal(reveal, poll, verify, Date.now(), chain)).ok) return { event, reveal };
   }
   return null;
 }
@@ -467,6 +677,12 @@ function runGenRevealKey(opts) {
 
 `);
 }
+async function revealChainFor(poll) {
+  if (!isAnchoredPoll(poll)) return void 0;
+  const close = await resolveCloseBlock(poll.deadline, mempoolBlockTimeSource());
+  if (!close.ok) throw new Error(`the block at the deadline could not be read: ${close.reason}`);
+  return { tipHeight: close.tip, closeHeight: close.height };
+}
 async function runReveal(opts) {
   if (!/^[0-9a-f]{64}$/.test(opts.pollId)) {
     throw new Error("poll id must be 64 hex chars");
@@ -483,14 +699,11 @@ async function runReveal(opts) {
       `poll creator is ${poll.creator} but you provided ${opts.creator}`
     );
   }
-  let chain;
-  if (isAnchoredPoll(poll)) {
-    const close = await resolveCloseBlock(poll.deadline, mempoolBlockTimeSource());
-    if (!close.ok) throw new Error(`the block at the deadline could not be read: ${close.reason}`);
-    chain = { tipHeight: close.tip, closeHeight: close.height };
-    if (!anchoredTallyIsFinal(close.height, close.tip) && !opts.force) {
+  const chain = await revealChainFor(poll);
+  if (chain) {
+    if (!anchoredTallyIsFinal(chain.closeHeight, chain.tipHeight) && !opts.force) {
       throw new Error(
-        close.height === null ? "no block at the deadline yet: talliers would not accept a reveal now (pass --force to publish anyway)" : `talliers accept the reveal from block ${lastAnchorHeight(close.height) + ANCHOR_FINAL_CONFIRMATIONS}; the tip is ${close.tip} (pass --force to publish anyway)`
+        chain.closeHeight === null ? "no block at the deadline yet: talliers would not accept a reveal now (pass --force to publish anyway)" : `talliers accept the reveal from block ${lastAnchorHeight(chain.closeHeight) + ANCHOR_FINAL_CONFIRMATIONS}; the tip is ${chain.tipHeight} (pass --force to publish anyway)`
       );
     }
   } else if (Date.parse(poll.deadline) > Date.now() && !opts.force) {
@@ -498,14 +711,26 @@ async function runReveal(opts) {
       `poll deadline is ${poll.deadline} \u2014 pass --force to publish before deadline`
     );
   }
-  const existing = await selectReveal(
-    (await fetchRevealEvents(opts.pollId, relays)).events,
-    poll,
-    bip322Verify,
-    chain
-  );
+  const existing = await findReveal((await fetchRevealEvents(opts.pollId, relays)).events, poll, bip322Verify, chain);
   if (existing && !opts.force) {
-    throw new Error("a reveal event already exists for this poll (pass --force to replace)");
+    const readBack = () => relaysServingReveal(existing.reveal, poll, { relays, chain });
+    const serving2 = await castEvent(existing.event, await readBack(), readBack, { relays });
+    report({
+      id: ["reveal_id", revealId(existing.reveal)],
+      heading: [
+        ["poll", poll.question],
+        ["revealed", existing.reveal.revealed_at]
+      ],
+      main: { kind: "reveal", event: existing.event, relays, serving: serving2 },
+      json: Boolean(opts.json),
+      jsonExtra: { reveal: existing.reveal, signed_earlier: true },
+      tail: [
+        "  note:       this reveal was signed earlier and found on the relays; it was sent as it is",
+        "",
+        `  tally with: oc-vote tally ${opts.pollId}`
+      ]
+    });
+    return;
   }
   const draft = {
     v: 0,
@@ -523,42 +748,114 @@ async function runReveal(opts) {
   const sigValue = await promptForSignature(opts.creator, rid, opts.sig);
   draft.sig.value = sigValue;
   const event = buildRevealEvent(draft);
-  const results = await publishEvent(event, relays);
-  const okCount = results.filter((r) => r.ok).length;
-  if (opts.json) {
-    process.stdout.write(
-      JSON.stringify(
-        {
-          reveal_id: rid,
-          published: okCount,
-          total: results.length,
-          relays: results,
-          reveal: draft
-        },
-        null,
-        2
-      ) + "\n"
-    );
-    return;
+  const serving = await castEvent(event, [], () => relaysServingReveal(draft, poll, { relays, chain }), { relays });
+  report({
+    id: ["reveal_id", rid],
+    heading: [
+      ["poll", poll.question],
+      ["revealed", draft.revealed_at]
+    ],
+    main: { kind: "reveal", event, relays, serving },
+    json: Boolean(opts.json),
+    jsonExtra: { reveal: draft },
+    tail: ["", `  tally with: oc-vote tally ${opts.pollId}`]
+  });
+}
+
+// src/commands/republish.ts
+async function failure(p) {
+  const v = await p.catch((e) => ({ ok: false, reason: e.message }));
+  return v.ok ? null : "reason" in v && v.reason || "it does not verify";
+}
+async function readSigned(text, relays = DEFAULT_RELAYS) {
+  let obj;
+  try {
+    obj = JSON.parse(text);
+  } catch {
+    throw new Error("the file is not JSON");
   }
-  const w = (s) => process.stdout.write(s);
-  w(`
-  reveal_id:  ${rid}
-`);
-  w(`  poll:       ${poll.question}
-`);
-  w(`  revealed:   ${draft.revealed_at}
-`);
-  w(`  published:  ${okCount}/${results.length} relays
-`);
-  for (const r of results) {
-    w(`    ${r.ok ? "\u2713" : "\u2717"} ${r.relay}${r.reason ? ` (${r.reason})` : ""}
-`);
+  const event = obj && typeof obj === "object" && "event" in obj ? obj.event : obj;
+  if (!verifyEvent(event)) throw new Error("no signed Nostr event in the file: its id or signature doesn't hold");
+  if (event.kind === 30080) {
+    const poll = pollOf(event);
+    if (!poll) throw new Error("the event doesn't carry a poll");
+    const why = await failure(verifyPoll(poll, bip322Verify));
+    if (why) throw new Error(`the poll's signature doesn't verify: ${why}`);
+    return {
+      kind: "poll",
+      event,
+      id: ["poll_id", pollId(poll)],
+      heading: [["poll", poll.question]],
+      jsonExtra: { poll },
+      readBack: (r) => relaysServingPoll(poll, { relays: r })
+    };
   }
-  w(`
-  tally with: oc-vote tally ${opts.pollId}
-
-`);
+  if (event.kind === 30081) {
+    const ballot = ballotOf(event);
+    if (!ballot) throw new Error("the event doesn't carry a ballot");
+    const why = await failure(verifyBallot(ballot, bip322Verify));
+    if (why) throw new Error(`the ballot's signature doesn't verify: ${why}`);
+    return {
+      kind: "ballot",
+      event,
+      id: ["ballot_id", ballotId(ballot)],
+      heading: [
+        ["poll", ballot.poll_id],
+        ["voter", ballot.voter]
+      ],
+      jsonExtra: { ballot },
+      readBack: (r) => relaysServingBallot(ballot, { relays: r })
+    };
+  }
+  if (event.kind === 30082) {
+    const reveal = revealOf(event);
+    if (!reveal) throw new Error("the event doesn't carry a reveal");
+    const poll = (await findPoll(await fetchPollEvents(reveal.poll_id, relays), reveal.poll_id, bip322Verify)).poll;
+    const chain = await revealChainFor(poll);
+    const why = await failure(verifyReveal(reveal, poll, bip322Verify, Date.now(), chain));
+    if (why) throw new Error(`the reveal doesn't verify against its poll: ${why}`);
+    return {
+      kind: "reveal",
+      event,
+      id: ["reveal_id", revealId(reveal)],
+      heading: [["poll", poll.question]],
+      jsonExtra: { reveal },
+      readBack: (r) => relaysServingReveal(reveal, poll, { relays: r, chain })
+    };
+  }
+  if (event.kind === 30083) {
+    const env = stampOf(event);
+    if (!env) throw new Error("the event doesn't carry an OC Stamp");
+    const why = await failure(
+      verify({
+        envelope: env,
+        verifyBip322: async (message, signature, address) => bip322Verify({ address, message, signature })
+      }).then((v) => v.ok ? { ok: true } : { ok: false, reason: v.message ?? v.code })
+    );
+    if (why) throw new Error(`the stamp's signature doesn't verify: ${why}`);
+    return {
+      kind: "stamp",
+      event,
+      id: ["stamp_id", env.id],
+      heading: [["over", env.content.hash]],
+      jsonExtra: { stamp: env },
+      readBack: (r) => relaysServingStamp(env, { relays: r })
+    };
+  }
+  throw new Error(`the event is kind ${event.kind}: not a poll, ballot, reveal or stamp (30080 to 30083)`);
+}
+async function runRepublish(opts) {
+  const relays = opts.relays ?? DEFAULT_RELAYS;
+  const signed = await readSigned(readFileSync(opts.file, "utf8"), relays);
+  const serving = await castEvent(signed.event, [], () => signed.readBack(relays), { relays });
+  report({
+    id: signed.id,
+    heading: signed.heading,
+    main: { kind: signed.kind, event: signed.event, relays, serving },
+    json: Boolean(opts.json),
+    jsonExtra: signed.jsonExtra,
+    file: opts.file
+  });
 }
 
 // src/commands/show.ts
@@ -613,15 +910,15 @@ async function runShow(opts) {
 `);
 }
 function ballotCopiesFromEvents(events, pid) {
-  const parsed = [];
+  const parsed2 = [];
   for (const ev of events) {
     try {
       const b = JSON.parse(ev.content);
-      if (b && b.poll_id === pid) parsed.push(b);
+      if (b && b.poll_id === pid) parsed2.push(b);
     } catch {
     }
   }
-  return distinctBallotCopies(parsed);
+  return distinctBallotCopies(parsed2);
 }
 function ballotVerdicts(copies, verify = verifySignature) {
   const byId = /* @__PURE__ */ new Map();
@@ -718,24 +1015,25 @@ async function runTally(opts) {
   }
   const relays = opts.relays ?? DEFAULT_RELAYS;
   const verify = opts.verify !== false ? bip322Verify : null;
-  const [pollFetch, ballotFetch, revealFetch] = await Promise.all([
-    fetchPollEvents(pid, relays),
-    fetchBallotEvents(pid, relays),
-    fetchRevealEvents(pid, relays)
-  ]);
-  const selected = await findPoll(pollFetch, pid, verify ?? bip322Verify);
+  const ballotRead = fetchBallotEvents(pid, relays);
+  ballotRead.catch(() => void 0);
+  const selected = await findPoll(await fetchPollEvents(pid, relays), pid, verify ?? bip322Verify);
   if (verify && !selected.signatureValid) {
     throw new Error("poll signature does not verify against its creator (SPEC \xA710.1)");
   }
   const poll = selected.poll;
-  const ballots = ballotCopiesFromEvents(requireComplete(ballotFetch, "ballot"), pid);
+  const [ballotFetch, revealFetch] = await Promise.all([
+    ballotRead,
+    poll.mode === "secret" ? fetchRevealEvents(pid, relays) : null
+  ]);
+  const ballots = ballotCopiesFromEvents(ballotsToCount(ballotFetch, isAnchoredPoll(poll)), pid);
   const chain = await anchoredChain(poll, ballots.map(ballotId), {
     ballotRelays: ballotFetch.relays,
     relays,
     ...opts.mempoolBase ? { mempoolBase: opts.mempoolBase } : {}
   });
-  const reveal = poll.mode === "secret" ? await selectReveal(revealFetch.events, poll, bip322Verify, chain ?? void 0) : null;
-  if (poll.mode === "secret" && !reveal) requireComplete(revealFetch, "reveal");
+  const reveal = revealFetch ? await selectReveal(revealFetch.events, poll, bip322Verify, chain ?? void 0) : null;
+  if (revealFetch && !reveal) requireComplete(revealFetch, "reveal");
   const source = mempoolSource(opts.mempoolBase);
   const utxosAt = buildLookup(source);
   const snapshot = chain ? void 0 : await resolveSnapshot(poll, opts);
@@ -949,66 +1247,38 @@ async function runVote(opts) {
   const sigValue = await promptForSignature(opts.voter, bid, opts.sig);
   draft.sig.value = sigValue;
   const pub = buildBallotEvent(draft);
-  const results = await publishEvent(pub, opts.relays ?? DEFAULT_RELAYS);
-  const okCount = results.filter((r) => r.ok).length;
-  let stamped = null;
-  if (okCount > 0 && isAnchoredPoll(poll)) {
+  const relays = opts.relays ?? DEFAULT_RELAYS;
+  const serving = await castBallot(pub, draft, [], { relays });
+  let stamp2 = null;
+  if (serving.length > 0 && isAnchoredPoll(poll)) {
     try {
       const env = await stampBallot(draft);
-      const sent = await publishEvent(buildStampEvent(env), opts.relays ?? DEFAULT_RELAYS);
-      stamped = { relays: sent.filter((r) => r.ok).length, total: sent.length };
+      const event = buildStampEvent(env);
+      const on = await castEvent(event, [], () => relaysServingStamp(env, { relays }), { relays });
+      stamp2 = { kind: "stamp", event, relays, serving: on };
     } catch (e) {
-      stamped = { error: e.message };
+      stamp2 = { error: e.message };
     }
   }
-  if (opts.json) {
-    process.stdout.write(
-      JSON.stringify(
-        {
-          ballot_id: bid,
-          published: okCount,
-          total: results.length,
-          relays: results,
-          ...stamped ? { stamp: stamped } : {},
-          ballot: draft
-        },
-        null,
-        2
-      ) + "\n"
-    );
-    return;
-  }
-  const w = (s) => process.stdout.write(s);
-  w(`
-  ballot_id:  ${bid}
-`);
-  w(`  poll:       ${poll.question}
-`);
-  w(`  voter:      ${opts.voter}
-`);
-  w(`  option:     ${opts.option}${poll.mode === "secret" ? " (sealed)" : ""}
-`);
-  w(`  published:  ${okCount}/${results.length} relays
-`);
-  for (const r of results) {
-    w(`    ${r.ok ? "\u2713" : "\u2717"} ${r.relay}${r.reason ? ` (${r.reason})` : ""}
-`);
-  }
-  if (stamped && "error" in stamped) {
-    w(`  stamp:      not made here (${stamped.error}); vote.ochk.io's anchorer stamps every ballot it sees
-`);
-  } else if (stamped) {
-    w(`  stamp:      published to ${stamped.relays}/${stamped.total} relays; a Bitcoin block usually anchors it within an hour or two
-`);
-  }
-  w(`
-`);
+  report({
+    id: ["ballot_id", bid],
+    heading: [
+      ["poll", poll.question],
+      ["voter", opts.voter],
+      ["option", `${opts.option}${poll.mode === "secret" ? " (sealed)" : ""}`]
+    ],
+    main: { kind: "ballot", event: pub, relays, serving },
+    stamp: stamp2,
+    json: Boolean(opts.json),
+    jsonExtra: { ballot: draft }
+  });
 }
 
 // src/cli.ts
 if (typeof globalThis.WebSocket === "undefined") {
   globalThis.WebSocket = WebSocket;
 }
+var { version } = createRequire(import.meta.url)("../package.json");
 var program = new Command();
 function collectRelay(v, prev = []) {
   return [...prev, v];
@@ -1028,9 +1298,9 @@ function parseDeadline(raw) {
     const d = new Date(Date.now() + ms);
     return d.toISOString().replace(/\.\d+Z$/, "Z");
   }
-  const parsed = new Date(raw);
-  if (Number.isNaN(parsed.getTime())) throw new Error(`invalid deadline: ${raw}`);
-  return parsed.toISOString().replace(/\.\d+Z$/, "Z");
+  const parsed2 = new Date(raw);
+  if (Number.isNaN(parsed2.getTime())) throw new Error(`invalid deadline: ${raw}`);
+  return parsed2.toISOString().replace(/\.\d+Z$/, "Z");
 }
 function parseSnapshot(raw) {
   if (raw === "deadline") return "deadline";
@@ -1038,10 +1308,10 @@ function parseSnapshot(raw) {
   if (!Number.isFinite(n) || n <= 0) throw new Error(`invalid snapshot block: ${raw}`);
   return n;
 }
-program.name("oc-vote").description("OC Vote \u2014 sovereign signaling for the open web").version("0.2.0");
-program.command("tally <poll_id>").description("Fetch the poll + ballots and run the pure tally function").option("--relay <url>", "Nostr relay (repeatable)", collectRelay, []).option("--mempool-base <url>", "mempool.space-compatible base URL", "https://mempool.space/api").option("--snapshot <height>", "Override snapshot block (integer)").option("--no-verify", "Skip BIP-322 signature verification").option("--json", "Emit JSON instead of human-readable output").action(async (pollId3, opts) => {
+program.name("oc-vote").description("OC Vote \u2014 sovereign signaling for the open web").version(version);
+program.command("tally <poll_id>").description("Fetch the poll + ballots and run the pure tally function").option("--relay <url>", "Nostr relay (repeatable)", collectRelay, []).option("--mempool-base <url>", "mempool.space-compatible base URL", "https://mempool.space/api").option("--snapshot <height>", "Override snapshot block (integer)").option("--no-verify", "Skip BIP-322 signature verification").option("--json", "Emit JSON instead of human-readable output").action(async (pollId5, opts) => {
   await runTally({
-    pollId: pollId3,
+    pollId: pollId5,
     relays: opts.relay?.length ? opts.relay : void 0,
     mempoolBase: opts.mempoolBase,
     json: Boolean(opts.json),
@@ -1049,16 +1319,16 @@ program.command("tally <poll_id>").description("Fetch the poll + ballots and run
     snapshotBlock: opts.snapshot ? Number.parseInt(String(opts.snapshot), 10) : void 0
   });
 });
-program.command("verify <poll_id>").description("Verify every BIP-322 signature on the poll + its ballots").option("--relay <url>", "Nostr relay (repeatable)", collectRelay, []).option("--json", "Emit JSON").action(async (pollId3, opts) => {
+program.command("verify <poll_id>").description("Verify every BIP-322 signature on the poll + its ballots").option("--relay <url>", "Nostr relay (repeatable)", collectRelay, []).option("--json", "Emit JSON").action(async (pollId5, opts) => {
   await runVerify({
-    pollId: pollId3,
+    pollId: pollId5,
     relays: opts.relay?.length ? opts.relay : void 0,
     json: Boolean(opts.json)
   });
 });
-program.command("show <poll_id>").description("Print the poll metadata + ballot count without running the tally").option("--relay <url>", "Nostr relay (repeatable)", collectRelay, []).option("--json", "Emit JSON").action(async (pollId3, opts) => {
+program.command("show <poll_id>").description("Print the poll metadata + ballot count without running the tally").option("--relay <url>", "Nostr relay (repeatable)", collectRelay, []).option("--json", "Emit JSON").action(async (pollId5, opts) => {
   await runShow({
-    pollId: pollId3,
+    pollId: pollId5,
     relays: opts.relay?.length ? opts.relay : void 0,
     json: Boolean(opts.json)
   });
@@ -1071,7 +1341,9 @@ program.command("discover").description("List recent polls across the default re
     openOnly: Boolean(opts.openOnly)
   });
 });
-program.command("create").description("Build + sign + publish a poll").requiredOption("--creator <btc-addr>", "Bitcoin address of the poll creator").requiredOption("--question <text>", "poll question").requiredOption(
+program.command("create").description(
+  "Build + sign + publish a poll. It is published once 2 relays, each asked alone, serve it back; below that it exits 2 (see republish)"
+).requiredOption("--creator <btc-addr>", "Bitcoin address of the poll creator").requiredOption("--question <text>", "poll question").requiredOption(
   "--option <id:label>",
   'poll option; repeatable; "id" or "id:label"',
   collectOption,
@@ -1104,7 +1376,9 @@ program.command("create").description("Build + sign + publish a poll").requiredO
     json: Boolean(opts.json)
   });
 });
-program.command("vote").description("Cast a ballot on a poll").requiredOption("--poll <poll_id>", "64-hex poll id").requiredOption("--voter <btc-addr>", "voter Bitcoin address").requiredOption("--option <id>", "chosen option id").option("--sig <base64>", "BIP-322 signature of ballot_id; prompts if omitted").option("--relay <url>", "Nostr relay (repeatable)", collectRelay, []).option("--dry-run", "print canonical + id; do not sign or publish").option("--json", "Emit JSON").action(async (opts) => {
+program.command("vote").description(
+  "Cast a ballot on a poll. It is in once 2 relays, each asked alone, serve it back; below that it exits 2 (see republish)"
+).requiredOption("--poll <poll_id>", "64-hex poll id").requiredOption("--voter <btc-addr>", "voter Bitcoin address").requiredOption("--option <id>", "chosen option id").option("--sig <base64>", "BIP-322 signature of ballot_id; prompts if omitted").option("--relay <url>", "Nostr relay (repeatable)", collectRelay, []).option("--dry-run", "print canonical + id; do not sign or publish").option("--json", "Emit JSON").action(async (opts) => {
   await runVote({
     pollId: String(opts.poll),
     voter: String(opts.voter),
@@ -1115,7 +1389,18 @@ program.command("vote").description("Cast a ballot on a poll").requiredOption("-
     json: Boolean(opts.json)
   });
 });
-program.command("reveal").description("Publish the reveal event for a secret-mode poll").requiredOption("--poll <poll_id>", "64-hex poll id").requiredOption("--reveal-sk <hex>", "64-hex X25519 secret key").requiredOption("--creator <btc-addr>", "poll creator address (must match the poll)").option("--sig <base64>", "BIP-322 signature of reveal_id; prompts if omitted").option("--relay <url>", "Nostr relay (repeatable)", collectRelay, []).option("--force", "publish even before deadline / even if a reveal exists").option("--dry-run", "print reveal + id; do not sign or publish").option("--json", "Emit JSON").action(async (opts) => {
+program.command("republish <file>").description(
+  "Send a signed poll, ballot, reveal or ballot stamp again, as it is (from --json output, or an event: line), and ask each relay for it back"
+).option("--relay <url>", "Nostr relay (repeatable)", collectRelay, []).option("--json", "Emit JSON").action(async (file, opts) => {
+  await runRepublish({
+    file,
+    relays: opts.relay?.length ? opts.relay : void 0,
+    json: Boolean(opts.json)
+  });
+});
+program.command("reveal").description(
+  "Publish the reveal for a secret-mode poll, or send the one already signed again. It is published once 2 relays serve it back; below that it exits 2"
+).requiredOption("--poll <poll_id>", "64-hex poll id").requiredOption("--reveal-sk <hex>", "64-hex X25519 secret key").requiredOption("--creator <btc-addr>", "poll creator address (must match the poll)").option("--sig <base64>", "BIP-322 signature of reveal_id; prompts if omitted").option("--relay <url>", "Nostr relay (repeatable)", collectRelay, []).option("--force", "publish before the deadline, or sign a new reveal when one is already on the relays").option("--dry-run", "print reveal + id; do not sign or publish").option("--json", "Emit JSON").action(async (opts) => {
   await runReveal({
     pollId: String(opts.poll),
     revealSk: String(opts.revealSk),