agent-receipt-verify 0.0.0-stage → 0.2.1

package/src/x402-poortwachters.mjs

@@ -0,0 +1,241 @@
+// Meet de POORTWACHTERS, niet de kraampjes.
+//
+// WAAROM DIT APART STAAT VAN DE ANDERE METINGEN. x402-conformance-check meet een
+// verkoper, en x402-discovery-census telt wat verkopers in EEN index hebben
+// aangemeld. Beide meten de kraampjes. Maar een verkoper kan niets afrekenen zonder
+// een facilitator, en niemand vindt hem zonder een index. Dat zijn er maar een paar,
+// en daar zit de macht in deze laag. Een scorebord over een handvol poortwachters is
+// daarom iets anders dan een scorebord over duizend winkeltjes: de poortwachters
+// kunnen niet doen alsof ze het niet lezen.
+//
+// WAT HIER MET OPZET NIET GEBEURT. Geen afrekening, geen betaling, geen poging om
+// iets af te dwingen, en nooit meer dan een paar gewone GET-verzoeken per host, met
+// een eerlijke user-agent en rust ertussen. Dit meet wat een poortwachter ZELF
+// publiek over zichzelf zegt via zijn eigen endpoints. Niets meer.
+//
+// DE TREDEN, en net als bij de verkopersladder is "niet gemeten" geen afkeuring:
+//   G0  antwoordt /supported met bruikbare JSON (minstens een netwerk en een scheme)
+//   G1  noemt in dat antwoord welke extensies hij ondersteunt
+//   G2  biedt een discovery-index aan die JSON teruggeeft
+//   G3  die index meldt een totaal, zodat zijn omvang narekenbaar is
+//   G4  de index is niet door een enkele partij gedomineerd (grootste host onder de
+//       helft van de EERSTE PAGINA)
+//
+// EN DAAR ZIT EEN VALKUIL IN DIE BIJ DE EERSTE RUN METEEN BLEEK. De eerste pagina is
+// NIET representatief. Op payai gaf de eerste pagina 21,0 procent voor de grootste
+// host, terwijl onze volledige census over alle 20.597 registraties 51,8 procent
+// vond voor het grootste domein. Een index wordt niet in willekeurige volgorde
+// geleverd, dus wie alleen de eerste pagina weegt onderschat de concentratie, en in
+// dit geval met meer dan een factor twee. G4 is daarom een ONDERGRENS en nooit een
+// vrijbrief: hij haalt alleen de gevallen boven water die al op de eerste pagina
+// zichtbaar zijn. De echte concentratie meet je met x402-discovery-census.mjs, dat
+// de hele index leest.
+//
+// G4 bestaat omdat onze eigen census op 2026-10-17 vond dat in de grootste index
+// EEN domein meer dan de helft van alle registraties houdt, over elf subdomeinen.
+// Dat is geen verwijt aan die partij (gemeten: het zijn echte, losse eindpunten),
+// maar het betekent dat de omvang van een index niets zegt over het aantal partijen
+// in de markt. Een index die dat niet zichtbaar maakt, laat iedereen die hem citeert
+// een verkeerd getal noemen.
+
+const UA = 'x402-conformance-check/1 (read-only, github.com/holistis/agent-receipt-verify)'
+const slaap = (ms) => new Promise((r) => setTimeout(r, ms))
+
+/** De lijst die x402 zelf publiceert, plus de twee die wij al gemeten hebben. */
+export const POORTWACHTERS = [
+  { naam: 'payai', basis: 'https://facilitator.payai.network' },
+  { naam: 'x402.org', basis: 'https://x402.org/facilitator' },
+  { naam: 'celo', basis: 'https://api.x402.celo.org' },
+  { naam: 'celo-sepolia', basis: 'https://api.x402.sepolia.celo.org' },
+  { naam: 'corbits', basis: 'https://corbits.dev' },
+  { naam: 'dexter', basis: 'https://dexter.cash/facilitator' },
+  { naam: 'mogami', basis: 'https://facilitator.mogami.tech' },
+  { naam: 'mrdn', basis: 'https://mrdn.finance' },
+  { naam: 'solvador', basis: 'https://solvador.com' },
+  { naam: 'mikedotexe', basis: 'https://x402.mikedotexe.com' },
+  { naam: 't54-xrpl', basis: 'https://xrpl-x402.t54.ai' },
+  { naam: 'ftptech', basis: 'https://www.ftptech.xyz/x402' },
+]
+
+async function haalJson(url, { fetchImpl = fetch } = {}) {
+  try {
+    const r = await fetchImpl(url, {
+      headers: { 'User-Agent': UA, Accept: 'application/json' },
+      signal: AbortSignal.timeout(20000),
+    })
+    const tekst = await r.text().catch(() => '')
+    if (!r.ok) return { status: r.status, json: null, reden: 'status ' + r.status }
+    try {
+      return { status: r.status, json: JSON.parse(tekst) }
+    } catch {
+      // Een HTML-pagina op een API-pad is GEEN kapotte facilitator, het betekent
+      // dat dit endpoint hier niet bestaat. Dat onderscheid hoort in de uitslag.
+      return { status: r.status, json: null, reden: tekst.trim().startsWith('<') ? 'html, geen json' : 'geen json' }
+    }
+  } catch (e) {
+    return { status: null, json: null, reden: 'onbereikbaar: ' + String(e.message).slice(0, 50) }
+  }
+}
+
+/** Leest een /supported-antwoord zonder aan te nemen hoe het precies heet. */
+export function leesSupported(j) {
+  if (!j || typeof j !== 'object') return { netwerken: [], schemes: [], extensies: [] }
+  const rijen = Array.isArray(j) ? j : (j.kinds ?? j.supported ?? j.data ?? j.items ?? [])
+  const netwerken = new Set()
+  const schemes = new Set()
+  const extensies = new Set()
+  for (const r of Array.isArray(rijen) ? rijen : []) {
+    if (r?.network) netwerken.add(String(r.network))
+    if (r?.scheme) schemes.add(String(r.scheme))
+    // Een lijst en een object moeten apart: Object.keys op een lijst geeft de
+    // INDEXEN, dus ["bazaar"] zou "0" als extensienaam opleveren. Gevonden door de
+    // test, en precies het soort stille fout dat een scorebord onzin maakt.
+    if (Array.isArray(r?.extensions)) for (const e of r.extensions) extensies.add(String(e))
+    else for (const k of Object.keys(r?.extensions ?? {})) extensies.add(k)
+  }
+  if (Array.isArray(j.extensions)) for (const e of j.extensions) extensies.add(String(e))
+  else for (const k of Object.keys(j.extensions ?? {})) extensies.add(k)
+  return { netwerken: [...netwerken], schemes: [...schemes], extensies: [...extensies] }
+}
+
+/** Concentratie op de EERSTE pagina: het aandeel van de grootste host. */
+export function concentratie(items) {
+  const perHost = new Map()
+  let bruikbaar = 0
+  for (const it of Array.isArray(items) ? items : []) {
+    let h = null
+    try { h = new URL(it?.resource ?? it?.url ?? '').host.toLowerCase() } catch { h = null }
+    if (!h) continue
+    bruikbaar++
+    perHost.set(h, (perHost.get(h) ?? 0) + 1)
+  }
+  if (bruikbaar === 0) return { hosts: 0, grootste: null, aandeel: null, gemeten: 0 }
+  const top = [...perHost.entries()].sort((a, b) => b[1] - a[1])[0]
+  return { hosts: perHost.size, grootste: top[0], aandeel: top[1] / bruikbaar, gemeten: bruikbaar }
+}
+
+/** De hoogste trede die deze poortwachter aantoonbaar haalt. */
+export function hoogsteTrede(m) {
+  if (!m.g0) return -1
+  if (!m.g1) return 0
+  if (!m.g2) return 1
+  if (!m.g3) return 2
+  if (!m.g4) return 3
+  return 4
+}
+
+export async function meetPoortwachter(p, { fetchImpl = fetch, pauzeMs = 900 } = {}) {
+  const m = { naam: p.naam, basis: p.basis, bewijs: {} }
+
+  const sup = await haalJson(p.basis.replace(/\/$/, '') + '/supported', { fetchImpl })
+  const gelezen = leesSupported(sup.json)
+  m.g0 = gelezen.netwerken.length > 0 && gelezen.schemes.length > 0
+  m.bewijs.g0 = m.g0
+    ? gelezen.netwerken.length + ' netwerk(en), scheme(s): ' + gelezen.schemes.join(', ')
+    : 'geen bruikbaar /supported (' + (sup.reden ?? 'leeg antwoord') + ')'
+  m.netwerken = gelezen.netwerken
+  m.schemes = gelezen.schemes
+
+  m.g1 = gelezen.extensies.length > 0
+  m.bewijs.g1 = m.g1 ? 'noemt: ' + gelezen.extensies.join(', ') : 'noemt geen enkele extensie'
+  m.extensies = gelezen.extensies
+
+  await slaap(pauzeMs)
+  const disc = await haalJson(p.basis.replace(/\/$/, '') + '/discovery/resources?limit=100&offset=0', { fetchImpl })
+  const items = disc.json?.items ?? disc.json?.resources ?? disc.json?.data ?? null
+  m.g2 = Array.isArray(items)
+  m.bewijs.g2 = m.g2 ? items.length + ' op de eerste pagina' : 'geen index (' + (disc.reden ?? 'geen items-lijst') + ')'
+
+  const totaal = disc.json?.pagination?.total ?? disc.json?.total ?? null
+  m.g3 = m.g2 && Number.isFinite(Number(totaal))
+  m.bewijs.g3 = m.g3 ? 'meldt totaal ' + totaal : 'meldt geen totaal, dus zijn omvang is niet na te rekenen'
+  m.gemeldTotaal = m.g3 ? Number(totaal) : null
+
+  const c = m.g2 ? concentratie(items) : null
+  m.concentratie = c
+  if (!m.g2) {
+    m.g4 = false
+    m.bewijs.g4 = 'geen index om te wegen'
+  } else if (!c || c.gemeten === 0) {
+    m.g4 = false
+    m.bewijs.g4 = 'index zonder bruikbare adressen'
+  } else {
+    m.g4 = c.aandeel < 0.5
+    m.bewijs.g4 = 'grootste host ' + c.grootste + ' is ' + (c.aandeel * 100).toFixed(1) +
+      '% van ' + c.gemeten + ' op de EERSTE PAGINA, over ' + c.hosts + ' hosts. Dit is een' +
+      ' ondergrens: een volledige census van dezelfde index gaf een duidelijk hoger aandeel.'
+  }
+
+  m.trede = hoogsteTrede(m)
+  return m
+}
+
+if (process.argv[1]?.endsWith('x402-poortwachters.mjs')) {
+  const uitPad = process.argv[2]
+
+  // Controles eerst, net als bij de verkopersmeting: een ronde waarin alles faalt
+  // bewijst niet dat de wereld faalt, hij kan ook bewijzen dat het gereedschap kapot
+  // is. payai is bekend als index-aanbieder, en een documentatiepagina hoort niets
+  // te halen.
+  console.log('--- controls first ---')
+  const pos = await meetPoortwachter({ naam: 'control-payai', basis: 'https://facilitator.payai.network' })
+  const neg = await meetPoortwachter({ naam: 'control-docs', basis: 'https://docs.github.com' })
+  const posOk = pos.g2 === true
+  const negOk = neg.trede === -1
+  console.log((posOk ? '  ok   ' : '  FAIL ') + 'a known index offers one: g2=' + pos.g2)
+  console.log((negOk ? '  ok   ' : '  FAIL ') + 'a documentation site reaches nothing: level ' + neg.trede)
+  if (!posOk || !negOk) {
+    console.log('')
+    console.log('The harness did not behave on the controls. Treat everything below as invalid.')
+  }
+  console.log('')
+
+  const uit = []
+  for (const p of POORTWACHTERS) {
+    const m = await meetPoortwachter(p)
+    uit.push(m)
+    console.log(
+      (m.trede >= 0 ? 'G' + m.trede : 'G-') + '  ' + m.naam.padEnd(14) +
+      (m.netwerken.length ? m.netwerken.length + ' net' : '      ') +
+      '  ' + (m.g2 ? 'index ja' : 'index nee') +
+      (m.gemeldTotaal != null ? ', totaal ' + m.gemeldTotaal : '')
+    )
+    await slaap(900)
+  }
+
+  console.log('')
+  const metIndex = uit.filter((m) => m.g2)
+  const metExt = uit.filter((m) => m.g1)
+  console.log('  ' + uit.filter((m) => m.g0).length + ' of ' + uit.length + ' answer /supported with a usable network and scheme')
+  console.log('  ' + metExt.length + ' of ' + uit.length + ' name any extension at all')
+  console.log('  ' + metIndex.length + ' of ' + uit.length + ' offer a discovery index that returns json')
+  for (const m of metIndex) {
+    if (m.concentratie?.aandeel != null) {
+      console.log('     ' + m.naam + ': largest host ' + (m.concentratie.aandeel * 100).toFixed(1) + '% of the FIRST PAGE')
+    }
+  }
+  if (metIndex.some((m) => m.concentratie?.aandeel != null)) {
+    console.log('')
+    console.log('  Read that last number as a floor, not as the concentration. An index is not')
+    console.log('  served in random order, so the first page understates it: on payai the first')
+    console.log('  page gives 21.0% while a full census of the same index gave 51.8% for the')
+    console.log('  largest domain. Use x402-discovery-census.mjs when the number matters.')
+  }
+  console.log('')
+  console.log('  levels 1 to 4 are about what a gatekeeper publishes about itself. A facilitator')
+  console.log('  that settles fine but documents nothing scores low here, and that is the point:')
+  console.log('  a seller cannot choose what he cannot inspect.')
+
+  if (uitPad) {
+    const { writeFileSync, mkdirSync } = await import('node:fs')
+    const { dirname } = await import('node:path')
+    mkdirSync(dirname(uitPad), { recursive: true })
+    writeFileSync(uitPad, JSON.stringify({
+      bron: 'docs/dev-tools/facilitators.md in x402-foundation/x402, plus x402.org/facilitator',
+      controles: { positief: { g2: pos.g2 }, negatief: { trede: neg.trede }, geldig: posOk && negOk },
+      poortwachters: uit,
+    }, null, 2))
+    console.log('')
+    console.log('written: ' + uitPad)
+  }
+}

package/tools/bundel-bouw.mjs

@@ -0,0 +1,126 @@
+// Stageert de MCPB-bundel en BEWIJST dat hij werkt, voor er iets gepubliceerd wordt.
+//
+// WAAROM DIT EEN SCRIPT IS EN GEEN STUK YAML. Een controle die alleen in een
+// workflow staat, is alleen op een server te draaien en dus niet na te kijken door
+// wie hem moet vertrouwen. Dit bestand draait ook lokaal:
+//
+//   node tools/bundel-bouw.mjs <doelmap>
+//
+// WAT HET BEWIJST, en dit is het hele punt. Een bundel is een losse kopie van de
+// server. Wie hem samenstelt uit een lijst mappen, kan een bestand vergeten dat de
+// repo wel heeft: dan werkt alles bij ons en gaat het pas stuk bij een vreemde die
+// de bundel installeert. Daarom start dit script de server UIT de gestageerde map en
+// voert een echte initialize plus tools/list uit over stdio. Faalt dat, dan is er
+// niets om te publiceren.
+//
+// ethers zit er BEWUST niet in. Het is een optionele afhankelijkheid voor één
+// controle binnen trede 2, en zonder dat pakket meldt die controle ONGEMETEN in
+// plaats van te slagen. Een bundel van 184 kB die eerlijk zegt wat hij niet kon
+// meten, is beter dan een bundel met een hele node_modules erin.
+
+import fs from 'node:fs'
+import path from 'node:path'
+import { spawn } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+
+const wortel = fileURLToPath(new URL('..', import.meta.url))
+
+// Alleen wat de server bij het draaien ECHT nodig heeft, plus de stukken die een
+// mens moet kunnen lezen als hij de bundel binnenhaalt. vectors/ en test/ horen hier
+// niet: die zijn er voor onze eigen bewijslast, niet voor het draaien.
+export const INHOUD = {
+  bestanden: ['manifest.json', 'LICENSE', 'NOTICE', 'README.md', 'CONFORMANCE.md'],
+  mappen: ['src', 'profiles'],
+}
+
+function kopieerMap(van, naar) {
+  fs.mkdirSync(naar, { recursive: true })
+  for (const item of fs.readdirSync(van, { withFileTypes: true })) {
+    const a = path.join(van, item.name), b = path.join(naar, item.name)
+    if (item.isDirectory()) kopieerMap(a, b)
+    else fs.copyFileSync(a, b)
+  }
+}
+
+export function stageer(doel) {
+  fs.rmSync(doel, { recursive: true, force: true })
+  fs.mkdirSync(doel, { recursive: true })
+  for (const f of INHOUD.bestanden) {
+    const bron = path.join(wortel, f)
+    if (!fs.existsSync(bron)) throw new Error(`bundel mist een bestand dat de repo hoort te hebben: ${f}`)
+    fs.copyFileSync(bron, path.join(doel, f))
+  }
+  for (const m of INHOUD.mappen) {
+    const bron = path.join(wortel, m)
+    if (!fs.existsSync(bron)) throw new Error(`bundel mist een map die de repo hoort te hebben: ${m}`)
+    kopieerMap(bron, path.join(doel, m))
+  }
+  return doel
+}
+
+/** De drie versienummers moeten gelijk zijn, anders publiceren wij een versie die niet bestaat. */
+export function versiesKloppen(leesJson) {
+  // De lezer is een parameter zodat een test de rode kant kan aantonen zonder
+  // bestanden in de repo te verminken. Een controle die alleen groen kan worden,
+  // bewijst niets.
+  const lees = leesJson || ((f) => JSON.parse(fs.readFileSync(path.join(wortel, f), 'utf8')))
+  const pkg = lees('package.json').version
+  const man = lees('manifest.json').version
+  const srv = lees('server.json').version
+  const klachten = []
+  if (man !== pkg) klachten.push(`manifest.json zegt ${man}, package.json zegt ${pkg}`)
+  if (srv !== pkg) klachten.push(`server.json zegt ${srv}, package.json zegt ${pkg}`)
+  return { versie: pkg, klachten }
+}
+
+/** Start de server uit de bundel en eis een echte handdruk plus een echte toollijst. */
+export async function bewijsDatDeBundelWerkt(doel, { wachtMs = 2500 } = {}) {
+  const entry = path.join(doel, JSON.parse(fs.readFileSync(path.join(doel, 'manifest.json'), 'utf8')).server.entry_point)
+  if (!fs.existsSync(entry)) throw new Error(`het manifest wijst naar een entry_point die niet in de bundel zit: ${entry}`)
+
+  const kind = spawn(process.execPath, [entry], { stdio: ['pipe', 'pipe', 'pipe'] })
+  let uit = '', err = ''
+  kind.stdout.on('data', (d) => { uit += d })
+  kind.stderr.on('data', (d) => { err += d })
+  const stuur = (o) => kind.stdin.write(JSON.stringify(o) + '\n')
+
+  stuur({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: '2025-11-25', capabilities: {}, clientInfo: { name: 'bundel-bouw', version: '1' } } })
+  await new Promise((r) => setTimeout(r, 700))
+  stuur({ jsonrpc: '2.0', id: 2, method: 'tools/list' })
+  await new Promise((r) => setTimeout(r, wachtMs))
+  kind.kill()
+
+  const frames = uit.trim().split('\n').filter(Boolean).map((r) => { try { return JSON.parse(r) } catch { return null } }).filter(Boolean)
+  const init = frames.find((f) => f.id === 1)
+  const lijst = frames.find((f) => f.id === 2)
+  if (!init?.result?.serverInfo?.name) throw new Error('de bundel gaf geen bruikbaar initialize-antwoord. stderr: ' + err.slice(0, 400))
+  if (!Array.isArray(lijst?.result?.tools) || lijst.result.tools.length === 0) throw new Error('de bundel gaf geen tools terug')
+  // Alles wat geen protocolframe is hoort naar stderr. Een regel op stdout die geen
+  // JSON-RPC is, breekt elke client, en dat moet hier opvallen en niet bij een vreemde.
+  const nietFrames = uit.trim().split('\n').filter((r) => r.trim()).filter((r) => { try { JSON.parse(r); return false } catch { return true } })
+  if (nietFrames.length) throw new Error('er staat iets op stdout dat geen frame is: ' + nietFrames[0].slice(0, 120))
+
+  return { naam: init.result.serverInfo.name, versie: init.result.serverInfo.version, protocol: init.result.protocolVersion, tools: lijst.result.tools.map((t) => t.name) }
+}
+
+if (process.argv[1]?.endsWith('bundel-bouw.mjs')) {
+  const doel = process.argv[2]
+  if (!doel) {
+    console.log('gebruik: node tools/bundel-bouw.mjs <doelmap>')
+    process.exitCode = 2
+  } else {
+    const v = versiesKloppen()
+    if (v.klachten.length) {
+      console.log('versies lopen uiteen, dit stopt hier:')
+      for (const k of v.klachten) console.log('  ' + k)
+      process.exitCode = 1
+    } else {
+      stageer(doel)
+      const n = fs.readdirSync(doel, { recursive: true }).length
+      const uitslag = await bewijsDatDeBundelWerkt(doel)
+      console.log(`versie ${v.versie}, ${n} items gestageerd in ${doel}`)
+      console.log(`de bundel spreekt MCP: ${uitslag.naam} v${uitslag.versie}, protocol ${uitslag.protocol}`)
+      console.log(`tools: ${uitslag.tools.join(', ')}`)
+    }
+  }
+}

package/vectors/inam/BRON-README.md

@@ -0,0 +1,38 @@
+# Counterparty-countersigned feedback: signed vectors
+
+INAM grounds a rating in a **counterparty countersignature over the work**: the provider signs a receipt naming `task.specHash` and `result.outputHash` (both `sha256:` of the actual bytes), then the requester signs the same canonical content ([SPEC §4](../../SPEC.md#4-execution-receipt)). Over an HTTP call, both hashes are derived from the request and response bytes ([§15](../../SPEC.md#15-receipts-over-http-v041)). The finalized receipt goes into ERC-8004 `giveFeedback` as in [§11.1](../../SPEC.md#111-inam-and-erc-8004). It needs no payment to be visible on-chain, so it composes with `x402-settlement` instead of replacing it.
+
+These vectors are offered for the grounding conformance set discussed in [erc-8004-contracts#99](https://github.com/erc-8004/erc-8004-contracts/issues/99) and [x402#3772](https://github.com/x402-foundation/x402/issues/3772).
+
+```sh
+node interop/countersigned/verify.mjs     # Node built-ins only, no INAM server, no npm install
+```
+
+## Cases (`vectors.json`)
+
+| Case | What changes | Must be rejected by |
+|---|---|---|
+| `POSITIVE` | nothing: genuine feedback, right wallet, hashes match the observed bytes | accepted |
+| `WRONG-WALLET-COPY` | the genuine file, byte for byte, sent from another wallet | `fileClientAddressMatchesSender`, `senderIsRequesterWallet` |
+| `TAMPERED-OUTPUT-HASH` | `result.outputHash` edited in the carried receipt; `feedbackHash` recomputed over the edited file | `receiptIdRecomputes`, both signatures, `outputHashMatchesObservedBytes` |
+| `OUTPUT-NOT-WHAT-WAS-SERVED` | both signatures valid, but the provider's `outputHash` commits to bytes the requester never received | `outputHashMatchesObservedBytes` |
+
+The last case is the one the countersignature rule exists for. A requester that recomputes both hashes from the bytes it observed (SPEC §15 step 3) refuses to sign; a requester that signed anyway produces a record every signature check accepts and only the binding check catches. That recomputation is a verification step, not a second derivation of the interaction's identity: nothing is re-derived, the requester compares its own bytes against the value the provider derived.
+
+## What each check does
+
+`feedbackHashMatchesFile` keccak256 of the file bytes equals the event's `feedbackHash`. `receiptIdRecomputes` content-addressing (§4.2). `workerSignature` / `requesterSignature` Ed25519 over the same canonical content (§4.3). `valueMatchesOutcome` 100 / 50 / 0 for success / partial / failed. `fileClientAddressMatchesSender` the file names the address that sent the event. `senderIsRequesterWallet` that address is the `linked.erc8004_id` the requester's INAM ID proved control of (here the fixture's stand-in for the registry lookup). `specHashMatchesObservedBytes` / `outputHashMatchesObservedBytes` the hashes equal `sha256` of the request (`METHOD path?query\n` + body) and response bytes in `observed`.
+
+`verify.mjs` includes a small Keccak-256 because Node ships none; `tests/countersignedInterop.test.ts` checks it against the SDK's.
+
+## Files
+
+| File | What it is |
+|---|---|
+| `vectors.json` | The four cases, the observed request/response bytes and the parties. |
+| `verify.mjs` | The independent check. Prints PASS/FAIL per case. |
+| `generate.ts` | Rebuilds `vectors.json` byte for byte with the INAM SDK (`npx tsx interop/countersigned/generate.ts`). |
+
+**Test keys.** Both DIDs come from private keys derived from public strings in `generate.ts`; anyone can sign as them. The EVM addresses are made up and are not derived from any key. They exist only for these fixtures.
+
+**Not covered.** The registry's view of the receipt (status `finalized`, not disputed) is outside these files, and so is checking that the ERC-8004 `agentId` belongs to the provider; both need live state ([§11.1](../../SPEC.md#111-inam-and-erc-8004) step 4). INAM's registry is run by its maintainers, so these vectors test the format and the checks, not that anyone should trust the operator.

package/vectors/inam/canonical-vectors.json

@@ -0,0 +1,122 @@
+{
+  "description": "Canonical JSON vectors with non-ASCII and non-BMP content; reference: sdk-js/src/crypto/canonical.ts",
+  "vectors": [
+    {
+      "name": "astral-key-sorts-before-U+FFFF",
+      "input": {
+        "￿": 1,
+        "😀": 2
+      },
+      "canonical": "{\"😀\":2,\"￿\":1}",
+      "utf8Sha256": "48c5d098713870a7b88be7fc0ffc0a79e912d20f80ea8a4a5604426f49add103"
+    },
+    {
+      "name": "astral-key-sorts-before-U+E000",
+      "input": {
+        "": "private-use",
+        "𐀀": "linear-b",
+        "a": 0
+      },
+      "canonical": "{\"a\":0,\"𐀀\":\"linear-b\",\"\":\"private-use\"}",
+      "utf8Sha256": "5b26b7dcd5b746fc5f2d1f8e58c70b7bb9abfabff1fbde2a55936ce5965b79be"
+    },
+    {
+      "name": "astral-keys-among-bmp-keys",
+      "input": {
+        "z": 1,
+        "𝄞": 2,
+        "é": 3,
+        "日本": 4,
+        "A": 5,
+        "Ａ": 6
+      },
+      "canonical": "{\"A\":5,\"z\":1,\"é\":3,\"日本\":4,\"𝄞\":2,\"Ａ\":6}",
+      "utf8Sha256": "b6b7a2a1095bb9a8470e26cc35264d2669255d6abde0d490d4fd2bf691f347dd"
+    },
+    {
+      "name": "astral-key-nested-in-array",
+      "input": {
+        "list": [
+          {
+            "�": 1,
+            "🚀": 2
+          },
+          [
+            {
+              "𠀀": "cjk-ext-b",
+              "￯": "x"
+            }
+          ]
+        ]
+      },
+      "canonical": "{\"list\":[{\"🚀\":2,\"�\":1},[{\"𠀀\":\"cjk-ext-b\",\"￯\":\"x\"}]]}",
+      "utf8Sha256": "db5689390c763ec36522bbb1798d569f22b03ca010eb2be9408ec3f6375bdda1"
+    },
+    {
+      "name": "emoji-values",
+      "input": {
+        "a": "😀",
+        "b": "👨‍👩‍👧",
+        "c": "🇹🇷",
+        "d": "𝄞 clef"
+      },
+      "canonical": "{\"a\":\"😀\",\"b\":\"👨‍👩‍👧\",\"c\":\"🇹🇷\",\"d\":\"𝄞 clef\"}",
+      "utf8Sha256": "8907f06176aa2941e64fec7710d8505188d48d63f2d4e7c32126e8c601c3dc03"
+    },
+    {
+      "name": "bmp-non-ascii",
+      "input": {
+        "name": "Café",
+        "jp": "日本語",
+        "tr": "ğüşıöç İ"
+      },
+      "canonical": "{\"jp\":\"日本語\",\"name\":\"Café\",\"tr\":\"ğüşıöç İ\"}",
+      "utf8Sha256": "7482b59d09447b1fde215ad8a7bf2e41678a4bf35b9a80a41003e3e4d2e8cca9"
+    },
+    {
+      "name": "no-unicode-normalization",
+      "input": {
+        "nfc": "é",
+        "nfd": "é"
+      },
+      "canonical": "{\"nfc\":\"é\",\"nfd\":\"é\"}",
+      "utf8Sha256": "79eae438d105e852f86ea598ffdda91643386fad0b4f336b941528d30fbf1558"
+    },
+    {
+      "name": "lone-surrogates-escaped",
+      "input": {
+        "hi": "\ud800",
+        "lo": "\udc00",
+        "rev": "\udc00\ud800",
+        "\ud83d": "key"
+      },
+      "canonical": "{\"hi\":\"\\ud800\",\"lo\":\"\\udc00\",\"rev\":\"\\udc00\\ud800\",\"\\ud83d\":\"key\"}",
+      "utf8Sha256": "450ec9ac72567a72d99cddf0e97bad0c9952a1bed75ce16b802f435276c0a087"
+    },
+    {
+      "name": "control-and-special-chars",
+      "input": {
+        "c": "\u0000\b\t\n\f\r\u001f",
+        "q": "\"/",
+        "del": "",
+        "ls": "

"
+      },
+      "canonical": "{\"c\":\"\\u0000\\b\\t\\n\\f\\r\\u001f\",\"del\":\"\",\"ls\":\"

\",\"q\":\"\\\"/\"}",
+      "utf8Sha256": "b230efe90e496aac442bf66f13ba37036df1b102b9a8a723e794722eb95d1600"
+    },
+    {
+      "name": "key-order-digits-case-accents",
+      "input": {
+        "9": 4,
+        "10": 3,
+        "b": 1,
+        "B": 2,
+        "é": 5,
+        "e": 6,
+        "": 7
+      },
+      "canonical": "{\"\":7,\"10\":3,\"9\":4,\"B\":2,\"b\":1,\"e\":6,\"é\":5}",
+      "utf8Sha256": "ca65da7e132c4e02d1b747eee06e008c2f6442b731afe16d04d993109188ad22"
+    }
+  ]
+}

package/vectors/inam/vectors.json

@@ -0,0 +1,96 @@
+{
+  "suite": "inam-countersigned-grounding-v0.1",
+  "method": "counterparty-countersigned",
+  "note": "Test keys and made-up addresses only. Checks: feedbackHash, receiptId, both signatures, value, sender, specHash/outputHash against the bytes the requester observed.",
+  "parties": {
+    "requester": {
+      "did": "did:key:z6Mkkrq4oHrSaU8E2ZctUreJkiXyrVbPRM4FZgPxYx3X8XCS",
+      "erc8004Address": "0x1111111111111111111111111111111111111111"
+    },
+    "provider": {
+      "did": "did:key:z6MkenP9pSJt69Re5GYC3HeA6JC4BbFSATBbVkjx3TVbE4LL",
+      "erc8004Address": "0x2222222222222222222222222222222222222222"
+    }
+  },
+  "observed": {
+    "request": {
+      "method": "POST",
+      "url": "https://worker.example/translate",
+      "body": "{\"text\":\"merhaba dünya\",\"to\":\"en\"}"
+    },
+    "response": {
+      "status": 200,
+      "body": "{\"text\":\"hello world\"}"
+    },
+    "expectedSpecHash": "sha256:423007c3904c15d5f43b0485ff3e442b0003925cb283ac7b58c16634429bce20",
+    "expectedOutputHash": "sha256:e344fa3b83cf2b142293de2a4e56c6b211d4a157f8adb3c954c51ab67f41a46a"
+  },
+  "cases": [
+    {
+      "id": "POSITIVE",
+      "description": "Genuine feedback: sent from the requester's proven wallet, both signatures valid, hashes match the observed bytes.",
+      "feedbackFile": "{\"agentId\":7,\"agentRegistry\":\"eip155:8453:0x8004000000000000000000000000000000000000\",\"clientAddress\":\"eip155:8453:0x1111111111111111111111111111111111111111\",\"createdAt\":\"2026-10-03T00:00:00.000Z\",\"inam\":{\"receipt\":{\"agentA\":{\"id\":\"did:key:z6Mkkrq4oHrSaU8E2ZctUreJkiXyrVbPRM4FZgPxYx3X8XCS\",\"role\":\"requester\"},\"agentB\":{\"id\":\"did:key:z6MkenP9pSJt69Re5GYC3HeA6JC4BbFSATBbVkjx3TVbE4LL\",\"role\":\"worker\"},\"jobId\":\"http:countersigned-vectors-v0.1\",\"receiptId\":\"sha256:c4b80bbc9472979127dca9491a729396514bc9b6c36391b79ba9419fbb2828c3\",\"receiptVersion\":\"1.0\",\"result\":{\"completedAt\":\"2026-10-01T10:00:01.000Z\",\"outputHash\":\"sha256:e344fa3b83cf2b142293de2a4e56c6b211d4a157f8adb3c954c51ab67f41a46a\"},\"signatures\":{\"agentA\":\"mjXSDW6FMCAL5wBv0ASZ4BR7Dst7KXNMtQF1mrPaApJw0QCzuwWHPsuQqEkVjb4LOTvGfmJzaa6QtK/QLbKTCQ==\",\"agentB\":\"wDDUXpemxNcVEVQfH7kaTZr2rJk/zzLNNpAkx3a70UjyrGK9OPMAX/dhgxsVneGCse/jXV2s6F+n5WLFDqYwBQ==\"},\"task\":{\"capability\":\"translation.tr-en\",\"createdAt\":\"2026-10-01T10:00:00.000Z\",\"specHash\":\"sha256:423007c3904c15d5f43b0485ff3e442b0003925cb283ac7b58c16634429bce20\"},\"verification\":{\"method\":\"payer_confirmation\",\"outcome\":\"success\"}}},\"tag1\":\"inam-receipt\",\"tag2\":\"translation.tr-en\",\"value\":100,\"valueDecimals\":0}",
+      "onchainEvent": {
+        "clientAddress": "0x1111111111111111111111111111111111111111",
+        "feedbackHash": "0x9d7bb681bc76d26fe927d690d0042a1c3176dbf3b4831d498c99f1e3a39ecfe6",
+        "value": 100
+      },
+      "expected": {
+        "accepted": true,
+        "failedChecks": []
+      }
+    },
+    {
+      "id": "WRONG-WALLET-COPY",
+      "description": "The genuine file, byte for byte, sent from a wallet that is not the requester's proven erc8004_id (the Sybil copy).",
+      "feedbackFile": "{\"agentId\":7,\"agentRegistry\":\"eip155:8453:0x8004000000000000000000000000000000000000\",\"clientAddress\":\"eip155:8453:0x1111111111111111111111111111111111111111\",\"createdAt\":\"2026-10-03T00:00:00.000Z\",\"inam\":{\"receipt\":{\"agentA\":{\"id\":\"did:key:z6Mkkrq4oHrSaU8E2ZctUreJkiXyrVbPRM4FZgPxYx3X8XCS\",\"role\":\"requester\"},\"agentB\":{\"id\":\"did:key:z6MkenP9pSJt69Re5GYC3HeA6JC4BbFSATBbVkjx3TVbE4LL\",\"role\":\"worker\"},\"jobId\":\"http:countersigned-vectors-v0.1\",\"receiptId\":\"sha256:c4b80bbc9472979127dca9491a729396514bc9b6c36391b79ba9419fbb2828c3\",\"receiptVersion\":\"1.0\",\"result\":{\"completedAt\":\"2026-10-01T10:00:01.000Z\",\"outputHash\":\"sha256:e344fa3b83cf2b142293de2a4e56c6b211d4a157f8adb3c954c51ab67f41a46a\"},\"signatures\":{\"agentA\":\"mjXSDW6FMCAL5wBv0ASZ4BR7Dst7KXNMtQF1mrPaApJw0QCzuwWHPsuQqEkVjb4LOTvGfmJzaa6QtK/QLbKTCQ==\",\"agentB\":\"wDDUXpemxNcVEVQfH7kaTZr2rJk/zzLNNpAkx3a70UjyrGK9OPMAX/dhgxsVneGCse/jXV2s6F+n5WLFDqYwBQ==\"},\"task\":{\"capability\":\"translation.tr-en\",\"createdAt\":\"2026-10-01T10:00:00.000Z\",\"specHash\":\"sha256:423007c3904c15d5f43b0485ff3e442b0003925cb283ac7b58c16634429bce20\"},\"verification\":{\"method\":\"payer_confirmation\",\"outcome\":\"success\"}}},\"tag1\":\"inam-receipt\",\"tag2\":\"translation.tr-en\",\"value\":100,\"valueDecimals\":0}",
+      "onchainEvent": {
+        "clientAddress": "0x3333333333333333333333333333333333333333",
+        "feedbackHash": "0x9d7bb681bc76d26fe927d690d0042a1c3176dbf3b4831d498c99f1e3a39ecfe6",
+        "value": 100
+      },
+      "expected": {
+        "accepted": false,
+        "failedChecks": [
+          "fileClientAddressMatchesSender",
+          "senderIsRequesterWallet"
+        ]
+      }
+    },
+    {
+      "id": "TAMPERED-OUTPUT-HASH",
+      "description": "result.outputHash edited inside the carried receipt; feedbackHash recomputed over the edited file, sent from the right wallet.",
+      "feedbackFile": "{\"agentId\":7,\"agentRegistry\":\"eip155:8453:0x8004000000000000000000000000000000000000\",\"clientAddress\":\"eip155:8453:0x1111111111111111111111111111111111111111\",\"createdAt\":\"2026-10-03T00:00:00.000Z\",\"inam\":{\"receipt\":{\"agentA\":{\"id\":\"did:key:z6Mkkrq4oHrSaU8E2ZctUreJkiXyrVbPRM4FZgPxYx3X8XCS\",\"role\":\"requester\"},\"agentB\":{\"id\":\"did:key:z6MkenP9pSJt69Re5GYC3HeA6JC4BbFSATBbVkjx3TVbE4LL\",\"role\":\"worker\"},\"jobId\":\"http:countersigned-vectors-v0.1\",\"receiptId\":\"sha256:c4b80bbc9472979127dca9491a729396514bc9b6c36391b79ba9419fbb2828c3\",\"receiptVersion\":\"1.0\",\"result\":{\"completedAt\":\"2026-10-01T10:00:01.000Z\",\"outputHash\":\"sha256:2910e9a528b169d433bad2f53171e547726ca717868e29362ec178cfb58b97cb\"},\"signatures\":{\"agentA\":\"mjXSDW6FMCAL5wBv0ASZ4BR7Dst7KXNMtQF1mrPaApJw0QCzuwWHPsuQqEkVjb4LOTvGfmJzaa6QtK/QLbKTCQ==\",\"agentB\":\"wDDUXpemxNcVEVQfH7kaTZr2rJk/zzLNNpAkx3a70UjyrGK9OPMAX/dhgxsVneGCse/jXV2s6F+n5WLFDqYwBQ==\"},\"task\":{\"capability\":\"translation.tr-en\",\"createdAt\":\"2026-10-01T10:00:00.000Z\",\"specHash\":\"sha256:423007c3904c15d5f43b0485ff3e442b0003925cb283ac7b58c16634429bce20\"},\"verification\":{\"method\":\"payer_confirmation\",\"outcome\":\"success\"}}},\"tag1\":\"inam-receipt\",\"tag2\":\"translation.tr-en\",\"value\":100,\"valueDecimals\":0}",
+      "onchainEvent": {
+        "clientAddress": "0x1111111111111111111111111111111111111111",
+        "feedbackHash": "0x7feec35c27e69bccc6da108795931a25b2acbd49bd46dae7787fede41f3eadf0",
+        "value": 100
+      },
+      "expected": {
+        "accepted": false,
+        "failedChecks": [
+          "receiptIdRecomputes",
+          "workerSignature",
+          "requesterSignature",
+          "outputHashMatchesObservedBytes"
+        ]
+      }
+    },
+    {
+      "id": "OUTPUT-NOT-WHAT-WAS-SERVED",
+      "description": "Both signatures are valid, but the provider's outputHash commits to different bytes than the requester received. A requester that recomputes (SPEC §15 step 3) refuses to countersign this.",
+      "feedbackFile": "{\"agentId\":7,\"agentRegistry\":\"eip155:8453:0x8004000000000000000000000000000000000000\",\"clientAddress\":\"eip155:8453:0x1111111111111111111111111111111111111111\",\"createdAt\":\"2026-10-03T00:00:00.000Z\",\"inam\":{\"receipt\":{\"agentA\":{\"id\":\"did:key:z6Mkkrq4oHrSaU8E2ZctUreJkiXyrVbPRM4FZgPxYx3X8XCS\",\"role\":\"requester\"},\"agentB\":{\"id\":\"did:key:z6MkenP9pSJt69Re5GYC3HeA6JC4BbFSATBbVkjx3TVbE4LL\",\"role\":\"worker\"},\"jobId\":\"http:countersigned-vectors-v0.1\",\"receiptId\":\"sha256:51968202116a120715be7387e83f03d26ea3c1281d63110a148159e4d4c7cf90\",\"receiptVersion\":\"1.0\",\"result\":{\"completedAt\":\"2026-10-01T10:00:01.000Z\",\"outputHash\":\"sha256:2910e9a528b169d433bad2f53171e547726ca717868e29362ec178cfb58b97cb\"},\"signatures\":{\"agentA\":\"+fXRHCXTDOA+tUqARcBXm2cn8qkIeD+ByCQXPOTC7Nm2LOIc2mmmWQy0UKLcTpRUbvHaNv9mc3Lmz1IzsKUOBA==\",\"agentB\":\"P46kDb36mIo7D4HFeLR/DrVlKdwWfQdZHwnq2y4XmqjE4udQLFI7yNwkFMvgxCspXZL12pGX3ajp11bnreIMDQ==\"},\"task\":{\"capability\":\"translation.tr-en\",\"createdAt\":\"2026-10-01T10:00:00.000Z\",\"specHash\":\"sha256:423007c3904c15d5f43b0485ff3e442b0003925cb283ac7b58c16634429bce20\"},\"verification\":{\"method\":\"payer_confirmation\",\"outcome\":\"success\"}}},\"tag1\":\"inam-receipt\",\"tag2\":\"translation.tr-en\",\"value\":100,\"valueDecimals\":0}",
+      "onchainEvent": {
+        "clientAddress": "0x1111111111111111111111111111111111111111",
+        "feedbackHash": "0x81d5ed166f4c3fa4d7bb918240fae486c92299077fb00494ec65928a0b967770",
+        "value": 100
+      },
+      "expected": {
+        "accepted": false,
+        "failedChecks": [
+          "outputHashMatchesObservedBytes"
+        ]
+      }
+    }
+  ]
+}