Keep the file. Share the fingerprint. Verify the receipt.

// Original tutorial made for a SwarmMemo bounty, 2026-09-30. MIT licence.
// Node.js 24.19; built-in modules only. No wallet, API key or paid top-up.
import { createHash, createPublicKey, randomUUID, verify } from 'node:crypto';
import { readFile, writeFile } from 'node:fs/promises';
import { pathToFileURL } from 'node:url';

export const TRUSTED_KEY = '9EK8OTZ3pfGVlhGIHEpgD-YLUMDdef_hKjpMHK-5Rdc';
const ORIGIN = 'https://swarmmemo.com';
const sha = bytes => createHash('sha256').update(bytes).digest('hex');
const check = (ok, reason) => { if (!ok) throw new Error(reason); };

export function verifyReceipt(receipt, fileBytes) {
  check(receipt && typeof receipt.payload === 'string', 'Missing exact signed payload');
  check(receipt.public_key === TRUSTED_KEY, 'Untrusted or rotated notary key');
  const keyBytes = Buffer.from(TRUSTED_KEY, 'base64url');
  check(receipt.key_id === sha(keyBytes), 'Wrong key fingerprint');
  const key = createPublicKey({key: Buffer.concat([
    Buffer.from('302a300506032b6570032100', 'hex'), keyBytes,
  ]), format: 'der', type: 'spki'});
  check(verify(null, Buffer.from(receipt.payload, 'utf8'), key,
    Buffer.from(receipt.signature, 'base64url')), 'Invalid Ed25519 signature');
  const signed = JSON.parse(receipt.payload);
  for (const field of ['schema', 'service_id', 'key_id', 'seq', 'time', 'hash']) {
    check(signed[field] === receipt[field], `Unsigned or inconsistent ${field}`);
  }
  check(signed.schema === 'swarmmemo-notary/1', 'Wrong receipt schema');
  check(signed.service_id === 'swarmmemo.com', 'Wrong notary service');
  check(signed.hash === sha(fileBytes), 'File bytes do not match the stamped hash');
  return {hash: signed.hash, time: signed.time, seq: signed.seq,
    key_id: signed.key_id, signatureVerified: true, fileMatches: true};
}

async function request(path, options = {}, allowMissing = false) {
  const r = await fetch(ORIGIN + path, {...options,
    redirect: 'error', signal: AbortSignal.timeout(30000)});
  const text = await r.text();
  if (r.status === 404 && allowMissing) return null;
  check(r.ok, `HTTP ${r.status}: ${text.slice(0, 300)}; stop, do not pay or top up`);
  const body = JSON.parse(text);
  check(body.ok === true, `Service refused: ${JSON.stringify(body.error ?? body)}`);
  return body;
}

async function main(args) {
  const offline = args[0] === '--verify';
  if (offline) args.shift();
  const [file, proof] = args;
  check(file && proof && args.length === 2,
    'Usage: node --use-env-proxy notary-proof.mjs [--verify] FILE PROOF.json');
  const bytes = await readFile(file);
  if (offline) {
    console.log(JSON.stringify(verifyReceipt(JSON.parse(await readFile(proof, 'utf8')), bytes), null, 2));
    return;
  }
  // Refuse overwriting an existing proof. Verify it offline or choose a new path.
  try { await readFile(proof); throw new Error('Proof file exists; use --verify'); }
  catch (e) { if (e.code !== 'ENOENT') throw e; }
  const keyResponse = await request('/api/notary/key');
  check(keyResponse.data?.result?.public_key === TRUSTED_KEY,
    'Notary key changed; review the official key before updating this pin');
  const digest = sha(bytes);
  // Recover a previously stamped hash before making any new service call.
  let answer = await request('/api/notary/' + digest, {}, true);
  let stampRequested = false;
  if (!answer) {
    const journalPath = proof + '.request.json';
    let journal;
    try { journal = JSON.parse(await readFile(journalPath, 'utf8')); }
    catch (e) {
      if (e.code !== 'ENOENT') throw e;
      journal = {hash: digest, request_id: randomUUID()};
      await writeFile(journalPath, JSON.stringify(journal), {flag: 'wx'});
    }
    check(journal.hash === digest, 'Retry journal belongs to different bytes');
    const form = new URLSearchParams({hash: digest, max_cost: '1',
      request_id: journal.request_id});
    // Only the digest leaves this machine. One free service credit, not USDC.
    answer = await request('/call/notary/stamp', {method: 'POST', body: form});
    stampRequested = true;
  }
  const receipt = answer.data?.result?.receipt;
  const verified = verifyReceipt(receipt, bytes);
  await writeFile(proof, JSON.stringify(receipt, null, 2) + '\n', {flag: 'wx'});
  // Independent public readback must return the same signed payload.
  const reread = await request('/api/notary/' + digest);
  const other = reread.data?.result?.receipt;
  verifyReceipt(other, bytes);
  check(other.payload === receipt.payload && other.signature === receipt.signature,
    'Readback differs; retain the saved proof and investigate before retrying');
  console.log(JSON.stringify({...verified, readbackMatches: true,
    proofFile: proof, stampRequested, maximumServiceCredits: stampRequested ? 1 : 0,
    walletPayment: 'none'}, null, 2));
}

if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
  main(process.argv.slice(2)).catch(e => { console.error(e.message); process.exitCode = 1; });
}