agent-receipt-verify 0.2.6 → 0.2.8

package/bench/methodefout.mjs

@@ -0,0 +1,204 @@
+#!/usr/bin/env node
+/**
+ * METHODEFOUT-BENCHMARK -- meet de foutmarge van DEZE meter tegen de echte markt.
+ *
+ * WAAROM DIT BESTAAT, en het is een eigen fout die het nodig maakte. Deze verifieerder
+ * sondeert standaard met POST. Een betaalde route die alleen GET bedient antwoordt
+ * daarop 405, of 404 bij veel webraamwerken, en dat las de meter als "dit eindpunt vraagt
+ * niet om betaling zoals x402 voorschrijft". Gemeten op 18 oktober 2026, op zestig unieke
+ * hosts uit de CDP-index: van de 57 die ECHT om betaling vragen keurde de meter er 36 af.
+ * 63,2 procent. Dat bleef onopgemerkt omdat er alleen tegen eigen testvectoren getoetst
+ * werd, en testvectoren bevatten precies de vorm die de schrijver al in gedachten had.
+ *
+ * Een meter die zijn eigen foutmarge tegen de werkelijkheid niet meet, meet niets.
+ *
+ * DIT GEBRUIKT DE ECHTE METER, niet een nagebouwde sonde. Een eerste versie van dit
+ * bestand bouwde het verzoek zelf na, en dat is precies de fout die het wil opsporen: dan
+ * benchmark je een replica die met de echte code uit elkaar loopt. Daarom importeert dit
+ * `meetEindpunt` uit src.
+ *
+ * GEDRAGSREGELS, hard, want dit raakt eindpunten van anderen:
+ *  - de meter doet zelf een POST en hoogstens een herhaling; dit voegt er alleen bij een
+ *    AFKEURING nog een GET aan toe om te zien of de afkeuring terecht was
+ *  - een host maar een keer, anders weegt een operator met honderd paden honderd keer
+ *  - nooit betalen, nooit fuzzen, nooit herhalen om iets af te dwingen
+ *  - rust tussen de hosts
+ *
+ * GEBRUIK:
+ *   node bench/methodefout.mjs --urls <bestand.json>   een array van resource-urls
+ *   node bench/methodefout.mjs --urls - < bronnen.json  hetzelfde, van stdin
+ *   node bench/methodefout.mjs --urls x.json --uit uitslag.jsonl
+ *
+ * De lijst met bronnen komt van buiten dit bestand, want die vergt indextoegang en een
+ * sleutel, en een benchmark hoort geen geheimen te hoeven lezen.
+ *
+ * EXITCODES: 0 gemeten, 1 er is een RESTFOUT (de meter keurt nog hosts af die wel om
+ * betaling vragen), 2 de meting kon niet draaien.
+ */
+
+import fs from 'node:fs'
+import { meetEindpunt, hoogsteTrede } from '../src/x402-conformance-check.mjs'
+
+const UA = 'x402-conformance-check/1 (read-only, github.com/holistis/agent-receipt-verify)'
+const rust = (ms) => new Promise((r) => setTimeout(r, ms))
+
+function vlag(naam, standaard = null) {
+  const v = process.argv.find((a) => a === naam || a.startsWith(naam + '='))
+  if (!v) return standaard
+  if (v.includes('=')) return v.slice(naam.length + 1)
+  return process.argv[process.argv.indexOf(v) + 1] ?? standaard
+}
+
+/** Een host maar EEN keer, anders weegt een operator met honderd paden honderd keer. */
+export function eenPerHost(urls) {
+  const perHost = new Map()
+  for (const u of urls) {
+    try {
+      const h = new URL(u).host
+      if (!perHost.has(h)) perHost.set(h, u)
+    } catch {}
+  }
+  return [...perHost.values()]
+}
+
+/**
+ * Antwoordt dit eindpunt op GET WEL met 402? Dit wordt alleen gevraagd als de meter het
+ * eindpunt AFKEURDE, om te zien of die afkeuring terecht was. Een afkeuring die wij niet
+ * natrekken, telt stil als een eigenschap van de markt in plaats van als onze restfout.
+ */
+async function tweedeKansOpGet(url, fetchImpl) {
+  try {
+    const r = await fetchImpl(url, {
+      method: 'GET',
+      headers: { 'User-Agent': UA, Accept: 'application/json' },
+      signal: AbortSignal.timeout(12000),
+    })
+    return r.status === 402
+  } catch {
+    return false
+  }
+}
+
+export async function benchmark(urls, { fetchImpl = fetch, pauzeMs = 500 } = {}) {
+  const t = {
+    gemeten: 0,
+    haaltL0: 0,
+    // Hoeveel hosts de meter alleen haalt DOORDAT hij een herhaling doet. Dit is wat de
+    // reparatie oplevert, en het is tegelijk de omvang van de oude fout.
+    gereddenDoorHerhaling: 0,
+    // De restfout: de meter keurt af, maar het eindpunt antwoordt wel 402 op GET. Dit
+    // hoort nul te zijn. Staat hij boven nul, dan is er nog een vorm die wij missen.
+    restfout: 0,
+    terechtAfgekeurd: 0,
+    ongemeten: 0,
+  }
+  const gered = []
+  const rest = []
+  for (const u of urls) {
+    t.gemeten++
+    const m = await meetEindpunt(u, { fetchImpl })
+    const trede = hoogsteTrede(m)
+    if (m.treden.t0 === 'ONGEMETEN') {
+      t.ongemeten++
+    } else if (trede >= 0) {
+      t.haaltL0++
+      if (m.bewijs.methode_opnieuw) {
+        t.gereddenDoorHerhaling++
+        gered.push({ url: u, eerste_status: m.bewijs.methode_opnieuw.eerste_status, tweede: m.bewijs.methode_opnieuw.tweede })
+      }
+    } else {
+      await rust(Math.min(300, pauzeMs))
+      if (await tweedeKansOpGet(u, fetchImpl)) {
+        t.restfout++
+        rest.push({ url: u, bewijs: m.bewijs.t0 })
+      } else {
+        t.terechtAfgekeurd++
+      }
+    }
+    if (pauzeMs) await rust(pauzeMs)
+  }
+  const vraagtEchtOmBetaling = t.haaltL0 + t.restfout
+  return {
+    ...t,
+    vraagtEchtOmBetaling,
+    restfoutPct: vraagtEchtOmBetaling > 0 ? Number(((t.restfout / vraagtEchtOmBetaling) * 100).toFixed(1)) : null,
+    zonderHerhalingFoutPct:
+      vraagtEchtOmBetaling > 0
+        ? Number((((t.gereddenDoorHerhaling + t.restfout) / vraagtEchtOmBetaling) * 100).toFixed(1))
+        : null,
+    gered,
+    rest,
+  }
+}
+
+if (process.argv[1]?.endsWith('methodefout.mjs')) {
+  const bron = vlag('--urls')
+  if (!bron) {
+    console.error('geef een bestand met resource-urls: --urls bronnen.json (of - voor stdin)')
+    process.exit(2)
+  }
+  let ruw
+  try {
+    ruw = bron === '-' ? fs.readFileSync(0, 'utf8') : fs.readFileSync(bron, 'utf8')
+  } catch (e) {
+    console.error('kan de bronlijst niet lezen: ' + e.message)
+    process.exit(2)
+  }
+  let lijst
+  try {
+    const j = JSON.parse(ruw)
+    lijst = Array.isArray(j) ? j : (j.urls ?? j.resources ?? [])
+  } catch {
+    lijst = ruw.split(/\r?\n/).map((s) => s.trim()).filter((s) => /^https?:\/\//.test(s))
+  }
+  const hosts = eenPerHost(lijst.filter((u) => typeof u === 'string'))
+  const aantal = Number(vlag('--aantal', String(hosts.length)))
+  const teMeten = hosts.slice(0, aantal)
+  if (teMeten.length === 0) {
+    console.error('geen bruikbare urls, dus NIETS gemeten. Dit is geen uitslag van nul fouten.')
+    process.exit(2)
+  }
+
+  console.log('urls in de lijst ' + lijst.length + ', unieke hosts ' + hosts.length + ', gemeten ' + teMeten.length)
+  const u = await benchmark(teMeten)
+  console.log('')
+  console.log('  haalt trede 0                              : ' + u.haaltL0)
+  console.log('    waarvan alleen door de methode-herhaling : ' + u.gereddenDoorHerhaling)
+  console.log('  RESTFOUT, afgekeurd maar antwoordt 402     : ' + u.restfout)
+  console.log('  terecht afgekeurd                          : ' + u.terechtAfgekeurd)
+  console.log('  niet bereikbaar, dus ongemeten             : ' + u.ongemeten)
+  console.log('')
+  console.log('  van de ' + u.vraagtEchtOmBetaling + ' hosts die echt om betaling vragen:')
+  console.log('    foutmarge NU                 : ' + u.restfoutPct + ' procent')
+  console.log('    foutmarge ZONDER de herhaling: ' + u.zonderHerhalingFoutPct + ' procent')
+  if (u.rest.length) {
+    console.log('')
+    console.log('  nog steeds fout, en dit is het werk dat overblijft:')
+    for (const r of u.rest.slice(0, 12)) console.log('    ' + r.url + '  ' + r.bewijs)
+  }
+
+  const uit = vlag('--uit')
+  if (uit) {
+    const regel = {
+      gemeten_op: new Date().toISOString(),
+      gemeten: u.gemeten,
+      haalt_l0: u.haaltL0,
+      gered_door_herhaling: u.gereddenDoorHerhaling,
+      restfout: u.restfout,
+      terecht_afgekeurd: u.terechtAfgekeurd,
+      ongemeten: u.ongemeten,
+      vraagt_echt_om_betaling: u.vraagtEchtOmBetaling,
+      restfout_pct: u.restfoutPct,
+      zonder_herhaling_fout_pct: u.zonderHerhalingFoutPct,
+      rest: u.rest.slice(0, 10).map((r) => r.url),
+    }
+    fs.appendFileSync(uit, JSON.stringify(regel) + '\n')
+    console.log('')
+    console.log('regel bijgeschreven in ' + uit)
+  }
+
+  // Een restfout boven nul is een echte, open fout van deze meter. Die hoort een
+  // exitcode te geven, anders leest een groene run als "alles klopt" terwijl er hosts
+  // afgekeurd worden die wel om betaling vragen.
+  if (u.restfout > 0) process.exitCode = 1
+}

package/bin/cli.mjs

@@ -75,6 +75,11 @@ function gebruik() {
   console.log('        that one settlement? Eleven run offline, the chain-reading one is')
   console.log('        marked and skipped rather than failed.')
   console.log('')
+  console.log('  npx -y agent-receipt-verify attempt-identity')
+  console.log('        nineteen vectors for the question the other layers assume: are these')
+  console.log('        records about the SAME attempt? One acceptance and at least one refusal')
+  console.log('        per normative clause of x402 spec section 5.5. Offline.')
+  console.log('')
   console.log('What this does NOT do: it judges the SHAPE of a receipt, not the honesty of')
   console.log('the party that issued it. See CONFORMANCE.md for what is deliberately left')
   console.log('unmeasured.')
@@ -92,6 +97,7 @@ const onderdelen = {
   kanon: '../src/eip3009-autorisatie.mjs',
   beleid: '../bench/eip3009-beleid.mjs',
   'link-vectors': '../src/settlement-link-vectors.mjs',
+  'attempt-identity': '../src/attempt-identity.mjs',
   'verify-delivery': '../src/verify-delivery.mjs',
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-receipt-verify",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "Checks x402 endpoint conformance before an agent pays, and links the receipt to its settlement.",
   "license": "Apache-2.0",
   "type": "module",
@@ -8,7 +8,7 @@
     "node": ">=20"
   },
   "scripts": {
-    "test": "node test/interop.mjs && node test/canonical.mjs && node test/link-onchain.mjs && node test/profiel.mjs && node test/eip3009.mjs && node test/conformance.mjs && node test/jws-offer.mjs && node test/census.mjs && node test/poortwachters.mjs && node test/metingen-bundel.mjs && node test/mcp-server.mjs && node test/cli.mjs && node test/bundel.mjs && node test/settlement-link-vectors.mjs && node test/naar-kanon-vorm.mjs && node test/verify-delivery.mjs && node test/acceptance-binding.mjs",
+    "test": "node test/interop.mjs && node test/canonical.mjs && node test/link-onchain.mjs && node test/profiel.mjs && node test/eip3009.mjs && node test/conformance.mjs && node test/jws-offer.mjs && node test/census.mjs && node test/poortwachters.mjs && node test/metingen-bundel.mjs && node test/mcp-server.mjs && node test/cli.mjs && node test/bundel.mjs && node test/settlement-link-vectors.mjs && node test/naar-kanon-vorm.mjs && node test/verify-delivery.mjs && node test/acceptance-binding.mjs && node test/methodefout-bench.mjs && node test/attempt-identity.mjs",
     "link-example": "node src/x402-link-onchain.mjs --receipt=examples/receipt-live-base-sepolia.json && node src/x402-link-onchain.mjs --receipt=examples/receipt-live-base-sepolia-2.json && node src/x402-link-onchain.mjs --receipt=examples/receipt-live-base-sepolia-3.json",
     "conformance": "node src/x402-conformance-check.mjs",
     "bench": "node bench/robustness.mjs",
@@ -22,7 +22,9 @@
     "bench-eip3009": "node bench/eip3009-beleid.mjs",
     "link-vectors": "node src/settlement-link-vectors.mjs",
     "verify-delivery": "node src/verify-delivery.mjs",
-    "kanon-vorm": "node tools/naar-kanon-vorm.mjs"
+    "kanon-vorm": "node tools/naar-kanon-vorm.mjs",
+    "bench-methodefout": "node bench/methodefout.mjs",
+    "attempt-identity": "node src/attempt-identity.mjs"
   },
   "optionalDependencies": {
     "ethers": "^6.17.0"

package/src/attempt-identity.mjs

@@ -0,0 +1,278 @@
+// Toetst de poging-identiteit: hoort dit alles bij DEZELFDE poging.
+//
+// WAAROM DIT BESTAAT. In erc-8004#99 kwamen op 18 oktober 2026 vier bewijslagen op tafel
+// (vooraf-veiligheid, vooraf-oordeel, betaalbewijs na afrekening, en onafhankelijke
+// werk-acceptatie), en de schrijver van de spec stelde vast dat geen van die vier de
+// vraag eronder beantwoordt: welke van deze bewijsstukken gaan eigenlijk over dezelfde
+// POGING. Hij schrijft die regel in x402#3776 paragraaf 5.5, en die paragraaf sluit af
+// met een verwijzing naar "the normative conformance tests ... for the required negative
+// cases". Die testen bestonden nog niet. Dit is dat.
+//
+// WAT HIER GEMETEN WORDT, en het is bewust alleen de INVARIANT. Niet of een facilitator
+// goed rekent, niet of een handtekening klopt, maar of alle paden van een verzoek
+// dezelfde identiteit opleveren en of een veranderd verzoek een andere identiteit krijgt.
+// Dat is precies wat 5.5 eist en niets meer.
+//
+// WAT HIER MET OPZET NIET GEMETEN WORDT. Wij halen geen enkel pad zelf op. Een vector is
+// een vastgelegde reeks WAARNEMINGEN per pad, en deze module toetst de invariant over die
+// reeks. Een facilitator laten sonderen zou betekenen dat wij zijn betaalpaden aanroepen,
+// en dat is niet aan ons.
+//
+// DRIE UITKOMSTEN, NOOIT TWEE: PASS, FAIL, NOT_MEASURED. Een clausule waarover de vector
+// geen gegevens draagt is niet geslaagd en niet gefaald, hij is niet gemeten. Dat
+// onderscheid is dezelfde correctie die de Kanon-auteur op 17 oktober 2026 overnam voor
+// zijn eigen controleur, en de spec-auteur een dag later voor de zijne.
+
+import { createHash } from 'node:crypto'
+
+/**
+ * De normatieve clausules van paragraaf 5.5, met het letterlijke citaat erbij.
+ *
+ * Het citaat staat hier zodat een lezer kan nazien dat wij toetsen wat er STAAT en niet
+ * wat wij ervan maakten. Verandert de tekst, dan hoort dit mee te veranderen en is het
+ * verschil zichtbaar in de diff in plaats van verstopt in een oordeel.
+ */
+export const CLAUSULES = [
+  {
+    id: 'derive-once-at-ingress',
+    citaat:
+      'MUST be derived once, at ingress, from the complete request snapshot as received by the facilitator, ' +
+      'and MUST NOT be re-derived or partially re-derived downstream',
+  },
+  {
+    id: 'all-paths-same-artifact',
+    citaat:
+      '/settle, refusal handling, replay-lookup, and challenge-quote responses all resolve the same artifact value',
+  },
+  {
+    id: 'changed-request-different-artifact',
+    citaat:
+      'A request whose amount, query, or body changes between paths MUST produce a different artifact, and that ' +
+      'change MUST surface as a settlement or announcement event, never as a silent divergence',
+  },
+  {
+    id: 'countersignature-recompute-or-refuse',
+    citaat:
+      'that counterparty MUST independently recompute the fingerprint from the bytes it observed, and MUST refuse ' +
+      'to sign if the recomputed value differs ... on mismatch the interaction MUST NOT settle',
+  },
+  {
+    id: 'own-identity-from-decoded-fields',
+    citaat:
+      "an attempt's own identity ... MUST be derived from named decoded fields and MUST NOT be derived from wire " +
+      'bytes, an attempt is the same attempt whether it arrived with a different key order or different whitespace',
+  },
+  {
+    id: 'reference-over-transmitted-bytes',
+    citaat:
+      'that reference is taken over the artifact as transmitted, because the signature covers those bytes, ' +
+      'canonicalizing them first would verify a different object than the one that was signed',
+  },
+  {
+    id: 'outcome-not-folded-into-identity',
+    citaat:
+      'Outcome payloads produced later in the attempt ... are not folded into the identity artifact, an ' +
+      'implementation MUST NOT extend identity derivation with values that did not exist at ingress',
+  },
+  {
+    id: 'name-independent-but-bound',
+    citaat:
+      'An implementation that already uses Idempotency-Key satisfies it by binding that key to the ingress snapshot',
+  },
+]
+
+export const UITKOMSTEN = ['PASS', 'FAIL', 'NOT_MEASURED']
+
+// Een minimale canonicalisatie: sleutels gesorteerd, geen witruimte. Genoeg om "dezelfde
+// velden, andere sleutelvolgorde" te herkennen, en met opzet NIET uitgegeven als een
+// volledige RFC8785-implementatie: die heeft eigen regels voor getallen, en een halve
+// implementatie onder een bekende naam is erger dan een eigen kleine functie onder een
+// eigen naam.
+export function sorteerStabiel(w) {
+  if (Array.isArray(w)) return w.map(sorteerStabiel)
+  if (w && typeof w === 'object') {
+    const uit = {}
+    for (const k of Object.keys(w).sort()) uit[k] = sorteerStabiel(w[k])
+    return uit
+  }
+  return w
+}
+
+export const velddigest = (o) => createHash('sha256').update(JSON.stringify(sorteerStabiel(o))).digest('hex')
+export const bytedigest = (s) => createHash('sha256').update(String(s), 'utf8').digest('hex')
+
+const kaal = (w) => (typeof w === 'string' ? w.trim().toLowerCase().replace(/^0x/, '') : null)
+const zelfde = (a, b) => kaal(a) !== null && kaal(a) === kaal(b)
+
+const PAD_NAMEN = ['challenge-quote', 'settle', 'refusal', 'replay-lookup']
+
+/** Eén clausule, één oordeel. Geen gegevens betekent NOT_MEASURED en nooit FAIL. */
+function toetsClausule(id, inv) {
+  const niet = (reden) => ({ clausule: id, uitkomst: 'NOT_MEASURED', reden })
+  const faal = (code, detail) => ({ clausule: id, uitkomst: 'FAIL', reason_code: code, detail })
+  const goed = (detail) => ({ clausule: id, uitkomst: 'PASS', detail })
+
+  if (id === 'derive-once-at-ingress') {
+    const ingress = inv.ingress
+    const paden = Array.isArray(inv.paths) ? inv.paths : []
+    if (!ingress?.identity || paden.length === 0) return niet('geen ingress-identiteit of geen paden vastgelegd')
+    // Een pad dat de identiteit opnieuw afleidt uit iets dat NIET in de ingress-momentopname
+    // zat, is de overtreding. De vector legt dat vast als het veld `derived_from`.
+    for (const p of paden) {
+      if (p.derived_from && p.derived_from !== 'ingress-snapshot') {
+        return faal('IDENTITY_REDERIVED_DOWNSTREAM', `pad ${p.path} leidde opnieuw af uit ${p.derived_from}`)
+      }
+    }
+    return goed(`${paden.length} paden, allemaal uit de ingress-momentopname`)
+  }
+
+  if (id === 'all-paths-same-artifact') {
+    const paden = Array.isArray(inv.paths) ? inv.paths : []
+    const metSnapshot = paden.filter((p) => p.identity)
+    if (metSnapshot.length < 2) return niet('minder dan twee paden met een identiteit')
+    // Alleen paden met EEN GELIJK verzoek horen dezelfde identiteit te hebben. Een pad
+    // met een gewijzigd verzoek valt onder de volgende clausule, niet onder deze.
+    const basis = inv.ingress?.snapshot ? velddigest(inv.ingress.snapshot) : null
+    const gelijkVerzoek = metSnapshot.filter((p) => !p.snapshot || !basis || velddigest(p.snapshot) === basis)
+    if (gelijkVerzoek.length < 2) return niet('minder dan twee paden met een ongewijzigd verzoek')
+    const eerste = gelijkVerzoek[0]
+    for (const p of gelijkVerzoek.slice(1)) {
+      if (!zelfde(p.identity, eerste.identity)) {
+        return faal('PATHS_DISAGREE_ON_IDENTITY', `${eerste.path} en ${p.path} geven een andere identiteit`)
+      }
+    }
+    const gedekt = gelijkVerzoek.map((p) => p.path).filter((p) => PAD_NAMEN.includes(p))
+    return goed(`${gelijkVerzoek.length} paden eens, waarvan benoemd in de spec: ${gedekt.join(', ') || 'geen'}`)
+  }
+
+  if (id === 'changed-request-different-artifact') {
+    const paden = Array.isArray(inv.paths) ? inv.paths : []
+    const basis = inv.ingress?.snapshot
+    if (!basis) return niet('geen ingress-momentopname om tegen af te zetten')
+    const gewijzigd = paden.filter((p) => p.snapshot && velddigest(p.snapshot) !== velddigest(basis))
+    if (gewijzigd.length === 0) return niet('geen pad met een gewijzigd verzoek vastgelegd')
+    for (const p of gewijzigd) {
+      if (zelfde(p.identity, inv.ingress.identity)) {
+        return faal('CHANGED_REQUEST_SAME_IDENTITY', `pad ${p.path} wijzigde het verzoek en hield dezelfde identiteit`)
+      }
+      const events = Array.isArray(inv.events) ? inv.events : []
+      const erkend = events.some((e) => zelfde(e.identity, p.identity))
+      if (!erkend) {
+        return faal('CHANGED_REQUEST_NO_EVENT', `pad ${p.path} kreeg een andere identiteit zonder dat er een gebeurtenis bij hoort`)
+      }
+    }
+    return goed(`${gewijzigd.length} gewijzigd(e) verzoek(en), elk met eigen identiteit en een gebeurtenis`)
+  }
+
+  if (id === 'countersignature-recompute-or-refuse') {
+    const c = inv.countersignature
+    if (!c) return niet('geen medeondertekening vastgelegd')
+    if (c.recomputed === undefined || c.ingress_value === undefined) return niet('geen herberekende of ingress-waarde')
+    const past = zelfde(c.recomputed, c.ingress_value)
+    if (!past && c.signed === true) return faal('COUNTERSIGNED_DESPITE_MISMATCH', 'de herberekende waarde week af en er is toch ondertekend')
+    if (!past && c.settled === true) return faal('SETTLED_DESPITE_MISMATCH', 'de herberekende waarde week af en er is toch afgerekend')
+    if (past && c.signed === false) return goed('de waarden kloppen en er is niet ondertekend, dat is toegestaan maar ongebruikelijk')
+    return goed(past ? 'herberekend en gelijk, dus ondertekenen mag' : 'herberekend en afwijkend, dus geweigerd en niet afgerekend')
+  }
+
+  if (id === 'own-identity-from-decoded-fields') {
+    const v = inv.wire_variants
+    if (!Array.isArray(v) || v.length < 2) return niet('minder dan twee draadvarianten vastgelegd')
+    // Dezelfde velden, andere sleutelvolgorde of witruimte. De identiteit MOET gelijk
+    // blijven; verschilt hij, dan is hij uit de bytes afgeleid.
+    const digests = new Set(v.map((x) => velddigest(x.decoded)))
+    if (digests.size !== 1) return niet('de varianten hebben niet dezelfde gedecodeerde velden')
+    const ids = new Set(v.map((x) => kaal(x.identity)))
+    if (ids.size !== 1) {
+      return faal('IDENTITY_DERIVED_FROM_WIRE_BYTES', 'dezelfde velden in een andere sleutelvolgorde gaven een andere identiteit')
+    }
+    return goed(`${v.length} draadvarianten, dezelfde identiteit`)
+  }
+
+  if (id === 'reference-over-transmitted-bytes') {
+    const r = inv.signed_artifact_reference
+    if (!r || r.transmitted === undefined || r.reference_hash === undefined) return niet('geen verwijzing naar een ondertekend stuk')
+    // Wij rekenen beide kanten ZELF uit in plaats van een label te geloven.
+    const overBytes = bytedigest(r.transmitted)
+    let overVelden = null
+    try {
+      overVelden = velddigest(JSON.parse(r.transmitted))
+    } catch {
+      overVelden = null
+    }
+    if (zelfde(r.reference_hash, overBytes)) return goed('de verwijzing is over de verzonden bytes genomen')
+    if (overVelden && zelfde(r.reference_hash, overVelden)) {
+      return faal('REFERENCE_CANONICALIZED_BEFORE_HASHING', 'de verwijzing is over een gecanonicaliseerde vorm genomen, dus over een ander object dan er ondertekend is')
+    }
+    return faal('REFERENCE_HASH_UNEXPLAINED', 'de verwijzing komt noch met de verzonden bytes noch met een gecanonicaliseerde vorm overeen')
+  }
+
+  if (id === 'outcome-not-folded-into-identity') {
+    const o = inv.outcome_variants
+    if (!Array.isArray(o) || o.length < 2) return niet('minder dan twee uitkomst-varianten vastgelegd')
+    const ids = new Set(o.map((x) => kaal(x.identity)))
+    if (ids.size !== 1) {
+      return faal('OUTCOME_FOLDED_INTO_IDENTITY', 'de identiteit verschilt tussen volledige en gedeeltelijke levering, dus uitkomstdata zit erin')
+    }
+    return goed(`${o.length} leveringsvarianten, dezelfde identiteit`)
+  }
+
+  if (id === 'name-independent-but-bound') {
+    const k = inv.identity_field
+    if (!k || k.bound_to === undefined) return niet('geen identiteitsveld met een binding vastgelegd')
+    if (k.bound_to !== 'ingress-snapshot') {
+      return faal('IDENTITY_NOT_BOUND_TO_SNAPSHOT', `het veld ${k.name ?? 'onbekend'} is gebonden aan ${k.bound_to} in plaats van aan de ingress-momentopname`)
+    }
+    if (k.client_supplied === true && k.verified_against_snapshot !== true) {
+      return faal('CLIENT_SUPPLIED_IDENTITY_NOT_VERIFIED', 'de client levert de identiteit aan en die wordt niet tegen de momentopname getoetst')
+    }
+    return goed(`${k.name ?? 'het identiteitsveld'} is aan de ingress-momentopname gebonden`)
+  }
+
+  return niet('onbekende clausule')
+}
+
+/**
+ * Toetst alle clausules waarover de vector gegevens draagt.
+ *
+ * Het eindoordeel is FAIL zodra EEN clausule faalt, want 5.5 is een invariant en niet een
+ * cijferlijst. Zonder enige meetbare clausule is het NOT_MEASURED, nooit PASS: een vector
+ * zonder gegevens mag nooit als bewijs van naleving tellen.
+ */
+export function toetsPogingIdentiteit(invoer) {
+  const inv = invoer && typeof invoer === 'object' ? invoer : {}
+  const perClausule = CLAUSULES.map((c) => toetsClausule(c.id, inv))
+  const gefaald = perClausule.filter((r) => r.uitkomst === 'FAIL')
+  const geslaagd = perClausule.filter((r) => r.uitkomst === 'PASS')
+  const uitkomst = gefaald.length > 0 ? 'FAIL' : geslaagd.length > 0 ? 'PASS' : 'NOT_MEASURED'
+  return {
+    outcome: uitkomst,
+    reason_code: gefaald[0]?.reason_code ?? null,
+    detail: gefaald[0]?.detail ?? null,
+    gemeten: geslaagd.length + gefaald.length,
+    niet_gemeten: perClausule.length - geslaagd.length - gefaald.length,
+    per_clausule: perClausule,
+  }
+}
+
+// Een ingang, zodat dit geen bestand is dat iemand moet vinden maar een regel die hij kan
+// draaien. Zonder sleutel, zonder account, zonder netwerk.
+if (process.argv[1]?.endsWith('attempt-identity.mjs')) {
+  const fs = await import('node:fs')
+  const path = await import('node:path')
+  const { fileURLToPath } = await import('node:url')
+  const map = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'vectors', 'attempt-identity')
+  const bestanden = fs.readdirSync(map).filter((b) => b.endsWith('.json')).sort()
+  let past = 0
+  for (const b of bestanden) {
+    const v = JSON.parse(fs.readFileSync(path.join(map, b), 'utf8'))
+    const u = toetsPogingIdentiteit(v.input)
+    const ok = u.outcome === v.expected.outcome && (v.expected.reason_code === undefined || u.reason_code === v.expected.reason_code)
+    if (ok) past++
+    console.log((ok ? '  ok   ' : '  FAIL ') + b.replace('.json', '').padEnd(40) + u.outcome + (u.reason_code ? ' / ' + u.reason_code : ''))
+  }
+  console.log('')
+  console.log(past + ' of ' + bestanden.length + ' vectors behave as recorded, across ' + CLAUSULES.length + ' normative clauses of x402 spec section 5.5.')
+  console.log('Every clause carries one acceptance and at least one refusal. No account, no key, no network.')
+  if (past !== bestanden.length) process.exitCode = 1
+}

package/src/x402-conformance-check.mjs

@@ -90,7 +90,15 @@ export async function meetEindpunt(url, { fetchImpl = fetch, methode = 'POST', l
     // De herhaling blijft bewust smal: alleen 404 en 405, alleen als wij NIET met GET
     // sondeerden, en precies een keer. Elke 404 blind herhalen zou het verkeer naar elk
     // dood adres verdubbelen, en dat is niet aan ons om te doen.
-    if (resp.status === 405 || resp.status === 404) {
+    // GEMETEN, EN DAARNA VERBREED. Na de 404 en 405 bleef er een restfout van 3,4 procent
+    // staan op zestig echte hosts, en die bestond uit twee andere codes die hetzelfde
+    // zeggen: cheaptokens.ai/api/buy gaf 400 op onze POST met een leeg lichaam en 402 op
+    // GET, en www.getbags.app/api/v1 gaf 406 op onze Accept-kop en 402 op GET. Alle vier
+    // de codes melden iets over ONS VERZOEK en niets over de bron, dus alle vier verdienen
+    // precies een tweede poging. De verzameling staat hier met naam zodat een vijfde code
+    // een gemeten beslissing vergt en niet stil meegroeit.
+    const VRAAG_OPNIEUW_BIJ = new Set([400, 404, 405, 406])
+    if (VRAAG_OPNIEUW_BIJ.has(resp.status)) {
       const allow = resp.headers.get('allow') || resp.headers.get('Allow') || ''
       const genoemd = allow
         .split(',')