agent-receipt-verify 0.2.2 → 0.2.4

package/tools/bouw-afrekening-vectoren.mjs

@@ -0,0 +1,273 @@
+#!/usr/bin/env node
+// Bouwt testvectoren voor de helft NA het betalen: hoort dit bonnetje bij die ene
+// afrekening?
+//
+// WAAROM DEZE ER ZIJN. De gepubliceerde vectoren van iamonuwa/kanon dekken de
+// AUTORISATIE van een koper voor de afrekening. Niemand heeft vectoren gepubliceerd
+// voor de stap erna. In x402#3396 zei de auteur van die vectoren op 2026-10-17
+// letterlijk: "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 bestand maakt
+// precies dat, in zijn vorm, met dat veld.
+//
+// DE SPLITSING DIE HIJ VROEG, en die is inhoudelijk het hele punt. Een bonnetje aan een
+// afrekening binden bestaat uit twee stappen met heel verschillende eisen:
+//
+//   1. VIND de kandidaat-nonces die deze betaler in dit venster verbruikte.
+//      Dat vereist een ketenlezing. Niet reproduceerbaar zonder RPC, en de uitkomst
+//      hangt af van hoe ver je terugkijkt.
+//   2. OPEN het commitment op precies een van die kandidaten.
+//      Dat is pure rekenkunde: sha256 over tag, methode, asset, autorisator,
+//      identifier en zout. Offline, deterministisch, en voor altijd reproduceerbaar.
+//
+// Stap 2 is waar de spec iets beweert, en stap 2 heeft GEEN keten nodig zodra je de
+// kandidaten meegeeft. Daarom draagt elke vector hier `requires_chain_read`, en zijn de
+// offline vectoren degene waar een vreemde iets aan heeft.
+//
+// ALLE DATA IS ECHT. De bonnetjes komen uit echte betalingen op Base Sepolia aan
+// https://api.tokenizen.nl/api/paid/verify-ownership. De nonces en transactiehashes
+// zijn door onze eigen linker op de keten gevonden. Koper en verkoper zijn allebei wij,
+// dus dit bewijst dat de keten sluit, niet dat iemand anders hem gebruikt.
+//
+// DEZE GENERATOR WEIGERT TE LIEGEN. Voor elke positieve vector wordt het commitment
+// opnieuw berekend uit de losse velden en vergeleken met wat in het ondertekende
+// bonnetje staat. Klopt dat niet, dan schrijft hij niets en faalt hij luid. Een
+// vectorbestand dat zichzelf niet opent is erger dan geen vectorbestand, want iedereen
+// die het gebruikt bouwt op een fout.
+//
+// Gebruik: node tools/bouw-afrekening-vectoren.mjs [--droog]
+
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { berekenCommitment } from '../src/x402-offer-receipt.mjs'
+
+const WORTEL = fileURLToPath(new URL('..', import.meta.url))
+const UIT = path.join(WORTEL, 'vectors', 'settlement-link')
+
+// De drie echte betalingen, met de afrekening die onze linker op de keten vond.
+// De nonce staat hier NIET omdat wij hem kozen, maar omdat hij gevonden is; de
+// controle hieronder bewijst dat hij bij dit bonnetje hoort.
+const ECHT = [
+  {
+    bestand: 'receipt-live-base-sepolia.json',
+    nonce: '0x1120412c78ea1b2e8bf9eacfc3264c71a23ecd9b1fa579eb16030693344d5dfe',
+    tx: '0xed87b09bfb20a8c8b69908e163fcea6432d193d389640c0465afcb5561dfeb30',
+    kandidaten: 2,
+  },
+  {
+    bestand: 'receipt-live-base-sepolia-2.json',
+    nonce: '0x515895dfac6f148a4cfdf5c4f8266b7859dbd6534cdf77104b1be9f484eb5005',
+    tx: '0x2898d0ceb97ddf60af98e19c94fc0adddbdf1e64f9032e62454085e37acfe36b',
+    kandidaten: 3,
+  },
+  {
+    bestand: 'receipt-live-base-sepolia-3.json',
+    nonce: '0x4b133bbec3ce0d8177a9010784faedb459f04384b45316bb526a5f96c90a70de',
+    tx: '0x2a9e95d63a5af8210767baa69143b364dad51caffc29a152c77e03bc508d7199',
+    kandidaten: 2,
+  },
+]
+
+const lees = (b) => JSON.parse(fs.readFileSync(path.join(WORTEL, 'examples', b), 'utf8'))
+
+function basis(id, beschrijving, encodes) {
+  return {
+    id,
+    schema_version: '3.0.0',
+    protocol: 'x402',
+    scheme: 'exact',
+    network: 'eip155:84532',
+    asset_transfer_method: 'eip3009',
+    encodes,
+    provenance: [
+      'x402 offer-receipt extension section 5.6.4, as proposed in pull request 3827 at commit 0e492d6 and not on main',
+      'EIP-3009',
+    ],
+    description: beschrijving,
+  }
+}
+
+const vectoren = []
+const fouten = []
+
+for (const e of ECHT) {
+  const bron = lees(e.bestand)
+  const p = bron.receipt.payload
+  const betaler = p.payer
+
+  // DE CONTROLE DIE DEZE GENERATOR EERLIJK HOUDT. Herbereken het commitment uit de
+  // losse velden. Opent het niet op de nonce die wij hier opschrijven, dan is onze
+  // toewijzing fout en mag er niets geschreven worden.
+  const herberekend = berekenCommitment({
+    method: 'eip3009',
+    asset: bron.asset,
+    authorizer: betaler,
+    identifier: e.nonce,
+    salt: bron.authorizationSalt,
+  })
+  if (String(herberekend).toLowerCase() !== String(p.authorizationCommitment).toLowerCase()) {
+    fouten.push(`${e.bestand}: het commitment opent NIET op de opgegeven nonce. ` +
+      `berekend ${herberekend}, in het bonnetje ${p.authorizationCommitment}`)
+    continue
+  }
+
+  const kort = e.bestand.replace('receipt-live-base-sepolia', 'live').replace('.json', '')
+
+  // 1. De offline positieve: de kandidaten zijn MEEGEGEVEN, dus geen keten nodig.
+  vectoren.push({
+    ...basis(
+      `x402-evm-settlement-link-opens-${kort}`,
+      'A version 2 receipt whose authorizationCommitment opens on exactly one of the candidate nonces supplied with it. No chain access is needed because the candidates are given; this is the arithmetic half of section 5.6.4.',
+      'Receipt-to-settlement binding verified offline against a supplied candidate set.',
+    ),
+    requires_chain_read: false,
+    input: {
+      receipt: bron.receipt,
+      authorizationSalt: bron.authorizationSalt,
+      asset: bron.asset,
+      candidates: [{ authorizer: betaler, nonce: e.nonce }],
+    },
+    context: {
+      note: 'Real payment on Base Sepolia to https://api.tokenizen.nl/api/paid/verify-ownership. Buyer and seller are the same party, which proves the chain closes end to end and nothing about adoption.',
+      settlement_transaction: e.tx,
+    },
+    expected: { linked: true, outcome: 'LINKED', identifier: e.nonce },
+  })
+
+  // 2. De offline negatieve die het meest zegt: het zout van een ANDER bonnetje.
+  //    Dit is waar de hele constructie op rust, want zonder het zout zouden twee
+  //    identieke betalingen niet uit elkaar te houden zijn.
+  const ander = ECHT.find((x) => x.bestand !== e.bestand)
+  const anderBron = lees(ander.bestand)
+  vectoren.push({
+    ...basis(
+      `x402-evm-settlement-link-wrong-salt-${kort}`,
+      'The same receipt and the same candidate, but the salt of a different payment. The commitment must not open. This is the case the whole construction rests on: without the salt, two payments with identical terms could not be told apart.',
+      'A salt that belongs to another payment must not open this commitment.',
+    ),
+    requires_chain_read: false,
+    input: {
+      receipt: bron.receipt,
+      authorizationSalt: anderBron.authorizationSalt,
+      asset: bron.asset,
+      candidates: [{ authorizer: betaler, nonce: e.nonce }],
+    },
+    context: { note: 'Both salts are real and come from two separate payments with identical terms.' },
+    expected: { linked: false, outcome: 'NOT_LINKED' },
+  })
+
+  // 3. De offline negatieve met de nonce van een andere betaling.
+  vectoren.push({
+    ...basis(
+      `x402-evm-settlement-link-wrong-nonce-${kort}`,
+      'The correct receipt and salt, but a candidate nonce that belongs to a different settlement by the same payer. The commitment must not open on it.',
+      'A candidate that is not this payment must not satisfy the commitment.',
+    ),
+    requires_chain_read: false,
+    input: {
+      receipt: bron.receipt,
+      authorizationSalt: bron.authorizationSalt,
+      asset: bron.asset,
+      candidates: [{ authorizer: betaler, nonce: ander.nonce }],
+    },
+    context: { note: 'Both nonces were really consumed by this payer; only one belongs to this receipt.' },
+    expected: { linked: false, outcome: 'NOT_LINKED' },
+  })
+}
+
+// 4. De vector die de twee identieke betalingen naast elkaar zet. Dit is het geval dat
+//    een lezer overtuigt, want hier zijn de voorwaarden letterlijk gelijk.
+if (ECHT.length >= 2 && fouten.length === 0) {
+  const a = lees(ECHT[0].bestand)
+  const b = lees(ECHT[1].bestand)
+  vectoren.push({
+    ...basis(
+      'x402-evm-settlement-link-two-identical-payments',
+      'Two payments with identical terms (same payer, same asset, same amount, same resource) each open on their own settlement and on no other. Given both candidate sets together, each receipt selects exactly one.',
+      'Disambiguation of two otherwise indistinguishable payments.',
+    ),
+    requires_chain_read: false,
+    input: {
+      receipts: [
+        { receipt: a.receipt, authorizationSalt: a.authorizationSalt, asset: a.asset },
+        { receipt: b.receipt, authorizationSalt: b.authorizationSalt, asset: b.asset },
+      ],
+      candidates: [
+        { authorizer: a.receipt.payload.payer, nonce: ECHT[0].nonce },
+        { authorizer: b.receipt.payload.payer, nonce: ECHT[1].nonce },
+      ],
+    },
+    context: {
+      note: 'Both are real payments on Base Sepolia with the same terms. Without the salt these two could not be told apart by any later reader.',
+      settlements: [ECHT[0].tx, ECHT[1].tx],
+    },
+    expected: {
+      linked: true,
+      outcome: 'LINKED',
+      mapping: [
+        { receipt_index: 0, identifier: ECHT[0].nonce },
+        { receipt_index: 1, identifier: ECHT[1].nonce },
+      ],
+    },
+  })
+}
+
+// 5. De uitkomst die kanon nog niet kent, en die wij juist wel nodig hebben: een
+//    controle die NIET KON DRAAIEN is geen afkeuring. Dit vector beschrijft dat geval
+//    zonder een keten nodig te hebben: er zijn geen kandidaten verkregen.
+vectoren.push({
+  ...basis(
+    'x402-evm-settlement-link-no-candidates-not-measured',
+    'No candidate set could be obtained, for example because no chain access was available or the lookup window produced nothing. The correct answer is NOT_MEASURED and explicitly not NOT_LINKED: a check that could not run is not a receipt that fails. This is the third outcome a two-valued vocabulary cannot express.',
+    'An incomplete check must be distinguishable from a failed one.',
+  ),
+  requires_chain_read: false,
+  input: {
+    receipt: lees(ECHT[0].bestand).receipt,
+    authorizationSalt: lees(ECHT[0].bestand).authorizationSalt,
+    asset: lees(ECHT[0].bestand).asset,
+    candidates: null,
+  },
+  context: { note: 'candidates is null rather than an empty list, and the two mean different things: null is "we did not obtain a list", empty is "we obtained a list and it was empty".' },
+  expected: { linked: null, outcome: 'NOT_MEASURED' },
+})
+
+// 6. En het geval dat wel een keten nodig heeft, expliciet als zodanig gemarkeerd.
+vectoren.push({
+  ...basis(
+    'x402-evm-settlement-link-find-candidates-onchain',
+    'The full section 5.6.4 walk, starting from only the receipt, the salt and the asset: find the nonces this payer consumed in a window, then open the commitment on exactly one. Requires an archive-capable RPC for Base Sepolia. Included so the chain-dependent half is named rather than hidden, but a runner without RPC access should skip it and report that, not fail it.',
+    'The chain-reading half of the walk, marked as such.',
+  ),
+  requires_chain_read: true,
+  input: {
+    receipt: lees(ECHT[0].bestand).receipt,
+    authorizationSalt: lees(ECHT[0].bestand).authorizationSalt,
+    asset: lees(ECHT[0].bestand).asset,
+  },
+  context: {
+    rpc: 'any Base Sepolia endpoint that serves eth_getLogs over the window around the receipt issuedAt',
+    expected_candidate_count: ECHT[0].kandidaten,
+    note: 'The candidate count is what the window actually produced on 2026-10-18 and will grow as this payer makes more payments; a runner should assert "exactly one opens", not the count.',
+  },
+  expected: { linked: true, outcome: 'LINKED', identifier: ECHT[0].nonce, settlement_transaction: ECHT[0].tx },
+})
+
+if (fouten.length) {
+  console.error('GEEN ENKELE VECTOR GESCHREVEN. De controle faalde:')
+  for (const f of fouten) console.error('  ' + f)
+  process.exitCode = 1
+} else {
+  const droog = process.argv.includes('--droog')
+  if (!droog) {
+    fs.mkdirSync(UIT, { recursive: true })
+    for (const v of vectoren) {
+      fs.writeFileSync(path.join(UIT, v.id.replace('x402-evm-settlement-link-', '') + '.json'), JSON.stringify(v, null, 2) + '\n')
+    }
+  }
+  const offline = vectoren.filter((v) => !v.requires_chain_read).length
+  console.log(`${vectoren.length} vectoren${droog ? ' (droog, niets geschreven)' : ' geschreven naar vectors/settlement-link/'}`)
+  console.log(`  offline, zonder keten te lezen : ${offline}`)
+  console.log(`  met ketenlezing, gemarkeerd    : ${vectoren.length - offline}`)
+  console.log(`  elk commitment opnieuw berekend en gelijk bevonden aan het ondertekende bonnetje`)
+}

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/settlement-link/find-candidates-onchain.json

@@ -0,0 +1,44 @@
+{
+  "id": "x402-evm-settlement-link-find-candidates-onchain",
+  "schema_version": "3.0.0",
+  "protocol": "x402",
+  "scheme": "exact",
+  "network": "eip155:84532",
+  "asset_transfer_method": "eip3009",
+  "encodes": "The chain-reading half of the walk, marked as such.",
+  "provenance": [
+    "x402 offer-receipt extension section 5.6.4, as proposed in pull request 3827 at commit 0e492d6 and not on main",
+    "EIP-3009"
+  ],
+  "description": "The full section 5.6.4 walk, starting from only the receipt, the salt and the asset: find the nonces this payer consumed in a window, then open the commitment on exactly one. Requires an archive-capable RPC for Base Sepolia. Included so the chain-dependent half is named rather than hidden, but a runner without RPC access should skip it and report that, not fail it.",
+  "requires_chain_read": true,
+  "input": {
+    "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"
+    },
+    "authorizationSalt": "0xea85b2473363fd8fff1ccdd7f8638be8b47c7c05023e3e2e3f81bebb085ba2ad",
+    "asset": "0x036CbD53842c5426634e7929541eC2318f3dCF7e"
+  },
+  "context": {
+    "rpc": "any Base Sepolia endpoint that serves eth_getLogs over the window around the receipt issuedAt",
+    "expected_candidate_count": 2,
+    "note": "The candidate count is what the window actually produced on 2026-10-18 and will grow as this payer makes more payments; a runner should assert \"exactly one opens\", not the count."
+  },
+  "expected": {
+    "linked": true,
+    "outcome": "LINKED",
+    "identifier": "0x1120412c78ea1b2e8bf9eacfc3264c71a23ecd9b1fa579eb16030693344d5dfe",
+    "settlement_transaction": "0xed87b09bfb20a8c8b69908e163fcea6432d193d389640c0465afcb5561dfeb30"
+  }
+}

package/vectors/settlement-link/no-candidates-not-measured.json

@@ -0,0 +1,41 @@
+{
+  "id": "x402-evm-settlement-link-no-candidates-not-measured",
+  "schema_version": "3.0.0",
+  "protocol": "x402",
+  "scheme": "exact",
+  "network": "eip155:84532",
+  "asset_transfer_method": "eip3009",
+  "encodes": "An incomplete check must be distinguishable from a failed one.",
+  "provenance": [
+    "x402 offer-receipt extension section 5.6.4, as proposed in pull request 3827 at commit 0e492d6 and not on main",
+    "EIP-3009"
+  ],
+  "description": "No candidate set could be obtained, for example because no chain access was available or the lookup window produced nothing. The correct answer is NOT_MEASURED and explicitly not NOT_LINKED: a check that could not run is not a receipt that fails. This is the third outcome a two-valued vocabulary cannot express.",
+  "requires_chain_read": false,
+  "input": {
+    "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"
+    },
+    "authorizationSalt": "0xea85b2473363fd8fff1ccdd7f8638be8b47c7c05023e3e2e3f81bebb085ba2ad",
+    "asset": "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+    "candidates": null
+  },
+  "context": {
+    "note": "candidates is null rather than an empty list, and the two mean different things: null is \"we did not obtain a list\", empty is \"we obtained a list and it was empty\"."
+  },
+  "expected": {
+    "linked": null,
+    "outcome": "NOT_MEASURED"
+  }
+}

package/vectors/settlement-link/opens-live-2.json

@@ -0,0 +1,48 @@
+{
+  "id": "x402-evm-settlement-link-opens-live-2",
+  "schema_version": "3.0.0",
+  "protocol": "x402",
+  "scheme": "exact",
+  "network": "eip155:84532",
+  "asset_transfer_method": "eip3009",
+  "encodes": "Receipt-to-settlement binding verified offline against a supplied candidate set.",
+  "provenance": [
+    "x402 offer-receipt extension section 5.6.4, as proposed in pull request 3827 at commit 0e492d6 and not on main",
+    "EIP-3009"
+  ],
+  "description": "A version 2 receipt whose authorizationCommitment opens on exactly one of the candidate nonces supplied with it. No chain access is needed because the candidates are given; this is the arithmetic half of section 5.6.4.",
+  "requires_chain_read": false,
+  "input": {
+    "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"
+    },
+    "authorizationSalt": "0x63072ea656fe922bf04c9cefc4275314d695fff01e5b57f6628c8df0252cc5dc",
+    "asset": "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+    "candidates": [
+      {
+        "authorizer": "0x87f344b6Ec48A936373d774D3De8649DEEB66Ee1",
+        "nonce": "0x515895dfac6f148a4cfdf5c4f8266b7859dbd6534cdf77104b1be9f484eb5005"
+      }
+    ]
+  },
+  "context": {
+    "note": "Real payment on Base Sepolia to https://api.tokenizen.nl/api/paid/verify-ownership. Buyer and seller are the same party, which proves the chain closes end to end and nothing about adoption.",
+    "settlement_transaction": "0x2898d0ceb97ddf60af98e19c94fc0adddbdf1e64f9032e62454085e37acfe36b"
+  },
+  "expected": {
+    "linked": true,
+    "outcome": "LINKED",
+    "identifier": "0x515895dfac6f148a4cfdf5c4f8266b7859dbd6534cdf77104b1be9f484eb5005"
+  }
+}