agent-receipt-verify 0.2.1 → 0.2.3

package/README.md

@@ -2,9 +2,9 @@
 
 Independent verification of payment- and outcome-proof receipts used by AI agents.
 
-An agent economy has two kinds of receipt. One says **who was allowed to act**
-(delegation: UCAN, Authproof, Agent Passport). The other says **what was paid for
-and whether the output matches** (settlement and outcome: x402 offer-receipt, INAM
+An agent economy has two kinds of receipt. One says who was allowed to act
+(delegation: UCAN, Authproof, Agent Passport). The other says what was paid for
+and whether the output matches (settlement and outcome: x402 offer-receipt, INAM
 countersigned receipts, and the proofs ERC-8004 consumers count).
 
 `receipt-commons/receipt-interop` covers the first kind. This covers the second.
@@ -90,6 +90,23 @@ settlements, starting from the receipt, the salt and the asset as §5.6.4
 requires. Their result and ours are in
 [x402#3827](https://github.com/x402-foundation/x402/pull/3827#issuecomment-6230063003).
 
+## Recompute it yourself, without an account
+
+Two of the cross-checks run offline from a single command, so nothing here has to be
+taken on trust:
+
+```sh
+npx -y agent-receipt-verify kanon
+npx -y agent-receipt-verify beleid
+```
+
+The first checks our EIP-3009 verifier against the ten published vectors of
+iamonuwa/kanon. The second exists because agreement can hide a question: all ten of
+those vectors cover underpayment only, so they say nothing about overpayment, or
+about one nonce reused across two payers. Those are the two open questions in
+[x402#2725](https://github.com/x402-foundation/x402/issues/2725), and the command
+prints exactly where the two possible answers diverge and where they do not.
+
 ## Linking a receipt to its settlement
 
 A receipt with an empty `transaction` field can be matched to a payment only by
@@ -170,7 +187,7 @@ not show that anyone else is using it.
 
 ## Honest limits
 
-The format checks test the **form** of a receipt: signatures, content addressing,
+The format checks test the form of a receipt: signatures, content addressing,
 and whether the hashes match the bytes a counterparty observed. They do not tell
 you whether an operator is honest, or whether a registry holds a receipt as
 finalized.

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

@@ -52,6 +52,16 @@ function gebruik() {
   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.')
+  console.log('')
+  console.log('  npx github:holistis/agent-receipt-verify link-vectors')
+  console.log('        twelve vectors for the half AFTER paying: does this receipt belong to')
+  console.log('        that one settlement? Eleven run offline, the chain-reading one is')
+  console.log('        marked and skipped rather than failed.')
 }
 
 // Het argument bepaalt welke module draait. De modules zijn ook los te draaien en te
@@ -64,6 +74,8 @@ const onderdelen = {
   inam: '../src/inam-countersigned.mjs',
   liveness: '../src/x402-index-liveness.mjs',
   kanon: '../src/eip3009-autorisatie.mjs',
+  beleid: '../bench/eip3009-beleid.mjs',
+  'link-vectors': '../src/settlement-link-vectors.mjs',
 }
 
 if (!eerste || eerste === '--help' || eerste === '-h' || eerste === 'help') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-receipt-verify",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "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",
+    "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",
     "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",
@@ -18,7 +18,9 @@
     "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"
+    "kanon": "node src/eip3009-autorisatie.mjs --vectoren",
+    "bench-eip3009": "node bench/eip3009-beleid.mjs",
+    "link-vectors": "node src/settlement-link-vectors.mjs"
   },
   "optionalDependencies": {
     "ethers": "^6.17.0"
@@ -35,6 +37,7 @@
     "NOTICE",
     "CONFORMANCE.md",
     "README.md",
+    "bench/",
     "tools/"
   ],
   "author": "Abdellah Ouadoudi (https://github.com/holistis)",

package/src/eip3009-autorisatie.mjs

@@ -141,19 +141,52 @@ export async function beoordeelAutorisatie(input, context = {}) {
     return { valid: false, reason_code: 'SIGNER_MISMATCH', hersteld }
   }
 
-  // 5. Het bedrag, pas NA de handtekening: een authentiek ondertekende onderbetaling.
-  if (BigInt(auth.value ?? 0) < BigInt(accepted.amount ?? 0)) {
-    return { valid: false, reason_code: 'AMOUNT_INSUFFICIENT' }
+  // 5. Het bedrag, pas NA de handtekening: een authentiek ondertekende afwijking.
+  //
+  // DE STANDAARD NEEMT HIER GEEN POSITIE IN, DUS WIJ MAKEN DE KEUZE ZICHTBAAR. Twee
+  // referentie-implementaties eisen GELIJKHEID en wijzen dus ook te veel betalen af:
+  // go/mechanisms/evm/exact/facilitator/eip3009.go regel 65 (`Cmp(requiredValue) != 0`,
+  // fout ErrAuthorizationValueMismatch) en python/x402/mechanisms/evm/exact/
+  // facilitator.py regel 235 (`!=`), met op regel 168 de eigen zin "Amount exactly
+  // matches requirements.amount". Onze eerste versie liet te veel betalen toe en zou
+  // dus op dat ene geval van hen afwijken, terwijl geen enkele gepubliceerde vector
+  // het dekt. Daarom staat 'exact' nu als standaard, is 'at-least' een bewuste keuze,
+  // en draagt de uitslag ALTIJD welke van de twee gebruikt is.
+  const beleid = context.amountPolicy === 'at-least' ? 'at-least' : 'exact'
+  const betaald = BigInt(auth.value ?? 0)
+  const gevraagd = BigInt(accepted.amount ?? 0)
+  const bedragFout = beleid === 'exact' ? betaald !== gevraagd : betaald < gevraagd
+  if (bedragFout) {
+    return { valid: false, reason_code: 'AMOUNT_INSUFFICIENT', amountPolicy: beleid }
   }
 
-  // 6. Is deze nonce al verbruikt. Dit is toestand van buiten, geen eigenschap van de
-  // autorisatie, en komt daarom uit de context in plaats van uit de betaling.
-  const gezien = (context.seen_nonces ?? []).map((n) => String(n).toLowerCase())
-  if (gezien.includes(String(auth.nonce).toLowerCase())) {
+  // 6. Is deze nonce al verbruikt, PER BETALER en niet over iedereen heen.
+  //
+  // EIP-3009 houdt dit zelf per adres bij: `mapping(address => mapping(bytes32 =>
+  // bool))`, en de leesfunctie heet `authorizationState(address authorizer, bytes32
+  // nonce)`. De spec zegt er bovendien bij dat nonces willekeurige 32 bytes zijn,
+  // uniek per adres, en juist geen volgnummers. Een verifieerder die EEN lijst
+  // bijhoudt zonder onderscheid naar betaler is dus STRENGER dan de keten zelf: hij
+  // zou een geldige betaling van een andere partij weigeren die toevallig dezelfde
+  // 32 bytes koos. Onze eerste versie deed precies dat.
+  //
+  // Twee vormen worden aanvaard. Een platte lijst hoort bij DEZE betaler, want zo
+  // gebruiken de gepubliceerde vectoren hem. Een object met het adres als sleutel is
+  // de nauwkeurige vorm en komt overeen met wat het token-contract doet.
+  const betaler = String(auth.from ?? '').toLowerCase()
+  const bron = context.seen_nonces
+  let gezien = []
+  if (Array.isArray(bron)) gezien = bron
+  else if (bron && typeof bron === 'object') {
+    for (const [adres, lijst] of Object.entries(bron)) {
+      if (String(adres).toLowerCase() === betaler) gezien = lijst ?? []
+    }
+  }
+  if (gezien.map((n) => String(n).toLowerCase()).includes(String(auth.nonce).toLowerCase())) {
     return { valid: false, reason_code: 'NONCE_REPLAY' }
   }
 
-  return { valid: true, reason_code: 'VALID', ondertekenaar: hersteld }
+  return { valid: true, reason_code: 'VALID', ondertekenaar: hersteld, amountPolicy: beleid }
 }
 
 /** Een hele vector beoordelen, met zijn eigen context en doelnetwerk. */