agent-receipt-verify 0.2.7 → 0.2.8

package/bin/cli.mjs

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

package/package.json

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

package/src/attempt-identity.mjs

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

package/vectors/attempt-identity/all-paths-agree.json

@@ -0,0 +1,126 @@
+{
+  "schema_version": "3.0.0",
+  "verifies": "attempt-identity",
+  "requires_chain_read": false,
+  "provenance": [
+    "x402 specification v2 section 5.5, Settlement and Refusal Identity Invariant, as proposed in x402-foundation/x402 pull request 3776 on branch spec/settlement-refusal-identity-invariant and not on main",
+    "the gap these cover was named by ruiruii in erc-8004/erc-8004-contracts#99 on 18 October 2026: each of the four evidence layers depends on an attempt identity that none of them defines",
+    "section 5.5 closes by referring to \"the normative conformance tests in the specification repository for the required negative cases\"; at the time of writing those did not exist"
+  ],
+  "id": "attempt-identity-all-paths-agree",
+  "clause": "all-paths-same-artifact",
+  "encodes": "The positive control for section 5.5: four named paths, one identity, derived once at ingress.",
+  "description": "All four paths named in the clause resolve the same identity artifact, and each reports that it took that value from the ingress snapshot rather than re-deriving it. Without this vector the set would contain only refusals, which proves the harness says no and nothing about whether it can say yes.",
+  "input": {
+    "ingress": {
+      "snapshot": {
+        "method": "POST",
+        "path": "/api/paid/verify-ownership",
+        "query": "",
+        "body": {
+          "endpoint": "https://example.com/api/health",
+          "ownerAddress": "0x1111111111111111111111111111111111111111",
+          "method": "dns-txt"
+        },
+        "payTo": "0x2888f36548a900b9b08d584524e1f73bc563ec26",
+        "asset": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+        "network": "eip155:8453",
+        "amount": "1000",
+        "scheme": "exact"
+      },
+      "identity": "2ed52a521f9762c3adc24c8048a4ee04a3796202a34c335585fc953e15c97196"
+    },
+    "paths": [
+      {
+        "path": "challenge-quote",
+        "snapshot": {
+          "method": "POST",
+          "path": "/api/paid/verify-ownership",
+          "query": "",
+          "body": {
+            "endpoint": "https://example.com/api/health",
+            "ownerAddress": "0x1111111111111111111111111111111111111111",
+            "method": "dns-txt"
+          },
+          "payTo": "0x2888f36548a900b9b08d584524e1f73bc563ec26",
+          "asset": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+          "network": "eip155:8453",
+          "amount": "1000",
+          "scheme": "exact"
+        },
+        "identity": "2ed52a521f9762c3adc24c8048a4ee04a3796202a34c335585fc953e15c97196",
+        "derived_from": "ingress-snapshot"
+      },
+      {
+        "path": "settle",
+        "snapshot": {
+          "method": "POST",
+          "path": "/api/paid/verify-ownership",
+          "query": "",
+          "body": {
+            "endpoint": "https://example.com/api/health",
+            "ownerAddress": "0x1111111111111111111111111111111111111111",
+            "method": "dns-txt"
+          },
+          "payTo": "0x2888f36548a900b9b08d584524e1f73bc563ec26",
+          "asset": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+          "network": "eip155:8453",
+          "amount": "1000",
+          "scheme": "exact"
+        },
+        "identity": "2ed52a521f9762c3adc24c8048a4ee04a3796202a34c335585fc953e15c97196",
+        "derived_from": "ingress-snapshot"
+      },
+      {
+        "path": "refusal",
+        "snapshot": {
+          "method": "POST",
+          "path": "/api/paid/verify-ownership",
+          "query": "",
+          "body": {
+            "endpoint": "https://example.com/api/health",
+            "ownerAddress": "0x1111111111111111111111111111111111111111",
+            "method": "dns-txt"
+          },
+          "payTo": "0x2888f36548a900b9b08d584524e1f73bc563ec26",
+          "asset": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+          "network": "eip155:8453",
+          "amount": "1000",
+          "scheme": "exact"
+        },
+        "identity": "2ed52a521f9762c3adc24c8048a4ee04a3796202a34c335585fc953e15c97196",
+        "derived_from": "ingress-snapshot"
+      },
+      {
+        "path": "replay-lookup",
+        "snapshot": {
+          "method": "POST",
+          "path": "/api/paid/verify-ownership",
+          "query": "",
+          "body": {
+            "endpoint": "https://example.com/api/health",
+            "ownerAddress": "0x1111111111111111111111111111111111111111",
+            "method": "dns-txt"
+          },
+          "payTo": "0x2888f36548a900b9b08d584524e1f73bc563ec26",
+          "asset": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+          "network": "eip155:8453",
+          "amount": "1000",
+          "scheme": "exact"
+        },
+        "identity": "2ed52a521f9762c3adc24c8048a4ee04a3796202a34c335585fc953e15c97196",
+        "derived_from": "ingress-snapshot"
+      }
+    ],
+    "identity_field": {
+      "name": "attempt_id",
+      "bound_to": "ingress-snapshot"
+    }
+  },
+  "expected": {
+    "outcome": "PASS"
+  },
+  "limits": [
+    "This says the four paths agree. It says nothing about whether the identity was computed over the right fields."
+  ]
+}

package/vectors/attempt-identity/changed-amount-announced.json

@@ -0,0 +1,86 @@
+{
+  "schema_version": "3.0.0",
+  "verifies": "attempt-identity",
+  "requires_chain_read": false,
+  "provenance": [
+    "x402 specification v2 section 5.5, Settlement and Refusal Identity Invariant, as proposed in x402-foundation/x402 pull request 3776 on branch spec/settlement-refusal-identity-invariant and not on main",
+    "the gap these cover was named by ruiruii in erc-8004/erc-8004-contracts#99 on 18 October 2026: each of the four evidence layers depends on an attempt identity that none of them defines",
+    "section 5.5 closes by referring to \"the normative conformance tests in the specification repository for the required negative cases\"; at the time of writing those did not exist"
+  ],
+  "id": "attempt-identity-changed-amount-announced",
+  "clause": "changed-request-different-artifact",
+  "encodes": "The positive control for the changed-request half: new identity, and an event that names it.",
+  "description": "The amount changed, the identity changed, and an announcement event carries the new identity. This is what the clause asks for, and it is here so the two refusals above cannot be mistaken for \"any change fails\".",
+  "input": {
+    "ingress": {
+      "snapshot": {
+        "method": "POST",
+        "path": "/api/paid/verify-ownership",
+        "query": "",
+        "body": {
+          "endpoint": "https://example.com/api/health",
+          "ownerAddress": "0x1111111111111111111111111111111111111111",
+          "method": "dns-txt"
+        },
+        "payTo": "0x2888f36548a900b9b08d584524e1f73bc563ec26",
+        "asset": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+        "network": "eip155:8453",
+        "amount": "1000",
+        "scheme": "exact"
+      },
+      "identity": "2ed52a521f9762c3adc24c8048a4ee04a3796202a34c335585fc953e15c97196"
+    },
+    "paths": [
+      {
+        "path": "challenge-quote",
+        "snapshot": {
+          "method": "POST",
+          "path": "/api/paid/verify-ownership",
+          "query": "",
+          "body": {
+            "endpoint": "https://example.com/api/health",
+            "ownerAddress": "0x1111111111111111111111111111111111111111",
+            "method": "dns-txt"
+          },
+          "payTo": "0x2888f36548a900b9b08d584524e1f73bc563ec26",
+          "asset": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+          "network": "eip155:8453",
+          "amount": "1000",
+          "scheme": "exact"
+        },
+        "identity": "2ed52a521f9762c3adc24c8048a4ee04a3796202a34c335585fc953e15c97196"
+      },
+      {
+        "path": "settle",
+        "snapshot": {
+          "method": "POST",
+          "path": "/api/paid/verify-ownership",
+          "query": "",
+          "body": {
+            "endpoint": "https://example.com/api/health",
+            "ownerAddress": "0x1111111111111111111111111111111111111111",
+            "method": "dns-txt"
+          },
+          "payTo": "0x2888f36548a900b9b08d584524e1f73bc563ec26",
+          "asset": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+          "network": "eip155:8453",
+          "amount": "2000",
+          "scheme": "exact"
+        },
+        "identity": "b1b9009e0c9e7d66fc4e47a66303e8ccdddce8cc3462bc9de007abf524855bcb"
+      }
+    ],
+    "events": [
+      {
+        "type": "announcement",
+        "identity": "b1b9009e0c9e7d66fc4e47a66303e8ccdddce8cc3462bc9de007abf524855bcb"
+      }
+    ]
+  },
+  "expected": {
+    "outcome": "PASS"
+  },
+  "limits": [
+    "The event is taken as recorded. Whether it was actually emitted to anyone is outside this layer."
+  ]
+}

package/vectors/attempt-identity/changed-amount-no-event.json

@@ -0,0 +1,82 @@
+{
+  "schema_version": "3.0.0",
+  "verifies": "attempt-identity",
+  "requires_chain_read": false,
+  "provenance": [
+    "x402 specification v2 section 5.5, Settlement and Refusal Identity Invariant, as proposed in x402-foundation/x402 pull request 3776 on branch spec/settlement-refusal-identity-invariant and not on main",
+    "the gap these cover was named by ruiruii in erc-8004/erc-8004-contracts#99 on 18 October 2026: each of the four evidence layers depends on an attempt identity that none of them defines",
+    "section 5.5 closes by referring to \"the normative conformance tests in the specification repository for the required negative cases\"; at the time of writing those did not exist"
+  ],
+  "id": "attempt-identity-changed-amount-no-event",
+  "clause": "changed-request-different-artifact",
+  "encodes": "A changed request that correctly gets a new identity but surfaces nowhere, which the clause calls a silent divergence.",
+  "description": "The amount changed, the identity changed with it, and no settlement or announcement event names the new identity. Half the clause is satisfied and the half that makes it observable is not, so a reader sees two unrelated attempts instead of one attempt that changed.",
+  "input": {
+    "ingress": {
+      "snapshot": {
+        "method": "POST",
+        "path": "/api/paid/verify-ownership",
+        "query": "",
+        "body": {
+          "endpoint": "https://example.com/api/health",
+          "ownerAddress": "0x1111111111111111111111111111111111111111",
+          "method": "dns-txt"
+        },
+        "payTo": "0x2888f36548a900b9b08d584524e1f73bc563ec26",
+        "asset": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+        "network": "eip155:8453",
+        "amount": "1000",
+        "scheme": "exact"
+      },
+      "identity": "2ed52a521f9762c3adc24c8048a4ee04a3796202a34c335585fc953e15c97196"
+    },
+    "paths": [
+      {
+        "path": "challenge-quote",
+        "snapshot": {
+          "method": "POST",
+          "path": "/api/paid/verify-ownership",
+          "query": "",
+          "body": {
+            "endpoint": "https://example.com/api/health",
+            "ownerAddress": "0x1111111111111111111111111111111111111111",
+            "method": "dns-txt"
+          },
+          "payTo": "0x2888f36548a900b9b08d584524e1f73bc563ec26",
+          "asset": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+          "network": "eip155:8453",
+          "amount": "1000",
+          "scheme": "exact"
+        },
+        "identity": "2ed52a521f9762c3adc24c8048a4ee04a3796202a34c335585fc953e15c97196"
+      },
+      {
+        "path": "settle",
+        "snapshot": {
+          "method": "POST",
+          "path": "/api/paid/verify-ownership",
+          "query": "",
+          "body": {
+            "endpoint": "https://example.com/api/health",
+            "ownerAddress": "0x1111111111111111111111111111111111111111",
+            "method": "dns-txt"
+          },
+          "payTo": "0x2888f36548a900b9b08d584524e1f73bc563ec26",
+          "asset": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+          "network": "eip155:8453",
+          "amount": "2000",
+          "scheme": "exact"
+        },
+        "identity": "b1b9009e0c9e7d66fc4e47a66303e8ccdddce8cc3462bc9de007abf524855bcb"
+      }
+    ],
+    "events": []
+  },
+  "expected": {
+    "outcome": "FAIL",
+    "reason_code": "CHANGED_REQUEST_NO_EVENT"
+  },
+  "limits": [
+    "An empty event list is taken at face value. A checker cannot tell a missing event from an event it was not shown."
+  ]
+}