agent-receipt-verify 0.2.3 → 0.2.5

package/src/x402-offer-receipt.mjs

@@ -16,21 +16,51 @@ import { createHash } from 'node:crypto'
 const TAG = Buffer.from('x402-receipt-authorization/0', 'ascii')
 const NUL = Buffer.from([0])
 
+// De lengte is VERPLICHT, niet optioneel. Eerder was `verwacht === undefined` stil
+// toegestaan, en dan deed deze functie niets anders dan hex naar bytes omzetten. Dat
+// was precies het gat dat hieronder beschreven staat: zodra `lengtes` per ongeluk geen
+// object was, viel elke lengtecontrole weg zonder dat er iets te zien was.
 const bytes = (h, naam, verwacht) => {
+  if (!Number.isInteger(verwacht) || verwacht <= 0) {
+    throw new Error(`geen lengte-eis bekend voor ${naam}, dus dit veld wordt niet geaccepteerd`)
+  }
   const b = Buffer.from(String(h ?? '').replace(/^0x/, ''), 'hex')
-  if (verwacht !== undefined && b.length !== verwacht) {
+  if (b.length !== verwacht) {
     throw new Error(`${naam} moet ${verwacht} bytes zijn, kreeg ${b.length}`)
   }
   return b
 }
 
+// De bekende methoden, met de lengte-eis per veld.
+//
+// WAAROM DIT EEN APARTE TABEL IS EN MET hasOwn WORDT OPGEZOCHT. Dit stond als
+// `{ eip3009: {...} }[method]` in de functie zelf, en dat is een opzoeking die ook de
+// PROTOTYPEKETEN raakt. Zelf gemeten op de gepubliceerde versie: `constructor`,
+// `toString`, `valueOf`, `hasOwnProperty` en `__proto__` kwamen alle vijf door de
+// `!lengtes`-poort, want ze geven een functie terug en een functie is waar. Daarna was
+// `lengtes.asset` undefined en viel elke lengtecontrole weg, en dan zijn de velden
+// zonder scheiding aan elkaar geplakt. De botsing is echt en narekenbaar:
+//
+//   method constructor, asset 0xaabb, authorizer 0xcc
+//   method constructor, asset 0xaa,   authorizer 0xbbcc
+//   geven BEIDE 0xd7f3867bb7a62bc13ba3e5e332c2109f3dc397d94c2f0d8c1238b8d87faa3836
+//
+// Twee verschillende afrekeningen die hetzelfde commitment opleveren is exact wat een
+// commitment moet uitsluiten, dus dit is geen schoonheidsfoutje.
+const LENGTES = { eip3009: { asset: 20, authorizer: 20 } }
+
+/** Is dit een methode die wij echt kennen, en niet iets uit de prototypeketen? */
+export function kentMethode(method) {
+  return typeof method === 'string' && Object.hasOwn(LENGTES, method)
+}
+
 // §5.6.2. Elk veld na `method` heeft een vaste lengte, dus het voorbeeld is
 // ondubbelzinnig. Lengtes worden hier afgedwongen: een veld van de verkeerde lengte
 // zou stilzwijgend een ander commitment opleveren dat nergens op opent.
 export function berekenCommitment({ method, asset, authorizer, identifier, salt }) {
   if (!method) throw new Error('method ontbreekt')
-  const lengtes = { eip3009: { asset: 20, authorizer: 20 } }[method]
-  if (!lengtes) throw new Error(`onbekende authorizationMethod: ${method}`)
+  if (!kentMethode(method)) throw new Error(`onbekende authorizationMethod: ${method}`)
+  const lengtes = LENGTES[method]
 
   const pre = Buffer.concat([
     TAG, NUL,
@@ -52,9 +82,25 @@ export function opentCommitment({ receipt, salt, asset, kandidaatIdentifiers })
   const commitment = payload?.authorizationCommitment
   if (!method || !commitment) return { linked: false, reden: 'receipt carries no commitment' }
 
+  // De vaste velden EERST, buiten de lus. Anders kan een onbruikbaar zout of een
+  // onbekende methode nooit zichtbaar worden: elke ronde gooit dan dezelfde fout, de
+  // catch slikt hem op, en de uitslag wordt "geen kandidaat opent dit" terwijl de
+  // waarheid is dat er niets te berekenen viel. Dat is het verschil tussen een
+  // afkeuring en een onvolledige meting, en dat verschil mag nooit wegvallen.
+  if (!kentMethode(method)) {
+    return { linked: false, meetbaar: false, reden: `unknown authorizationMethod: ${method}` }
+  }
+  try {
+    berekenCommitment({ method, asset, authorizer: payload.payer, identifier: '0x' + '00'.repeat(32), salt })
+  } catch (e) {
+    return { linked: false, meetbaar: false, reden: 'cannot compute a commitment here: ' + e.message }
+  }
+
   const treffers = []
   for (const identifier of kandidaatIdentifiers ?? []) {
     let berekend
+    // Hier kan nog maar een ding misgaan: deze ene identifier heeft de verkeerde
+    // lengte. Dat is dan geen treffer, en dat is de juiste uitkomst.
     try { berekend = berekenCommitment({ method, asset, authorizer: payload.payer, identifier, salt }) } catch { continue }
     if (berekend.toLowerCase() === String(commitment).toLowerCase()) treffers.push(identifier)
   }

package/tools/naar-kanon-vorm.mjs

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+// Zet onze afrekening-vectoren om naar de vorm van de kanon-vectoren.
+//
+// WAAROM DIT BESTAAT, en het is een verzoek en geen eigen inval. De auteur van de
+// kanon-vectoren schreef op 2026-10-17 in x402#3396: "if you want receipt-to-settlement
+// vectors in Kanon's shape, I'm open to that, with the part that needs a chain read
+// marked as such." Dit is dat, met die markering erin.
+//
+// WAT HIER WEL EN NIET VERTAALD KAN WORDEN, en dat tweede is het interessante deel.
+// Zijn `expected` is `{ valid: boolean, reason_code: string }`. Twee van onze vier
+// uitkomsten passen daar precies in. De andere twee niet, en dat is geen slordigheid
+// van hem maar het gat dat hij in dezelfde reactie zelf benoemde en zei te willen
+// dichten. Daarom laat dit script die twee gevallen ZICHTBAAR open staan in plaats van
+// ze in `valid: false` te duwen:
+//
+//   LINKED       -> valid true,  reason_code LINKED
+//   NOT_LINKED   -> valid false, reason_code NOT_LINKED
+//   AMBIGUOUS    -> valid false, reason_code AMBIGUOUS
+//   NOT_MEASURED -> GEEN valid. `measurable: false` plus een reason_code.
+//
+// Die laatste regel is het hele punt van de omzetting. Een bonnetje waarvan de
+// kandidatenlijst niet opgehaald kon worden is NIET afgekeurd, en het in `valid: false`
+// schrijven zou een eerlijke verkoper beschuldigen omdat onze RPC haperde. Liever een
+// veld dat zijn validator nog niet kent dan een onwaarheid die hij wel kan lezen.
+//
+// EN DE GRENS VAN DEZE VERTALING, want die hoort erbij. Zijn corpus dekt de autorisatie
+// van de KOPER voor de afrekening: geldigheidsvenster, malleability, domein-replay,
+// nonce-hergebruik, bedrag. Dit corpus dekt de andere kant: opent het gezouten
+// commitment in een ONDERTEKEND bonnetje op precies een afrekening op de keten. Die
+// twee overlappen nergens, dus dit is een aanvulling en geen samenvoeging.
+//
+// Gebruik:
+//   node tools/naar-kanon-vorm.mjs                 schrijft naar vectors/settlement-link-kanon
+//   node tools/naar-kanon-vorm.mjs --controleer    schrijft niets, meldt alleen afwijkingen
+
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const WORTEL = fileURLToPath(new URL('..', import.meta.url))
+export const BRONMAP = path.join(WORTEL, 'vectors', 'settlement-link')
+export const DOELMAP = path.join(WORTEL, 'vectors', 'settlement-link-kanon')
+
+/** Hun schema-versie, zoals die in elk van hun eigen vectoren staat. */
+export const KANON_SCHEMA_VERSIE = '3.0.0'
+
+/**
+ * De vertaaltabel van onze uitkomst naar hun expected-blok.
+ *
+ * `valid` wordt met opzet WEGGELATEN bij NOT_MEASURED, niet op false gezet. Een
+ * ontbrekend veld is voor een lezer een vraag; een false is een beschuldiging.
+ */
+export function naarExpected(onze) {
+  const o = onze?.outcome
+  if (o === 'LINKED') {
+    return { valid: true, reason_code: 'LINKED' }
+  }
+  if (o === 'NOT_LINKED') {
+    return { valid: false, reason_code: 'NOT_LINKED' }
+  }
+  if (o === 'AMBIGUOUS') {
+    return { valid: false, reason_code: 'AMBIGUOUS' }
+  }
+  if (o === 'NOT_MEASURED') {
+    return {
+      measurable: false,
+      reason_code: 'NOT_MEASURED',
+      note:
+        'Deliberately carries no `valid`. The candidate set could not be obtained, so this says ' +
+        'nothing about the receipt. Writing valid:false here would blame an honest seller for a ' +
+        'failed chain read. This is the third-outcome gap discussed in x402#3396.',
+    }
+  }
+  return null
+}
+
+/** Zet een van onze vectoren om. Geeft null terug als de uitkomst niet te vertalen is. */
+export function zetOm(v) {
+  const expected = naarExpected(v.expected)
+  if (!expected) return null
+  const uit = {
+    id: v.id,
+    schema_version: KANON_SCHEMA_VERSIE,
+    protocol: v.protocol ?? 'x402',
+    scheme: v.scheme ?? 'exact',
+    network: v.network,
+    asset_transfer_method: v.asset_transfer_method ?? 'eip3009',
+    // Een eigen veld, en het staat er omdat hun corpus deze as niet heeft. Hun vectoren
+    // gaan allemaal over de autorisatie VOOR de afrekening; deze gaan over het bonnetje
+    // NA de afrekening. Zonder dit veld zou een lezer de twee verzamelingen door elkaar
+    // halen zodra ze in een map staan.
+    verifies: 'receipt-to-settlement',
+    encodes: v.encodes,
+    provenance: v.provenance,
+    description: v.description,
+    // DE MARKERING DIE ERO M GEVRAAGD WERD. Hun schema heeft dit veld niet, dus het is
+    // additief: een loper die het niet kent negeert het en draait de vector gewoon, een
+    // loper die het wel kent weet dat er een RPC nodig is.
+    ...(v.requires_chain_read ? { requires_chain_read: true } : {}),
+    input: v.input,
+    ...(v.context ? { context: v.context } : {}),
+    expected,
+  }
+  return uit
+}
+
+export function laadBron(map = BRONMAP) {
+  if (!fs.existsSync(map)) return []
+  return fs.readdirSync(map).filter((f) => f.endsWith('.json')).sort()
+    .map((f) => ({ bestand: f, inhoud: JSON.parse(fs.readFileSync(path.join(map, f), 'utf8')) }))
+}
+
+const ditBestand = fileURLToPath(import.meta.url)
+if (process.argv[1] && path.resolve(process.argv[1]) === path.resolve(ditBestand)) {
+  const alleenControleren = process.argv.includes('--controleer')
+  const bron = laadBron()
+  if (!bron.length) {
+    console.error('no vectors found in vectors/settlement-link')
+    process.exit(1)
+  }
+
+  if (!alleenControleren) fs.mkdirSync(DOELMAP, { recursive: true })
+
+  let geschreven = 0
+  let ongewijzigd = 0
+  let afwijkend = 0
+  let nietTeVertalen = 0
+  const telling = {}
+
+  for (const { bestand, inhoud } of bron) {
+    const om = zetOm(inhoud)
+    if (!om) {
+      nietTeVertalen++
+      console.log('  SKIP  ' + bestand + '  (outcome ' + String(inhoud?.expected?.outcome) + ' has no translation)')
+      continue
+    }
+    const code = om.expected.reason_code
+    telling[code] = (telling[code] ?? 0) + 1
+    const doel = path.join(DOELMAP, bestand)
+    const tekst = JSON.stringify(om, null, 2) + '\n'
+    if (alleenControleren) {
+      const bestaat = fs.existsSync(doel) ? fs.readFileSync(doel, 'utf8') : null
+      if (bestaat === tekst) ongewijzigd++
+      else { afwijkend++; console.log('  DIFFERS  ' + bestand + (bestaat === null ? '  (missing)' : '')) }
+      continue
+    }
+    fs.writeFileSync(doel, tekst)
+    geschreven++
+  }
+
+  console.log('')
+  if (alleenControleren) {
+    console.log(ongewijzigd + ' up to date, ' + afwijkend + ' differ, ' + nietTeVertalen + ' untranslatable')
+    process.exitCode = afwijkend === 0 ? 0 : 1
+  } else {
+    console.log(geschreven + ' vectors written to vectors/settlement-link-kanon')
+  }
+  console.log('')
+  console.log('reason codes used:')
+  for (const [k, v] of Object.entries(telling).sort((a, b) => b[1] - a[1])) {
+    console.log('  ' + String(v).padStart(3) + '  ' + k)
+  }
+  const ketenLees = bron.filter((b) => b.inhoud.requires_chain_read).length
+  console.log('')
+  console.log(ketenLees + ' of ' + bron.length + ' carry requires_chain_read:true, so a runner knows to expect an RPC.')
+  console.log('')
+  console.log('One honest note about the translation, and it is the reason this exists:')
+  console.log('Kanon expected is valid plus a reason_code. LINKED, NOT_LINKED and AMBIGUOUS map')
+  console.log('onto that cleanly. NOT_MEASURED does not, so those files carry measurable:false')
+  console.log('and no valid at all, rather than a valid:false that would read as a verdict about')
+  console.log('a seller when the truth is that our own chain read did not happen.')
+}

package/tools/pack-inhoud.mjs

@@ -28,6 +28,7 @@
 // Exitcode 0 als er een lijst is, 1 als de inhoud niet te meten was.
 
 import { execSync } from 'node:child_process'
+import { readFileSync } from 'node:fs'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 
@@ -47,7 +48,13 @@ export function lijstUitPackUitvoer(ruw) {
     throw new Error('npm pack gaf geen json terug: ' + String(e.message).slice(0, 80))
   }
 
-  const uitEntry = (e) => (e && Array.isArray(e.files) ? e.files.map((f) => f.path) : null)
+  // EEN LEGE LIJST IS GEEN LIJST. `Array.isArray([])` is waar en `[]` is in javascript
+  // ook waar, dus een entry met `files: []` kwam hier als geldige uitkomst door en gaf
+  // een lege bestandslijst terug. Dat is precies wat de koptekst hierboven belooft NIET
+  // te doen, en het is ook de storing die deze file se eigen geschiedenis beschrijft:
+  // twaalf controles die verdwenen terwijl de suite groen bleef. Een tarball met nul
+  // bestanden bestaat niet, dus dit is altijd een meetfout en nooit een uitkomst.
+  const uitEntry = (e) => (e && Array.isArray(e.files) && e.files.length ? e.files.map((f) => f.path) : null)
 
   // Vorm 1: een array van entries (npm 11.11.0 en ouder).
   if (Array.isArray(j)) {
@@ -83,6 +90,43 @@ export function pakInhoud({ cwd = WORTEL, draai = null } = {}) {
   return lijstUitPackUitvoer(uit)
 }
 
+
+/**
+ * Wat de tarball MOET dragen, afgeleid uit de verzendtabel van de cli zelf.
+ *
+ * WAAROM AFGELEID EN NIET OPGESCHREVEN. De publicatiestap heette "de tarball moet NOTICE,
+ * LICENSE en alles waar de cli naar verwijst dragen" en toetste vijf vaste paden, terwijl
+ * de verzendtabel negen modules heeft. Zeven subcommando's werden dus nooit gecontroleerd.
+ * Zou `files` in package.json ooit `src/` kwijtraken, dan ging er een pakket uit waarvan
+ * elk subcommando bij de eerste aanroep crasht, en deze poort zou groen staan. Een lijst
+ * die met de hand wordt bijgehouden loopt per definitie achter op de tabel die hij
+ * bewaakt; deze leest die tabel.
+ *
+ * De drie vaste regels eronder staan er wel met de hand, en met opzet: NOTICE en LICENSE
+ * zijn een LICENTIEPLICHT (wij verspreiden testvectoren van derden onder Apache-2.0) en
+ * volgen uit geen enkele tabel. Het profielbestand staat erbij omdat de ladder het leest
+ * zonder dat een importregel dat verraadt.
+ */
+export function verwachteBestanden({ cliPad = null } = {}) {
+  const pad = cliPad ?? path.join(WORTEL, 'bin', 'cli.mjs')
+  const bron = readFileSync(pad, 'utf8')
+  const tabel = bron.match(/const onderdelen = \{([^}]*)\}/)
+  if (!tabel) {
+    throw new Error('de verzendtabel is niet te vinden in ' + pad + ', dus de verwachte inhoud is ONGEMETEN')
+  }
+  const modules = [...tabel[1].matchAll(/'([^']+\.mjs)'/g)].map((m) => m[1].replace(/^\.\.\//, ''))
+  if (!modules.length) {
+    throw new Error('de verzendtabel in ' + pad + ' bevat geen enkel modulepad, dus hier is iets stuk')
+  }
+  return [
+    'NOTICE',
+    'LICENSE',
+    'bin/cli.mjs',
+    'profiles/x402-deployed-ladder-v1.json',
+    ...modules,
+  ]
+}
+
 const ditBestand = fileURLToPath(import.meta.url)
 if (process.argv[1] && path.resolve(process.argv[1]) === path.resolve(ditBestand)) {
   try {

package/vectors/acceptance-binding/crossed-deliverable.json

@@ -0,0 +1,40 @@
+{
+  "id": "acceptance-binding-crossed-deliverable",
+  "schema_version": "3.0.0",
+  "verifies": "receipt-to-acceptance",
+  "encodes": "The case babyblueviper1 asked for: an acceptance record paired with a receipt for a different deliverable. It must not link.",
+  "provenance": [
+    "trilatic.acceptance-receipt/1.2, as cited in x402-foundation/tsc#4",
+    "requested in erc-8004/erc-8004-contracts#99 by babyblueviper1 on 18 October 2026: \"a vector in which the acceptance record names a different deliverable hash than the receipt it is paired with. It should not link.\""
+  ],
+  "description": "Identical to the positive control except for one byte of the acceptance record's deliverable hash. Everything else still passes: the sidecar names the right receipt, the checker is independent, and the criteria were committed first. A verifier that reports LINKED here is reading the pair as a whole instead of checking that both halves name the same deliverable, which is the one thing this binding exists to prove.",
+  "requires_chain_read": false,
+  "input": {
+    "receipt": {
+      "format": "eip712",
+      "authorizationNonce": "0x43457c8e57b7c4ff92d716350c61c88c8f3b644d09d7c813d5a7ee6450a843da"
+    },
+    "receiptSha256": "9f2c1d4e8a7b6053fe41cc90b2d7a3418e5f6072c9b8d1a4e7f0352698cdba17",
+    "acceptance": {
+      "format": "trilatic.acceptance-receipt/1.2",
+      "deliverable_sha256": "d74ad7d7c41b8e5206f39ac718be40d5392fb6ca07e1d8359f4b26cd0a39e030",
+      "checker": "invinoveritas-checker-a4cecab2",
+      "producer": "tokenizen-seller-2888f365",
+      "criteria_committed_at": "2026-10-18T00:52:03Z",
+      "checked_at": "2026-10-18T00:52:09Z"
+    },
+    "bindings": {
+      "receipt_sha256": "9f2c1d4e8a7b6053fe41cc90b2d7a3418e5f6072c9b8d1a4e7f0352698cdba17",
+      "deliverable_sha256": "d74ad7d7c41b8e5206f39ac718be40d5392fb6ca07e1d8359f4b26cd0a39e02f",
+      "authorization": "0x43457c8e57b7c4ff92d716350c61c88c8f3b644d09d7c813d5a7ee6450a843da"
+    }
+  },
+  "expected": {
+    "valid": false,
+    "reason_code": "NOT_LINKED",
+    "detail": "DELIVERABLE_HASH_MISMATCH"
+  },
+  "limits": [
+    "This proves the pair does not hold together. It says nothing about which of the two artifacts is the wrong one."
+  ]
+}

package/vectors/acceptance-binding/pairs-same-deliverable.json

@@ -0,0 +1,39 @@
+{
+  "id": "acceptance-binding-pairs-same-deliverable",
+  "schema_version": "3.0.0",
+  "verifies": "receipt-to-acceptance",
+  "encodes": "The positive control. Without it, a set that only contains failures proves nothing about the harness.",
+  "provenance": [
+    "trilatic.acceptance-receipt/1.2, as cited in x402-foundation/tsc#4",
+    "proposed in erc-8004/erc-8004-contracts#99 by babyblueviper1 on 18 October 2026"
+  ],
+  "description": "A signed bindings sidecar names one receipt and one deliverable hash, and the acceptance record names that same deliverable hash. The checker is not the producer, and the criteria were committed before the check. This must link.",
+  "requires_chain_read": false,
+  "input": {
+    "receipt": {
+      "format": "eip712",
+      "authorizationNonce": "0x43457c8e57b7c4ff92d716350c61c88c8f3b644d09d7c813d5a7ee6450a843da"
+    },
+    "receiptSha256": "9f2c1d4e8a7b6053fe41cc90b2d7a3418e5f6072c9b8d1a4e7f0352698cdba17",
+    "acceptance": {
+      "format": "trilatic.acceptance-receipt/1.2",
+      "deliverable_sha256": "d74ad7d7c41b8e5206f39ac718be40d5392fb6ca07e1d8359f4b26cd0a39e02f",
+      "checker": "invinoveritas-checker-a4cecab2",
+      "producer": "tokenizen-seller-2888f365",
+      "criteria_committed_at": "2026-10-18T00:52:03Z",
+      "checked_at": "2026-10-18T00:52:09Z"
+    },
+    "bindings": {
+      "receipt_sha256": "9f2c1d4e8a7b6053fe41cc90b2d7a3418e5f6072c9b8d1a4e7f0352698cdba17",
+      "deliverable_sha256": "d74ad7d7c41b8e5206f39ac718be40d5392fb6ca07e1d8359f4b26cd0a39e02f",
+      "authorization": "0x43457c8e57b7c4ff92d716350c61c88c8f3b644d09d7c813d5a7ee6450a843da"
+    }
+  },
+  "expected": {
+    "valid": true,
+    "reason_code": "LINKED"
+  },
+  "limits": [
+    "The signature on the acceptance record is not checked here, and neither are its criteria. That is the issuing checker's own verifier. A LINKED verdict says the two artifacts are about the same thing, not that the acceptance record itself is sound."
+  ]
+}

package/vectors/acceptance-binding/real-record-as-issued.json

@@ -0,0 +1,68 @@
+{
+  "schema_version": "3.0.0",
+  "verifies": "receipt-to-acceptance",
+  "requires_chain_read": false,
+  "provenance": [
+    "trilatic.acceptance-receipt/1.2, live record fetched from https://api.babyblueviper.com/work-acceptance/record/4c7273afcdb5333586b0a41c4238a968f3dedc23f66f71c5a1928ff3d279ab3d on 18 October 2026",
+    "the two binding keys were specified by babyblueviper1 in erc-8004/erc-8004-contracts#99 on 18 October 2026",
+    "the record is issued by invinoveritas, not by us; it is copied here as test material"
+  ],
+  "id": "acceptance-binding-real-record-as-issued",
+  "encodes": "A real, live, signed acceptance record whose independence cannot be verified by a third party, because the two parties are named in different namespaces while the issuer declares independence.",
+  "description": "This is the record exactly as the issuer serves it, with only the fields this layer reads. It says independence: \"independent\". The checker is identified by key_id (invinoveritas-checker-a4cecab2). The producer has key_id: null and is identified only by a display name (\"Example Vendor (self-test)\"). A key_id and a display name are two different kinds of name, so comparing them is not a comparison: a reader cannot establish that the checker is not the producer, in either direction. The honest outcome is NOT_MEASURED, not a pass and not a fail. A verifier that returns a pass here is reporting the issuer own claim back to the reader as if a third party had checked it, and a verifier that returns a fail is treating an unmeasured field as a refusal.",
+  "input": {
+    "doc": {
+      "record": {
+        "receipt": {
+          "schema": "trilatic.acceptance-receipt/1.2",
+          "receipt_id": "INV-WA-aa4b8bc740bc2524",
+          "issuer": "invinoveritas",
+          "issued_utc": "2026-10-18T00:52:09Z",
+          "criteria": {
+            "id": "invinoveritas-p1-selftest",
+            "sha256": "d74ad7d7492908f1146b233e89db6ca205065c67f02d33758ff0aa9f8b9e02fc",
+            "committed_at": "2026-10-18T00:52:03Z"
+          },
+          "files": {
+            "remediated": {
+              "name": "refund-policy.txt",
+              "bytes": 121,
+              "sha256": "9c27eee03d50f4ff00fb60a1551a03d7311dbed257b7b943b3ff5d13eb30c083"
+            }
+          },
+          "parties": {
+            "checker": {
+              "name": "invinoveritas",
+              "key_id": "invinoveritas-checker-a4cecab2"
+            },
+            "producer": {
+              "name": "Example Vendor (self-test)",
+              "key_id": null
+            }
+          },
+          "independence": "independent",
+          "verdict": "pass"
+        }
+      },
+      "bindings_sidecar": {
+        "version": "invinoveritas.work-acceptance-bindings/v0",
+        "receipt_sha256": "4c7273afcdb5333586b0a41c4238a968f3dedc23f66f71c5a1928ff3d279ab3d",
+        "criteria_id": "d74ad7d7492908f1146b233e89db6ca205065c67f02d33758ff0aa9f8b9e02fc",
+        "bindings": {}
+      }
+    },
+    "receiptSha256": "4c7273afcdb5333586b0a41c4238a968f3dedc23f66f71c5a1928ff3d279ab3d",
+    "deliverableSha256": "9c27eee03d50f4ff00fb60a1551a03d7311dbed257b7b943b3ff5d13eb30c083"
+  },
+  "expected": {
+    "valid": false,
+    "measurable": false,
+    "reason_code": "NOT_MEASURED",
+    "independence": "ZELFVERKLAARD_ONVERIFIEERBAAR"
+  },
+  "limits": [
+    "This says nothing about whether the check itself was good. It says the independence claim is not auditable from the record.",
+    "One field closes it: a key_id on the producer, in the same namespace as the checker. See real-record-with-producer-key.json for the same record with that field set.",
+    "Where a producer has no key at all, the remaining third-party handle on whether two parties are the same hand is the money, not the paperwork. That is a different measurement and it is not this one."
+  ]
+}

package/vectors/acceptance-binding/real-record-crossed-deliverable.json

@@ -0,0 +1,65 @@
+{
+  "schema_version": "3.0.0",
+  "verifies": "receipt-to-acceptance",
+  "requires_chain_read": false,
+  "provenance": [
+    "trilatic.acceptance-receipt/1.2, live record fetched from https://api.babyblueviper.com/work-acceptance/record/4c7273afcdb5333586b0a41c4238a968f3dedc23f66f71c5a1928ff3d279ab3d on 18 October 2026",
+    "the two binding keys were specified by babyblueviper1 in erc-8004/erc-8004-contracts#99 on 18 October 2026",
+    "the record is issued by invinoveritas, not by us; it is copied here as test material"
+  ],
+  "id": "acceptance-binding-real-record-crossed-deliverable",
+  "encodes": "The case babyblueviper1 asked for, in the shape the issuer actually serves.",
+  "description": "Identical to real-record-with-producer-key except for one byte of the deliverable hash we hold. Everything else still passes: the sidecar names the right receipt, the checker is verifiably not the producer, and the criteria were committed first. A verifier that reports LINKED here is reading the pair as a whole instead of checking that both halves name the same deliverable, which is the one thing this binding exists to prove.",
+  "input": {
+    "doc": {
+      "record": {
+        "receipt": {
+          "schema": "trilatic.acceptance-receipt/1.2",
+          "receipt_id": "INV-WA-aa4b8bc740bc2524",
+          "issuer": "invinoveritas",
+          "issued_utc": "2026-10-18T00:52:09Z",
+          "criteria": {
+            "id": "invinoveritas-p1-selftest",
+            "sha256": "d74ad7d7492908f1146b233e89db6ca205065c67f02d33758ff0aa9f8b9e02fc",
+            "committed_at": "2026-10-18T00:52:03Z"
+          },
+          "files": {
+            "remediated": {
+              "name": "refund-policy.txt",
+              "bytes": 121,
+              "sha256": "9c27eee03d50f4ff00fb60a1551a03d7311dbed257b7b943b3ff5d13eb30c083"
+            }
+          },
+          "parties": {
+            "checker": {
+              "name": "invinoveritas",
+              "key_id": "invinoveritas-checker-a4cecab2"
+            },
+            "producer": {
+              "name": "Example Vendor (self-test)",
+              "key_id": "example-vendor-producer-7f31aa02"
+            }
+          },
+          "independence": "independent",
+          "verdict": "pass"
+        }
+      },
+      "bindings_sidecar": {
+        "version": "invinoveritas.work-acceptance-bindings/v0",
+        "receipt_sha256": "4c7273afcdb5333586b0a41c4238a968f3dedc23f66f71c5a1928ff3d279ab3d",
+        "criteria_id": "d74ad7d7492908f1146b233e89db6ca205065c67f02d33758ff0aa9f8b9e02fc",
+        "bindings": {}
+      }
+    },
+    "receiptSha256": "4c7273afcdb5333586b0a41c4238a968f3dedc23f66f71c5a1928ff3d279ab3d",
+    "deliverableSha256": "9c27eee03d50f4ff00fb60a1551a03d7311dbed257b7b943b3ff5d13eb30c084"
+  },
+  "expected": {
+    "valid": false,
+    "reason_code": "NOT_LINKED",
+    "detail": "DELIVERABLE_HASH_MISMATCH"
+  },
+  "limits": [
+    "This proves the pair does not hold together. It says nothing about which of the two artifacts is the wrong one."
+  ]
+}

package/vectors/acceptance-binding/real-record-crossed-x402-keys.json

@@ -0,0 +1,74 @@
+{
+  "schema_version": "3.0.0",
+  "verifies": "receipt-to-acceptance",
+  "requires_chain_read": false,
+  "provenance": [
+    "trilatic.acceptance-receipt/1.2, live record fetched from https://api.babyblueviper.com/work-acceptance/record/4c7273afcdb5333586b0a41c4238a968f3dedc23f66f71c5a1928ff3d279ab3d on 18 October 2026",
+    "the two binding keys were specified by babyblueviper1 in erc-8004/erc-8004-contracts#99 on 18 October 2026",
+    "the record is issued by invinoveritas, not by us; it is copied here as test material"
+  ],
+  "id": "acceptance-binding-real-record-crossed-x402-keys",
+  "encodes": "Why the format carries two separate keys: a salted commitment must never be compared against a raw nonce.",
+  "description": "The sidecar carries the commitment value in the nonce key and the nonce value in the commitment key. Both are present, both are well-formed 32-byte values, and both belong to the same real payment, so a verifier that treats the two keys as interchangeable, or that falls back to one generic authorization field, will report LINKED. It must not. This is the failure the two-key split was introduced to prevent, and it is the one case a single-field implementation cannot see.",
+  "input": {
+    "doc": {
+      "record": {
+        "receipt": {
+          "schema": "trilatic.acceptance-receipt/1.2",
+          "receipt_id": "INV-WA-aa4b8bc740bc2524",
+          "issuer": "invinoveritas",
+          "issued_utc": "2026-10-18T00:52:09Z",
+          "criteria": {
+            "id": "invinoveritas-p1-selftest",
+            "sha256": "d74ad7d7492908f1146b233e89db6ca205065c67f02d33758ff0aa9f8b9e02fc",
+            "committed_at": "2026-10-18T00:52:03Z"
+          },
+          "files": {
+            "remediated": {
+              "name": "refund-policy.txt",
+              "bytes": 121,
+              "sha256": "9c27eee03d50f4ff00fb60a1551a03d7311dbed257b7b943b3ff5d13eb30c083"
+            }
+          },
+          "parties": {
+            "checker": {
+              "name": "invinoveritas",
+              "key_id": "invinoveritas-checker-a4cecab2"
+            },
+            "producer": {
+              "name": "Example Vendor (self-test)",
+              "key_id": "example-vendor-producer-7f31aa02"
+            }
+          },
+          "independence": "independent",
+          "verdict": "pass"
+        }
+      },
+      "bindings_sidecar": {
+        "version": "invinoveritas.work-acceptance-bindings/v0",
+        "receipt_sha256": "4c7273afcdb5333586b0a41c4238a968f3dedc23f66f71c5a1928ff3d279ab3d",
+        "criteria_id": "d74ad7d7492908f1146b233e89db6ca205065c67f02d33758ff0aa9f8b9e02fc",
+        "bindings": {
+          "x402_receipt_commitment": "0x43457c8e57b7c4ff92d716350c61c88c8f3b644d09d7c813d5a7ee6450a843da",
+          "x402_authorization_nonce": "0xe04421456465df1012f416b72aece3401f9e3d5be5bd78280324a031efe1d40f"
+        }
+      }
+    },
+    "receipt": {
+      "format": "eip712",
+      "authorizationNonce": "0x43457c8e57b7c4ff92d716350c61c88c8f3b644d09d7c813d5a7ee6450a843da",
+      "authorizationCommitment": "0xe04421456465df1012f416b72aece3401f9e3d5be5bd78280324a031efe1d40f"
+    },
+    "receiptSha256": "4c7273afcdb5333586b0a41c4238a968f3dedc23f66f71c5a1928ff3d279ab3d",
+    "deliverableSha256": "9c27eee03d50f4ff00fb60a1551a03d7311dbed257b7b943b3ff5d13eb30c083"
+  },
+  "expected": {
+    "valid": false,
+    "reason_code": "NOT_LINKED",
+    "detail": "COMMITMENT_MISMATCH"
+  },
+  "limits": [
+    "The commitment and the nonce in this vector are from our own mainnet payment of 18 October 2026, so both are real values, not placeholders.",
+    "A verifier can also fail this on AUTHORIZATION_MISMATCH depending on which pair it compares first; either refusal is correct, reporting LINKED is not."
+  ]
+}