agent-receipt-verify 0.0.0-stage → 0.2.2

package/bench/eip3009-beleid.mjs

@@ -0,0 +1,113 @@
+// Een matrix over de twee open vragen uit x402#2725, zodat een antwoord daar een
+// meting is en geen mening.
+//
+// DE TWEE VRAGEN, letterlijk van de steller van dat issue: moet het betaalde bedrag
+// precies kloppen of mag er te veel betaald worden, en moet hergebruik van een nonce
+// per betaler worden bijgehouden. Geen van beide wordt gedekt door een gepubliceerde
+// vector, en dus heeft onze eigen "eens op tien van tien" er niets over gezegd. Dat is
+// precies waarom dit bestand bestaat: een cijfer dat klopt kan een vraag verbergen.
+//
+// WAT HIER GEMETEN WORDT. Dezelfde tien vectoren onder beide bedragbeleiden, plus twee
+// gevallen die zij niet dekken en die het verschil zichtbaar maken. De uitslag is een
+// tabel waarin te zien is waar de twee keuzes uit elkaar lopen en waar niet.
+//
+// DE UITVOER IS ENGELS, de commentaren zijn dat niet. Sinds 0.2.2 is dit een eigen
+// commando (`agent-receipt-verify beleid`), dus de regels die iemand op zijn scherm
+// krijgt zijn voor een vreemde bedoeld. Een meting die niemand kan lezen is geen
+// meting die iemand overneemt.
+//
+// Gebruik: node bench/eip3009-beleid.mjs   of   npx agent-receipt-verify beleid
+
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { beoordeelVector, beoordeelAutorisatie } from '../src/eip3009-autorisatie.mjs'
+
+const wortel = fileURLToPath(new URL('..', import.meta.url))
+const MAP = path.join(wortel, 'vectors', 'kanon')
+const lees = (n) => JSON.parse(fs.readFileSync(path.join(MAP, n), 'utf8'))
+
+const vectoren = fs.readdirSync(MAP).filter((f) => f.endsWith('.json')).sort()
+
+console.log('EIP-3009: the two open questions from x402 issue 2725, measured')
+console.log('')
+
+// ---------------------------------------------------------------------------
+console.log('1. The same ten vectors under both amount policies')
+console.log('')
+const uitkomst = {}
+for (const beleid of ['exact', 'at-least']) {
+  let eens = 0
+  const afwijkend = []
+  for (const f of vectoren) {
+    const v = lees(f)
+    const u = await beoordeelAutorisatie(v.input, { ...(v.context ?? {}), doelNetwerk: v.network, amountPolicy: beleid })
+    if (u.valid === v.expected.valid && u.reason_code === v.expected.reason_code) eens++
+    else afwijkend.push(v.id + ' (' + u.reason_code + ' against ' + v.expected.reason_code + ')')
+  }
+  uitkomst[beleid] = { eens, afwijkend }
+  console.log('  ' + beleid.padEnd(9) + ' agrees on ' + eens + ' of ' + vectoren.length +
+    (afwijkend.length ? '   differs: ' + afwijkend.join(', ') : ''))
+}
+console.log('')
+console.log('  Both policies reach the same verdict on all ten. That is the point: the')
+console.log('  published vectors only cover UNDERpayment, so they cannot answer the')
+console.log('  question. Anyone who stops here thinks they know.')
+
+// ---------------------------------------------------------------------------
+console.log('')
+console.log('2. The case no vector covers: paying too much')
+console.log('')
+{
+  const basis = lees('valid-baseline-001.json')
+  for (const beleid of ['exact', 'at-least']) {
+    const v = JSON.parse(JSON.stringify(basis))
+    v.input.accepted.amount = String(BigInt(v.input.payload.authorization.value) - 1n)
+    const u = await beoordeelAutorisatie(v.input, { ...(v.context ?? {}), doelNetwerk: v.network, amountPolicy: beleid })
+    console.log('  ' + beleid.padEnd(9) + ' signed ' + v.input.payload.authorization.value +
+      ', asked ' + v.input.accepted.amount + '  ->  ' + (u.valid ? 'VALID' : u.reason_code))
+  }
+  console.log('')
+  console.log('  Two reference implementations reject this:')
+  console.log('    go/mechanisms/evm/exact/facilitator/eip3009.go:65  Cmp(requiredValue) != 0')
+  console.log('    python/x402/mechanisms/evm/exact/facilitator.py:235  value != amount')
+  console.log('    and that same python says on line 168: "Amount exactly matches requirements.amount"')
+  console.log('  So exact is our default. It stays a choice, which is why it is printed in')
+  console.log('  the result and not buried in the code.')
+}
+
+// ---------------------------------------------------------------------------
+console.log('')
+console.log('3. The second case no vector covers: the same nonce, a DIFFERENT payer')
+console.log('')
+{
+  const basis = lees('valid-baseline-001.json')
+  const nonce = basis.input.payload.authorization.nonce
+  const andereBetaler = '0x000000000000000000000000000000000000dEaD'
+
+  // Per betaler, zoals het token-contract het doet.
+  const perBetaler = await beoordeelVector({
+    ...basis,
+    context: { ...basis.context, seen_nonces: { [andereBetaler]: [nonce] } },
+  })
+  // De grove vorm: een lijst zonder onderscheid naar betaler.
+  const plat = await beoordeelVector({
+    ...basis,
+    context: { ...basis.context, seen_nonces: [nonce] },
+  })
+
+  console.log('  nonce already spent by ANOTHER address')
+  console.log('    per payer (how the contract does it) ->  ' + (perBetaler.valid ? 'VALID' : perBetaler.reason_code))
+  console.log('  the same nonce spent by THIS payer')
+  console.log('    flat list                            ->  ' + (plat.valid ? 'VALID' : plat.reason_code))
+  console.log('')
+  console.log('  EIP-3009 tracks this per address itself: mapping(address => mapping(bytes32')
+  console.log('  => bool)), readable as authorizationState(address authorizer, bytes32 nonce),')
+  console.log('  and the spec says nonces are random 32 bytes, unique to the authorizer. A')
+  console.log('  verifier holding a list without the payer is therefore STRICTER than the')
+  console.log('  chain, and could refuse a valid payment from someone else.')
+}
+
+console.log('')
+console.log('Short version: on the ten published vectors neither choice makes a difference.')
+console.log('On the two cases nobody published, it decides everything.')

package/bench/robustness.mjs

@@ -0,0 +1,264 @@
+// BENCHMARK: kan onze verifieerder voor de gek gehouden worden, en kunnen wij zelf
+// een geldig tegengetekend bonnetje maken?
+//
+// WAAROM DIT APART VAN DE TESTS STAAT. De tests tonen aan dat wij op de vier
+// gepubliceerde vectoren hetzelfde oordeel geven als hun eigen verifieerder. Dat is
+// correctheid, en correctheid is niet hetzelfde als POSITIE. Een controle die alles
+// goedkeurt geeft op vier vectoren precies dezelfde uitslag als een goede controle,
+// zolang drie van die vier negatief zijn en hij per ongeluk de juiste reden noemt.
+//
+// Deze benchmark meet daarom twee dingen die de vectoren niet kunnen meten:
+//
+//  1. PRECISIE ONDER AANVAL. Neem het POSITIEVE geval en verander er systematisch
+//     een ding in. Elke mutatie MOET afgekeurd worden. Een mutatie die we
+//     goedkeuren is geen cosmetisch gebrek maar precies het gat waardoor een
+//     vervalst bonnetje erdoor komt, en dat is het enige dat deze verifieerder te
+//     verkopen heeft.
+//
+//  2. KUNNEN WIJ TEGENPARTIJ ZIJN. De onderhouder van INAM vroeg of wij de
+//     tegenpartij willen zijn op een echt bonnetje. Dat beloven zonder te weten of
+//     wij er zelf een kunnen maken en ondertekenen, is een belofte op krediet. Dit
+//     deel bouwt er een, met eigen sleutels, en laat onze eigen verifieerder erover
+//     oordelen. Lukt dat niet, dan is het antwoord nee en weten we dat nu.
+//
+// Geen netwerk, geen sleutel van de koning, alleen node-ingebouwde crypto.
+
+import { createHash, generateKeyPairSync, sign as edSign } from 'node:crypto'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { dirname, join } from 'node:path'
+import { canoniek, toetsGeval } from '../src/inam-countersigned.mjs'
+
+const HIER = dirname(fileURLToPath(import.meta.url))
+const suite = JSON.parse(readFileSync(join(HIER, '..', 'vectors', 'inam', 'vectors.json'), 'utf8'))
+const positief = suite.cases.find((c) => c.id === 'POSITIVE')
+if (!positief) {
+  console.error('geen POSITIVE-vector gevonden, deze benchmark heeft er een nodig')
+  process.exit(2)
+}
+
+const sha256hex = (s) => createHash('sha256').update(s, 'utf8').digest('hex')
+
+// ── deel 1: precisie onder aanval ────────────────────────────────────────────
+
+/** Maak een kopie van het geval met een mutatie in het ondertekende bestand. */
+function muteer(naam, fn) {
+  const f = JSON.parse(positief.feedbackFile)
+  fn(f)
+  return { naam, geval: { ...positief, feedbackFile: JSON.stringify(f) } }
+}
+
+const eersteTeken = (s) => (s[0] === 'a' ? 'b' : 'a') + s.slice(1)
+
+const mutaties = [
+  muteer('handtekening van de aanvrager omgedraaid', (f) => {
+    f.inam.receipt.signatures.agentA = eersteTeken(f.inam.receipt.signatures.agentA)
+  }),
+  muteer('handtekening van de uitvoerder omgedraaid', (f) => {
+    f.inam.receipt.signatures.agentB = eersteTeken(f.inam.receipt.signatures.agentB)
+  }),
+  muteer('beide handtekeningen weg', (f) => {
+    f.inam.receipt.signatures = {}
+  }),
+  muteer('de uitvoer-hash veranderd', (f) => {
+    f.inam.receipt.result.outputHash = 'sha256:' + '0'.repeat(64)
+  }),
+  muteer('de opdracht-hash veranderd', (f) => {
+    f.inam.receipt.task.specHash = 'sha256:' + '0'.repeat(64)
+  }),
+  muteer('het bonnetje-kenmerk veranderd', (f) => {
+    f.inam.receipt.receiptId = 'sha256:' + '1'.repeat(64)
+  }),
+  muteer('de opdracht-naam veranderd', (f) => {
+    f.inam.receipt.jobId = 'http:iets-anders'
+  }),
+  muteer('de aanvrager vervangen door een ander adres', (f) => {
+    f.clientAddress = 'eip155:8453:0x9999999999999999999999999999999999999999'
+  }),
+  muteer('de waarde opgeschroefd', (f) => {
+    f.value = 999
+  }),
+  muteer('de uitvoerder vervangen door de aanvrager', (f) => {
+    f.inam.receipt.agentB = { ...f.inam.receipt.agentA, role: 'worker' }
+  }),
+  muteer('een veld toegevoegd aan de ondertekende inhoud', (f) => {
+    f.inam.receipt.task.extra = 'ik was hier'
+  }),
+  muteer('de rol van de aanvrager omgedraaid', (f) => {
+    f.inam.receipt.agentA.role = 'worker'
+  }),
+]
+
+console.log('DEEL 1: precisie onder aanval')
+console.log('  Elke mutatie van ondertekende inhoud MOET afgekeurd worden.')
+console.log('')
+
+// Eerst de controle dat het onveranderde geval wel wordt geaccepteerd. Zonder die
+// regel meet deel 1 niets: een verifieerder die alles afkeurt haalt hier anders
+// een perfecte score.
+const basis = toetsGeval(positief, suite)
+console.log('  basislijn, onveranderd: ' + (basis.accepted ? 'GEACCEPTEERD (goed)' : 'AFGEKEURD op ' + basis.failedChecks.join(',') + ' (FOUT, dan meet de rest niets)'))
+
+let afgekeurd = 0
+let doorgelaten = 0
+let alleenBytes = 0
+
+// De byte-hash (feedbackHashMatchesFile) faalt bij ELKE mutatie, want het bestand is
+// opnieuw geserialiseerd. Dat maakt 12 van 12 een misleidend cijfer: het zegt niet of
+// de INHOUDELIJKE controles de mutatie pakken. Wie dat onderscheid niet maakt, meet
+// zijn eigen serialisatie in plaats van zijn verifieerder. Daarom wordt die ene check
+// hier apart gezet en geteld hoeveel mutaties ALLEEN daardoor sneuvelen.
+const BYTE_CHECK = 'feedbackHashMatchesFile'
+
+for (const m of mutaties) {
+  let uit
+  try {
+    uit = toetsGeval(m.geval, suite)
+  } catch (e) {
+    uit = { accepted: false, failedChecks: ['wierp een fout: ' + String(e.message).slice(0, 40)] }
+  }
+  const inhoudelijk = uit.failedChecks.filter((c) => c !== BYTE_CHECK)
+  if (uit.accepted) {
+    doorgelaten++
+    console.log('  DOORGELATEN      ' + m.naam + '  <- dit is een gat')
+  } else if (inhoudelijk.length === 0) {
+    alleenBytes++
+    console.log('  alleen bytes     ' + m.naam + '  <- geen inhoudelijke controle pakt dit')
+  } else {
+    afgekeurd++
+    console.log('  inhoudelijk      ' + m.naam + '  (' + inhoudelijk.slice(0, 3).join(', ') + ')')
+  }
+}
+console.log('')
+console.log('  ' + afgekeurd + ' van ' + mutaties.length + ' mutaties door een INHOUDELIJKE controle gepakt')
+console.log('  ' + alleenBytes + ' alleen door de byte-hash, ' + doorgelaten + ' helemaal doorgelaten')
+if (alleenBytes > 0) {
+  console.log('')
+  console.log('  Let op wat dat betekent. De byte-hash vergelijkt het bestand met een hash in een')
+  console.log('  on-chain gebeurtenis. Waar die gebeurtenis er niet is, of waar dezelfde partij')
+  console.log('  beide kan zetten, is die controle geen bescherming. Een mutatie die alleen daar')
+  console.log('  op sneuvelt, komt in zo een geval dus wel door.')
+}
+
+// ── deel 2: kunnen wij tegenpartij zijn ──────────────────────────────────────
+
+console.log('')
+console.log('DEEL 2: kunnen wij zelf een tegengetekend bonnetje maken')
+
+const B58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+function base58encode(buf) {
+  let getal = 0n
+  for (const b of buf) getal = getal * 256n + BigInt(b)
+  let uit = ''
+  while (getal > 0n) {
+    uit = B58[Number(getal % 58n)] + uit
+    getal /= 58n
+  }
+  for (const b of buf) {
+    if (b === 0) uit = '1' + uit
+    else break
+  }
+  return uit
+}
+
+/** did:key voor een ed25519 publieke sleutel, multicodec 0xed01. */
+function didKey(publiek) {
+  const raw = publiek.export({ format: 'der', type: 'spki' }).subarray(-32)
+  return 'did:key:z' + base58encode(Buffer.concat([Buffer.from([0xed, 0x01]), raw]))
+}
+
+const paarA = generateKeyPairSync('ed25519')
+const paarB = generateKeyPairSync('ed25519')
+const didA = didKey(paarA.publicKey)
+const didB = didKey(paarB.publicKey)
+console.log('  twee verse sleutels gemaakt, geen sleutel van de koning gebruikt')
+
+// De bytes die een tegenpartij in het echt zou hebben gezien. Hier verzonnen, maar
+// de hashes eroverheen worden echt berekend, want dat is de hele constructie.
+const verzoek = { method: 'POST', url: 'https://api.tokenizen.nl/api/paid/verify-ownership', body: '{"endpoint":"https://example.org/sse"}' }
+const antwoord = { body: '{"ok":true,"method":"dns-txt"}' }
+const u = new URL(verzoek.url)
+const specHash = 'sha256:' + sha256hex(verzoek.method + ' ' + u.pathname + u.search + '\n' + verzoek.body)
+const outputHash = 'sha256:' + sha256hex(antwoord.body)
+
+const kern = {
+  agentA: { id: didA, role: 'requester' },
+  agentB: { id: didB, role: 'worker' },
+  jobId: 'http:tokenizen-conformance-check',
+  receiptVersion: '1.0',
+  task: { capability: 'endpoint.ownership-verification', createdAt: '2026-10-17T10:00:00.000Z', specHash },
+  result: { completedAt: '2026-10-17T10:00:01.000Z', outputHash },
+  settlement: { rail: 'x402', network: 'eip155:84532', amount: '1000' },
+  verification: { method: 'dns-txt' },
+}
+
+const zeven = {}
+for (const k of ['jobId', 'agentA', 'agentB', 'task', 'result', 'settlement', 'verification']) zeven[k] = kern[k]
+const receiptId = 'sha256:' + sha256hex(canoniek(zeven))
+
+const teTekenen = { ...kern, receiptId }
+const inhoud = canoniek(teTekenen)
+const sigA = edSign(null, Buffer.from(inhoud, 'utf8'), paarA.privateKey).toString('base64')
+const sigB = edSign(null, Buffer.from(inhoud, 'utf8'), paarB.privateKey).toString('base64')
+
+const bestand = {
+  agentId: 'did:tokenizen:conformance',
+  agentRegistry: 'eip155:84532',
+  clientAddress: 'eip155:84532:0x3333333333333333333333333333333333333333',
+  createdAt: '2026-10-17T10:00:02.000Z',
+  value: 100,
+  valueDecimals: 0,
+  tag1: 'conformance',
+  tag2: 'x402',
+  inam: { receipt: { ...teTekenen, signatures: { agentA: sigA, agentB: sigB } } },
+}
+const bestandBytes = JSON.stringify(bestand)
+
+const eigenSuite = {
+  suite: 'eigen-rondgang',
+  parties: {
+    requester: { did: didA, erc8004Address: '0x3333333333333333333333333333333333333333' },
+    provider: { did: didB, erc8004Address: '0x4444444444444444444444444444444444444444' },
+  },
+  observed: { request: verzoek, response: antwoord },
+}
+const eigenGeval = {
+  id: 'EIGEN-RONDGANG',
+  feedbackFile: bestandBytes,
+  onchainEvent: {
+    clientAddress: '0x3333333333333333333333333333333333333333',
+    value: 100,
+    feedbackHash: null,
+  },
+}
+
+const oordeel = toetsGeval(eigenGeval, eigenSuite)
+const alleenKeccak = oordeel.failedChecks.length === 1 && oordeel.failedChecks[0] === 'feedbackHashMatchesFile'
+console.log('  ons eigen bonnetje door onze eigen verifieerder: ' + (oordeel.accepted ? 'GEACCEPTEERD' : 'afgekeurd op ' + oordeel.failedChecks.join(', ')))
+if (!oordeel.accepted && alleenKeccak) {
+  console.log('  (alleen de keccak-controle faalt, en die vergelijkt met een on-chain gebeurtenis die hier')
+  console.log('   niet bestaat omdat er niets is uitgezonden. De acht controles die over het BONNETJE gaan,')
+  console.log('   inclusief beide handtekeningen en het herrekende kenmerk, slagen.)')
+}
+
+const kanTegenpartijZijn = oordeel.accepted || alleenKeccak
+console.log('  conclusie: wij ' + (kanTegenpartijZijn ? 'KUNNEN' : 'kunnen NIET') + ' tegenpartij zijn op een echt bonnetje')
+
+// ── samenvatting ─────────────────────────────────────────────────────────────
+
+console.log('')
+console.log('SAMENVATTING')
+console.log('  basislijn geaccepteerd      : ' + (basis.accepted ? 'ja' : 'NEE'))
+console.log('  inhoudelijk gepakt          : ' + afgekeurd + '/' + mutaties.length)
+console.log('  alleen door de byte-hash    : ' + alleenBytes)
+console.log('  doorgelaten                 : ' + doorgelaten)
+console.log('  eigen bonnetje maakbaar     : ' + (kanTegenpartijZijn ? 'ja' : 'NEE'))
+
+// alleenBytes maakt dit NIET rood: het is een eigenschap van de constructie en een
+// bevinding om te melden, geen gebrek in onze code. Doorgelaten wel, want dat is een gat.
+const faalt = !basis.accepted || doorgelaten > 0 || !kanTegenpartijZijn
+if (faalt) {
+  console.log('')
+  console.log('  Dit is een bevinding, niet alleen een cijfer. Repareer het voor er een claim op gebaseerd wordt.')
+}
+process.exitCode = faalt ? 1 : 0

package/bin/cli.mjs

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+// Een commando in plaats van een document.
+//
+// WAAROM DIT BESTAAT. Niemand neemt een meetlat over omdat die in een bestand staat.
+// Mensen nemen hem over als het makkelijkste wat ze kunnen doen een regel is die hun
+// eigen eindpunt nakijkt. Dan is de ladder de norm geworden zonder dat er ooit over
+// gestemd is.
+//
+// BEWUST GEEN NPM-PUBLICATIE NODIG. npx kan een pakket rechtstreeks uit een git-repo
+// draaien, dus dit werkt zonder dat er iets op npm staat:
+//
+//   npx github:holistis/agent-receipt-verify https://een-eindpunt.example/pad
+//
+// Dat is geen trucje maar een echte eigenschap van npx, en het haalt een hele
+// publicatie-stap plus een naamclaim weg. Het betekent ook dat niemand een
+// tussenversie van ons kan uitgeven: wat je draait is wat er in de repo staat.
+//
+// ethers is OPTIONEEL. Zonder ethers kan trede 2 van een eip712-aanbod niet
+// gecontroleerd worden, en dan zegt de uitslag ONGEMETEN in plaats van stil een
+// zwakkere controle te doen. Een jws-aanbod werkt wel zonder ethers, want dat gaat
+// op ingebouwde crypto.
+
+const args = process.argv.slice(2)
+const eerste = args[0]
+
+function gebruik() {
+  console.log('agent-receipt-verify, een onafhankelijke controle op bonnetjes van agent-betalingen')
+  console.log('')
+  console.log('  npx github:holistis/agent-receipt-verify <url> [url ...]')
+  console.log('        meet een x402-eindpunt tegen de ladder in CONFORMANCE.md (trede 0 tot 2,')
+  console.log('        zonder te betalen). Trede 3 tot 5 vereisen een echte afrekening en komen')
+  console.log('        terug als ONGEMETEN, nooit als afgekeurd.')
+  console.log('')
+  console.log('  npx github:holistis/agent-receipt-verify census [uit.json]')
+  console.log('        telt een discovery-index per host in plaats van per resource.')
+  console.log('')
+  console.log('  npx github:holistis/agent-receipt-verify link --receipt=<bestand>')
+  console.log('        zoekt bij een bonnetje van versie 2 de bijbehorende afrekening op de keten.')
+  console.log('')
+  console.log('  npx github:holistis/agent-receipt-verify mcp')
+  console.log('        draait als MCP-server over stdio, zodat een agent deze controle AANROEPT')
+  console.log('        in plaats van hem aanbevolen te krijgen. Twee gereedschappen: controleer een')
+  console.log('        eindpunt voor je betaalt, en link een bonnetje aan een echte afrekening.')
+  console.log('')
+  console.log('  npx github:holistis/agent-receipt-verify inam <vectors.json>')
+  console.log('        controleert countersigned bonnetjes tegen gepubliceerde vectoren.')
+  console.log('')
+  console.log('Wat dit NIET doet: het oordeelt over de VORM van een bonnetje, niet over de')
+  console.log('eerlijkheid van de partij die het afgaf. Zie CONFORMANCE.md voor wat met opzet')
+  console.log('niet gemeten wordt.')
+  console.log('')
+  console.log('  npx github:holistis/agent-receipt-verify kanon')
+  console.log('        cross-check our independent EIP-3009 verifier against the ten published')
+  console.log('        vectors of iamonuwa/kanon, offline, no account and no key.')
+  console.log('')
+  console.log('  npx github:holistis/agent-receipt-verify beleid')
+  console.log('        the same ten vectors under both amount policies, plus the two cases no')
+  console.log('        published vector covers: overpayment, and one nonce across two payers.')
+  console.log('        Those two are the open questions in x402 issue 2725.')
+}
+
+// Het argument bepaalt welke module draait. De modules zijn ook los te draaien en te
+// importeren; dit bestand voegt alleen een ingang toe, geen tweede implementatie,
+// want twee plekken die hetzelfde doen lopen altijd uit elkaar.
+const onderdelen = {
+  mcp: '../src/mcp-server.mjs',
+  census: '../src/x402-discovery-census.mjs',
+  link: '../src/x402-link-onchain.mjs',
+  inam: '../src/inam-countersigned.mjs',
+  liveness: '../src/x402-index-liveness.mjs',
+  kanon: '../src/eip3009-autorisatie.mjs',
+  beleid: '../bench/eip3009-beleid.mjs',
+}
+
+if (!eerste || eerste === '--help' || eerste === '-h' || eerste === 'help') {
+  gebruik()
+  process.exitCode = eerste ? 0 : 2
+} else if (onderdelen[eerste]) {
+  // De doorgegeven argumenten zo neerzetten dat de module zijn eigen cli-tak kiest:
+  // die kijkt naar process.argv[1], dus die moet naar de module zelf wijzen.
+  const { fileURLToPath } = await import('node:url')
+  const pad = fileURLToPath(new URL(onderdelen[eerste], import.meta.url))
+  process.argv = [process.argv[0], pad, ...args.slice(1)]
+  await import(onderdelen[eerste])
+} else if (/^https?:\/\//.test(eerste)) {
+  const { fileURLToPath } = await import('node:url')
+  const pad = fileURLToPath(new URL('../src/x402-conformance-check.mjs', import.meta.url))
+  process.argv = [process.argv[0], pad, ...args]
+  await import('../src/x402-conformance-check.mjs')
+} else {
+  console.log('onbekend: ' + eerste)
+  console.log('')
+  gebruik()
+  process.exitCode = 2
+}

package/examples/receipt-live-base-sepolia-2.json

@@ -0,0 +1,21 @@
+{
+  "note": "The second of two payments with IDENTICAL terms: same payer, same payee, same amount, same resource, minutes apart. Without a commitment these two receipts cannot be told apart. Each one still resolves to its own settlement.",
+  "source": "A real payment to https://api.tokenizen.nl/api/paid/verify-ownership on Base Sepolia, 2026-10-16. Buyer and seller are both us.",
+  "network": "eip155:84532",
+  "asset": "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+  "authorizationSalt": "0x63072ea656fe922bf04c9cefc4275314d695fff01e5b57f6628c8df0252cc5dc",
+  "receipt": {
+    "format": "eip712",
+    "payload": {
+      "version": 2,
+      "network": "eip155:84532",
+      "resourceUrl": "https://api.tokenizen.nl/api/paid/verify-ownership",
+      "payer": "0x87f344b6Ec48A936373d774D3De8649DEEB66Ee1",
+      "issuedAt": 1792187518,
+      "transaction": "",
+      "authorizationMethod": "eip3009",
+      "authorizationCommitment": "0xfecee93e1aec7d6858a218bf324f23e2a4eed07925d8d4542b9662c5026e3d22"
+    },
+    "signature": "0x02f5ba0d2b7928a2dbb1d8845b664a79d38eebcd0a2c4532ed3c6b922051bf8d47c8aafb0520a875a708e3ed480d84a537962ea90d66ce2ee3811f4229aa8b401b"
+  }
+}

package/examples/receipt-live-base-sepolia-3.json

@@ -0,0 +1,21 @@
+{
+  "note": "A third payment on the same terms, so an independent implementation has more than one case to reach the same settlement on. Holds only what section 5.6.4 says a later verifier has: the receipt, its salt, and the asset that was paid.",
+  "source": "A real payment to https://api.tokenizen.nl/api/paid/verify-ownership on Base Sepolia, 2026-10-17. Buyer and seller are both us.",
+  "network": "eip155:84532",
+  "asset": "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+  "authorizationSalt": "0x349ddb90f38a3119817c5fc9cc253a2c20bcbe44aa845302df76889082b314d8",
+  "receipt": {
+    "format": "eip712",
+    "payload": {
+      "version": 2,
+      "network": "eip155:84532",
+      "resourceUrl": "https://api.tokenizen.nl/api/paid/verify-ownership",
+      "payer": "0x87f344b6Ec48A936373d774D3De8649DEEB66Ee1",
+      "issuedAt": 1792188211,
+      "transaction": "",
+      "authorizationMethod": "eip3009",
+      "authorizationCommitment": "0xea8dd34b8beac90f021a4e8d893a689c25249f86947770c8e6647c1cde206008"
+    },
+    "signature": "0x5b3a70cce6978ab44e51828b5ebbc55522e98b015045d94559d369420698da3b5309b28050dcb00ce14d65c8b230a273f8ff5ebff6410c6ae2a308e422ed5a611b"
+  }
+}

package/examples/receipt-live-base-sepolia.json

@@ -0,0 +1,21 @@
+{
+  "note": "The first of two payments with IDENTICAL terms. This file holds exactly what section 5.6.4 says a later verifier has: the receipt, its salt, and the asset that was paid. The settlement nonce and transaction hash are deliberately NOT here; finding them is what the tool has to do.",
+  "source": "A real payment to https://api.tokenizen.nl/api/paid/verify-ownership on Base Sepolia, 2026-10-16. Buyer and seller are both us, so this proves the chain closes end to end, not that anyone else uses it.",
+  "network": "eip155:84532",
+  "asset": "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+  "authorizationSalt": "0xea85b2473363fd8fff1ccdd7f8638be8b47c7c05023e3e2e3f81bebb085ba2ad",
+  "receipt": {
+    "format": "eip712",
+    "payload": {
+      "version": 2,
+      "network": "eip155:84532",
+      "resourceUrl": "https://api.tokenizen.nl/api/paid/verify-ownership",
+      "payer": "0x87f344b6Ec48A936373d774D3De8649DEEB66Ee1",
+      "issuedAt": 1792187030,
+      "transaction": "",
+      "authorizationMethod": "eip3009",
+      "authorizationCommitment": "0x5c35a61a09a566a9c284fad18a70ac2ddfff34d01d2a3ce776ce94e8d5b38ff8"
+    },
+    "signature": "0x78615cb22986af0aad6e08b74ca78773bb58ece21660e84e4b35b3e5c1841b0075238ca9bfdf0f969ad3f2903af8f391fafd1b3fc7ebbf1fb5c949a3948fccde1c"
+  }
+}

package/package.json

@@ -1,6 +1,63 @@
 {
   "name": "agent-receipt-verify",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.2",
+  "description": "Checks x402 endpoint conformance before an agent pays, and links the receipt to its settlement.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "engines": {
+    "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",
+    "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",
+    "census": "node src/x402-discovery-census.mjs",
+    "liveness": "node src/x402-index-liveness.mjs",
+    "poortwachters": "node src/x402-poortwachters.mjs",
+    "metingen-bundel": "node src/x402-metingen-bundel.mjs",
+    "mcp": "node src/mcp-server.mjs",
+    "bundel": "node tools/bundel-bouw.mjs build/bundle",
+    "kanon": "node src/eip3009-autorisatie.mjs --vectoren",
+    "bench-eip3009": "node bench/eip3009-beleid.mjs"
+  },
+  "optionalDependencies": {
+    "ethers": "^6.17.0"
+  },
+  "bin": {
+    "agent-receipt-verify": "bin/cli.mjs"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "profiles/",
+    "vectors/",
+    "examples/",
+    "NOTICE",
+    "CONFORMANCE.md",
+    "README.md",
+    "bench/",
+    "tools/"
+  ],
+  "author": "Abdellah Ouadoudi (https://github.com/holistis)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/holistis/agent-receipt-verify.git"
+  },
+  "homepage": "https://github.com/holistis/agent-receipt-verify#readme",
+  "bugs": {
+    "url": "https://github.com/holistis/agent-receipt-verify/issues"
+  },
+  "keywords": [
+    "x402",
+    "mcp",
+    "model-context-protocol",
+    "conformance",
+    "receipts",
+    "agent-payments",
+    "eip-3009",
+    "erc-8004",
+    "base",
+    "verification"
+  ]
+}