identity: the Travel Rule and compliance-policy verifiers name their rules; a missing originator id or nonce is now a refusal in acceptBeneficiary; conformance: Travel Rule and compliance presentations enrolled (239 rules, 15 verifiers, 21 kinds, 619 vectors), nothing of identity left out

This commit is contained in:
Aere Network committed 2026-10-18 13:13:50 +03:00
1 parent e1bb4e25d8
commit ea695dcf32
81 files changed
+17246 -127

No files matched your search

+106 -31
View File
@@ -42,10 +42,10 @@ verdict (`vectori/payment-receipt/company-p1-28001.valid.json`).
## What is enrolled
`REGULI.json` is derived from the code (`node deriva-reguli.mjs --verifica`): 213 rules of 13 verifiers, 17 artifact kinds (since
2026-10-18; 181 rules of 11 verifiers, 15 kinds before the SD-JWT verifiers were enrolled). By level: 170 rules are reported at
`integrity`, 40 at `authenticity`, 3 at `anchoring` (one of them, `envelope.finality`, is reported at `anchoring` or at `finality` by
the place that refused).
`REGULI.json` is derived from the code (`node deriva-reguli.mjs --verifica`): 239 rules of 15 verifiers, 21 artifact kinds (since
2026-10-18, when the Travel Rule and the compliance verifiers were enrolled; 213 rules of 13 verifiers and 17 kinds after the SD-JWT
verifiers earlier that day; 181 rules of 11 verifiers, 15 kinds before). By level: 187 rules are reported at `integrity`, 49 at
`authenticity`, 3 at `anchoring` (one of them, `envelope.finality`, is reported at `anchoring` or at `finality` by the place that refused).
| artifact kind | judged by | rules |
|---|---|---|
@@ -62,6 +62,8 @@ the place that refused).
| `device-bundle` (the chain of a device: the manufacturer's credential for the device key, a firmware release, the ownership transfers, the owner's authorization, the device's attestation and its AIP-23 envelope, judged with what the verifier brings: its clock, nonce and audience, the manufacturers it trusts, the recall lists, firmware policies and status records it read, its own reading of the notarized envelope) | `device-identity/device.mjs` | 47: `device.form`, `.manufacture-form`, `.manufacturer-id`, `.manufacture-holder`, `.manufacture-signature`, `.manufacturer-trusted`, `.manufacture-window`, `.manufacture-status-list`, `.manufacture-revoked`, `.device-key`, `.device-id`, `.firmware-form`, `.firmware-signer`, `.firmware-signature`, `.firmware-model`, `.firmware-retracted`, `.firmware-rollback`, `.firmware-software`, `.chain-length`, `.transfer-form`, `.transfer-device`, `.transfer-ids`, `.transfer-from`, `.transfer-prev`, `.transfer-signature`, `.transfer-time`, `.authorization-form`, `.authorization-device`, `.authorization-owner`, `.authorization-ownership`, `.authorization-signature`, `.authorization-window`, `.authorization-action`, `.status-retired`, `.status-suspended`, `.attestation-form`, `.attestation-key`, `.attestation-device`, `.attestation-signature`, `.audience`, `.nonce`, `.freshness`, `.attestation-firmware`, `.attestation-ownership`, `.witness-envelope`, `.witness-time`, `.unreadable` |
| `sdjwt-presentation` (an SD-JWT of IETF RFC 9901, as issued or with its Key Binding JWT, judged with what the verifier brings: the issuer key it chose, a public JWK, never one taken from the token; its clock; its audience and nonce; the issuer and the explicit type it expects; whether it requires key binding and `exp`) | `identity/sdjwt.mjs` (enrolled 2026-10-18) | 23: `sdjwt.form`, `.alg`, `.typ`, `.crit`, `.key`, `.signature`, `.issuer`, `.sd-alg`, `.disclosure-form`, `.disclosure-twice`, `.digest-twice`, `.disclosure-name`, `.claim-conflict`, `.unreferenced`, `.time`, `.kb-context`, `.kb-required`, `.kb-cnf`, `.kb-claims`, `.kb-audience`, `.kb-nonce`, `.kb-freshness`, `.kb-sd-hash` |
| `sdjwt-vc-presentation` (an SD-JWT VC of `draft-ietf-oauth-sd-jwt-vc`, judged as the SD-JWT above plus the profile: the credential type the verifier expects, and the Token Status List it fetched for the `status` the credential names) | `identity/sdjwt-vc.mjs` (enrolled 2026-10-18) | 9 of its own, on top of the 23 of `sdjwt`: `sdjwtvc.vct-expected`, `.vct`, `.vct-mismatch`, `.disclosed-protected`, `.form`, `.status-list`, `.status-index`, `.status-revoked`, `.status-unjudged` |
| `travel-rule-binding`, `travel-rule-message`, `travel-rule-receipt` (the Travel Rule between VASPs: the beneficiary's KEM key binding with its VASP presentation, judged by the originator with its id, its nonce, its clock, the registries it trusts and their status lists; the sealed IVMS101 message, judged by the beneficiary with its id, its own KEM key pair, which decrypts, its clock, its registries and lists and its replay store; the signed receipt, judged by the originator with the message it sent and the beneficiary it accepted) | `identity/travel-rule.mjs` (enrolled 2026-10-18) | 23: `travelrule.binding-form`, `.binding-id`, `.binding-signature`, `.binding-window`, `.vasp-presentation`, `.vasp-status`, `.vasp-identity`, `.vasp-claim`, `.message-form`, `.message-id`, `.message-signature`, `.message-recipient`, `.message-kem-keys`, `.message-freshness`, `.replay-store`, `.replay`, `.kem-alg`, `.kem-open`, `.ciphertext`, `.receipt-form`, `.receipt-from`, `.receipt-signature`, `.receipt-message` |
| `compliance-presentation` (a presentation of a credential judged against the verifier's compliance policy: the issuers it believes and the claims it requires, with the verifier's audience, nonce and clock, all required, and the status lists and revocations it holds) | `identity/conformitate.mjs` (enrolled 2026-10-18) | 3: `compliance.presentation`, `.status`, `.rule` |
A module verifier exports the list of rules it can name (`REGULI`; its helper throws on any other) and marks its rules in one of two
ways, both read by the derivation: a marker on every check of a rule (nine modules), or the rule named at every call of the
@@ -97,15 +99,26 @@ leaves the authenticity level `NOT_MEASURED` (`not-reached`), an authenticity re
status list was not read. The profile imports `sdjwt.mjs` from its real file, so a planted copy of `sdjwt.mjs` is reached only through
the artifact `sdjwt-presentation`: no `sdjwt-vc-presentation` vector expects a rule of `sdjwt` (they all exercise them).
**Not enrolled**, counted in the same file: two verifiers of the identity component that sit on top of the enrolled ones: Travel Rule
(20 places that add a reason) and compliance (3). Their refusals are texts, not rule ids. Their own probes and negative controls stay
what checks them.
The Travel Rule verifier and the compliance verifier (enrolled 2026-10-18, the last two of the identity component; the file counts
nothing as not enrolled since) run the identity verifier on the VASP or KYC presentation inside and name its whole verdict as one rule
(`travelrule.vasp-presentation`, `compliance.presentation`); the identity rules themselves are enrolled under `identity-presentation`.
Both make every check they can reach and name every rule that refused, like the identity verifier; the Travel Rule verifier does not open
a message whose header it refused for any reason, so with only its authenticity refused (the originator's signature or id, the VASP
presentation) the integrity of the message is `NOT_MEASURED` (`not-reached`), and a binding or a receipt that cannot be read at all
(`binding-form`, `receipt-form`, `message-form` before the signature) leaves authenticity so. Their verdicts are the verifier's: a
Travel Rule party brings its registries, its clock, the lists it holds and (the beneficiary) its replay store and its KEM keys; a
compliance verifier brings its policy, its audience, its nonce and its clock. A compliance judgement under a policy that waives the
credential status (`requireStatus: false`), with no list read, is `PARTIAL` (`claim-not-checked`); a Travel Rule verdict is never
`PARTIAL`, since a VASP status that was not judged is a refusal there (`vasp-status`). An invalid presentation establishes no claim, so
the compliance verifier reports every rule of its policy not met as well (the verifier's reasons list said so before the enrolment, and
the vectors expect both); a credential from an issuer or a registry whose status list the verifier does not hold is refused for its
issuer and for its status at once.
## The vectors
`vectori/` holds 553 vectors (544 offline, 9 that read testnet 28001; 20 MB, since every device and identity vector carries its ML-DSA-65 keys and signatures), listed with their digests in `vectori/INDEX.json`:
`vectori/` holds 619 vectors (610 offline, 9 that read testnet 28001; 22 MB, since every device, identity and Travel Rule vector carries its ML-DSA-65 keys and signatures), listed with their digests in `vectori/INDEX.json`:
envelope 64, payment-risk 11, payment-receipt 10, market-timeline 26, dataset 22, ai-trust-bundle 24, audit-log 19, audit-inclusion
10, audit-consistency 4, agent-ledger 18, identity-presentation 65, device-bundle 194, sdjwt-presentation 54, sdjwt-vc-presentation 32. By expected verdict: 81 `VALID`, 68 `PARTIAL`, 404 `INVALID`. None is typed by hand
10, audit-consistency 4, agent-ledger 18, identity-presentation 65, device-bundle 194, sdjwt-presentation 54, sdjwt-vc-presentation 32, travel-rule-binding 19, travel-rule-message 26, travel-rule-receipt 9, compliance-presentation 12. By expected verdict: 85 `VALID`, 69 `PARTIAL`, 465 `INVALID`. None is typed by hand
(`node genereaza-vectori.mjs --verifica` regenerates them and compares byte for byte):
- the 16 AIP-23 kinds come from their producers on fixed inputs (the same envelopes as the published AIP-23 kind vectors); the audit
@@ -131,32 +144,47 @@ envelope 64, payment-risk 11, payment-receipt 10, market-timeline 26, dataset 22
stranger: three hybrid key pairs each, made and discarded), presented to one verifier, the VC's Status List Tokens (clean, revoked,
suspended, 8 bits, for another uri, expired, by a stranger, typed JWT, without `iat`, too short, ML-DSA-65) and the forged siblings
only a key holder can make (a key binding JWT by a stranger or without its nonce, a digest signed twice, a nested `_sd_alg`, a
disclosure named `_sd`, a claim named `__proto__`, an algorithm confusion, a `status` behind a disclosure, and so on);
disclosure named `_sd`, a claim named `__proto__`, an algorithm confusion, a `status` behind a disclosure, and so on); since the same
day also one Travel Rule exchange (a registry, another registry, the paying VASP, the receiving VASP, a third VASP and a stranger: six
hybrid key pairs made and discarded; two hybrid KEM key pairs, X25519 + ML-KEM-768, of which the receiving VASP's is **kept whole in
the vectors, private half included**, since the beneficiary's private KEM keys are what opens a message: it was made for these vectors
and opens nothing else, and it is declared test material at the scene, in the form the secret gate of this repository reads, so that
the gate reports it as seen and would still block a private key without that declaration), with the forged siblings only a key holder
can make, each checked at generation to be refused for exactly the rule it was made for (a stranger's keys under a VASP's id, a binding
that expired or whose ML-KEM key is an X25519 key, a header addressed to another VASP, dated 400 s earlier, with another encapsulation
name, a truncated ML-KEM ciphertext, a flipped ciphertext byte or another amount, each signed again by the originator, a receipt by
another VASP); and one compliance exchange (an issuer, a holder, another issuer: three hybrid key pairs made and discarded; a KYC
credential with six disclosable claims, the issuer's status list, a policy of four rules, and the holder's presentations: enough
claims, too few, claims that break every rule, a credential from the other issuer, a revoked one);
- the SD-JWT vectors have two more sources that are fixed text: the example of RFC 9901 Section 5 with the key of its Appendix A.5
(`identity/fixturi-rfc9901.json`), and the tokens of `@sd-jwt/core` 0.23.0 and `@sd-jwt/sd-jwt-vc` 0.23.0 with the status lists of
`@owf/token-status-list` 0.5.0 (`identity/interop/fixturi-interop-*.json`), which the identity component derived from those
libraries' real output on 2026-10-18, with their public test keys.
An `INVALID` vector names its `base` and its `mutation`: **one operation** (set, remove or add at one JSON path) applied to the input
of a vector that is not invalid, and it must be refused for exactly the rules in `expected.failed`, not merely refused: 249 of the
404 are made this way. Where the rule sits under a hash or a signature, one place is not reachable (changing an amount under the
of a vector that is not invalid, and it must be refused for exactly the rules in `expected.failed`, not merely refused: 300 of the
465 are made this way. Where the rule sits under a hash or a signature, one place is not reachable (changing an amount under the
instruction hash trips the binding first; a false decision in a ledger must still be signed by the agent; a disclosure the issuer never signed must still be signed for by
the holder; an authorization by a previous owner must still be signed by that owner; a digest repeated in an SD-JWT must still be
signed by its issuer, a key binding JWT for another audience by its holder): the other 155 are made at
signed by its issuer, a key binding JWT for another audience by its holder; a Travel Rule header addressed to another VASP, or with a
cut ML-KEM ciphertext, must still be signed by the originator): the other 165 are made at
the producer, the commitments above the change recomputed with the published formulas, and every path that moved is declared
(`mutation.changed`). Eleven vectors expect more than one rule: rules that guard the same field cannot be separated (a looser policy shown
(`mutation.changed`). Twenty-four vectors expect more than one rule: rules that guard the same field cannot be separated (a looser policy shown
under a receipt also makes the risk verdict not reproduce; a Proof of AI envelope that is changed is also no longer the one the
ledger links; a delegation chain cut after it was signed for is also not presented by its last delegate; a manufacture credential
whose signature is changed is also no longer the link the first transfer names; a clone that claims the device's id with another
key breaks both the id derivation and the match with the manufacturer's credential).
key breaks both the id derivation and the match with the manufacturer's credential; a revoked VASP credential, or one from a registry
whose list the verifier does not hold, fails the VASP presentation and the VASP status at once; a message opened by another VASP is
not addressed to it and its originator's presentation was not made for it; a compliance presentation that is invalid for any reason
also establishes no claim, so its policy's rules are not met either).
## Run it
```
AERE_VERIFY_PROOF=<verify-proof.mjs from aere.network/tools, with verify-anchor.mjs, mpt.mjs, falcon512.mjs, registry-v3.mjs and package.json beside it and npm install done>
node conformance.mjs --impl "node implementare-aere.mjs" # the published verifiers behind the one verdict form: 544 offline vectors
node conformance.mjs --impl "node implementare-aere.mjs" # the published verifiers behind the one verdict form: 610 offline vectors
node conformance.mjs --impl "node implementare-aere.mjs" --online # and the 9 that read testnet 28001 (nothing is sent)
node conformance.mjs --impl "python3 implementare-integritate.py" # an independent implementation: 62 vectors, 491 reported NOT COVERED
node conformance.mjs --impl "python3 implementare-integritate.py" # an independent implementation: 62 vectors, 557 reported NOT COVERED
node conformance.mjs --impl "<your command>" # yours
node implementare-aere.mjs <artifact.json> [--online] # one artifact { artifact, input }: its verdict
```
@@ -168,8 +196,16 @@ chain, `{ presentation, now, audience?, nonce?, trustedIssuers?, statusLists?, r
credential, `{ bundle, now, nonce?, audience?, trustedManufacturers?, statusLists?, firmwarePolicies?, statusRecords?,
softwareAttestation?, anchors?, maxAgeS? }` for a device bundle, `{ sdJwt, issuerKey, issuerAlg?, now, audience?, nonce?,
expectedIssuer?, expectedTyp?, requireKeyBinding?, requireExp?, maxAgeS? }` for an SD-JWT presentation and the same plus
`{ expectedVct, statusListJwt?, statusListKey?, statusListAlg?, requireStatus? }` for an SD-JWT VC: `now`, the verifier's clock, is
required for all of them, since a verdict on the clock of the machine that runs a vector would not reproduce).
`{ expectedVct, statusListJwt?, statusListKey?, statusListAlg?, requireStatus? }` for an SD-JWT VC, `{ binding, presentation,
registries, originatorId, nonce, now, statusLists?, maxAgeS? }` for a Travel Rule binding (`originatorId` and `nonce` are the
originator's own; without them the identity verifier would leave the audience or the nonce of the VASP presentation unjudged, and the
Travel Rule verifier refuses instead of accepting on trust: a defect this suite's malformed-input row found on 2026-10-18, fixed the
same day), `{ message, me, kem, registries, now,
statusLists?, seen?, maxAgeS? }` for a Travel Rule message (`kem` is the beneficiary's key file, `aere-travel-rule-kem-keys`, with
its private half; `seen` is the list of message ids already received, the replay store; without it nothing is opened), `{ receipt,
message, beneficiaryId }` for a Travel Rule receipt, and `{ presentation, policy, audience, nonce, now, statusLists?, revocations? }` for
a compliance presentation (`audience` and `nonce` required, as the module requires them): `now`, the verifier's clock, is required for
all of them but the receipt, since a verdict on the clock of the machine that runs a vector would not reproduce).
An implementation is a command that answers three calls with JSON on stdout: `--capabilities` (`{ artifacts, rules, online, batch }`:
what it claims to judge), `<vector.json> [--online]` (the verdict above for the file's `{ artifact, input }`), and, if it says
@@ -179,15 +215,41 @@ exact set of failed rules and the state of each of the four levels are the expec
refusal. Without `--online` an implementation must not open a connection.
`implementare-integritate.py` is the second implementation: Python, standard library only, written from the rules and not from the
JavaScript. It claims 6 of the 213 rules (the form and the statement hash of an envelope; the form, the commitment, the salted field
JavaScript. It claims 6 of the 239 rules (the form and the statement hash of an envelope; the form, the commitment, the salted field
commitments and the RFC 9162 inclusion of a dataset record) and passes all 62 vectors it claims. It cannot check an ML-DSA signature
or read a chain, says so in its capabilities, and the runner reports the rest as not covered: 491 vectors, among them every vector of
the trust chain, the audit log, the agents' ledger, the identity presentations, the device bundles and the SD-JWT presentations. For
those eight verifiers the suite has one implementation, ours (for SD-JWT, the identity component measured our verifier against
`@sd-jwt/core` and `@sd-jwt/sd-jwt-vc` outside this suite; those libraries are not implementations of this suite's contract).
or read a chain, says so in its capabilities, and the runner reports the rest as not covered: 557 vectors, among them every vector of
the trust chain, the audit log, the agents' ledger, the identity presentations, the device bundles, the SD-JWT presentations, the
Travel Rule artifacts and the compliance presentations. For those ten verifiers the suite has one implementation, ours (for SD-JWT,
the identity component measured our verifier against `@sd-jwt/core` and `@sd-jwt/sd-jwt-vc` outside this suite; those libraries are
not implementations of this suite's contract).
## How the suite itself is checked
Measured on 2026-10-18 (UTC), after the Travel Rule verifier and the compliance verifier were enrolled, the last two of the identity
component (Node.js 24.14.1; the reference verifier of the development repository; testnet 28001 read, nothing sent; the run is the one
on the final code, after the three fixes below):
- `node proba-conformance.mjs --online`: 12 rows green, 0 red. The rules and the vectors are what the code derives now: 239 rules of
15 verifiers, 619 vectors (19 of the kind `travel-rule-binding`, 26 of `travel-rule-message`, 9 of `travel-rule-receipt`, 12 of
`compliance-presentation`). Every rule has a vector that expects it (239 of 239); every artifact kind has a valid vector (21); every
invalid vector is its base with one operation (300) or one declared producer change (165); the published verifiers pass 619/619; the
independent implementation passes all 62 it claims and the other 557 are reported not covered; 100,825 malformed inputs given to the
module verifiers each got a verdict and none threw (4,766 still accepted, at 255 distinct paths; of the four new kinds only
`travel-rule-receipt` accepts damage, at 62 paths, all of them the originator's presentation and signature inside the message handed
with the receipt, which the receipt names by the hash of the signed header and the ciphertext and does not read; the binding, the
message and the compliance presentation accept none); 183 malformed envelope files given to the reference verifier each got a verdict.
- `node proba-conformance.mjs --control-negativ --online`: 321 rows green, 0 red: 239 of 239 rules (each of the 23 rules of the Travel
Rule verifier and the 3 of the compliance verifier planted out in turn fails exactly the vectors that expect it), 76 of 76 conditions
of the device verifier, six controls of the instruments (an implementation that calls everything valid fails 578 of the 610 offline
vectors).
- While the enrolment was being made, the measurement found three things, each fixed before this run: the malformed-input row showed
that `acceptBeneficiary` called without `originatorId` or without `nonce` accepted the beneficiary (the identity verifier leaves the
audience or the nonce of the VASP presentation unjudged, and the Travel Rule verifier did not require them judged: it refuses now; a
test of the identity component, a planting of its negative control and two vectors here); and the control showed, with a `*-form`
rule planted out, the vector whose artifact is the JSON value `null` **breaking** instead of failing, twice in the adapter (its
not-reached reason read the name of a stopping rule that was not there) and once in `verifyReceipt` (it read `accepted` from a
statement that was not there). A crash is not a refusal, and the control counted each as broken, not as a fail.
Measured on 2026-10-18 (UTC), when the SD-JWT verifier and the SD-JWT VC profile were enrolled (Node.js 24.14.1; the reference
verifier of the development repository; testnet 28001 read, nothing sent):
@@ -306,11 +368,11 @@ On 2026-10-05, while the identity verifier was being enrolled, one more, fixed t
## What it is not, and what is not measured
- **Not a certification, not an audit, not a mark.** Passing says that an implementation agrees with the published verifiers on these
553 inputs. It does not say either of them is correct, and no third party has reviewed the verifiers, the vectors or this suite.
619 inputs. It does not say either of them is correct, and no third party has reviewed the verifiers, the vectors or this suite.
- **The vectors and the verifiers have the same authors.** The expected verdicts were written by the people who wrote the verifiers.
The second implementation is independent in code and language, not in authorship, and it covers 6 rules of 213; the other
207 rules, among them every rule of the trust chain, the audit log, the agents' ledger, the identity verifier, the device
verifier and the SD-JWT verifiers, are judged here by one implementation.
The second implementation is independent in code and language, not in authorship, and it covers 6 rules of 239; the other
233 rules, among them every rule of the trust chain, the audit log, the agents' ledger, the identity verifier, the device
verifier, the SD-JWT verifiers, the Travel Rule verifier and the compliance verifier, are judged here by one implementation.
- **Finality is the chain's.** The level says that the post-quantum certificate of the covering anchor verified on the chain where the
artifact was notarized. Every notarized vector here is on chain 28001, a testnet; nothing in this suite ran on mainnet.
- **Five of the six finality refusals have no vector.** The reference verifier can refuse at its finality level in six places; the
@@ -348,7 +410,7 @@ On 2026-10-05, while the identity verifier was being enrolled, one more, fixed t
survive a sale: after a transfer it is named and not applied (the manufacturer's is final). A retirement by an owner that holds
across a sale needs a witness of when it and the transfer were signed, which is not built; every time in a transfer, an
authorization and a status record of these vectors is the statement of the key holder that signed it.
- **What a damaged artifact can still pass.** Of the 96,757 malformed inputs (measured 2026-10-14), 4,280 were still accepted, at 187 distinct paths (76 of them in device bundles; the kinds that follow were listed on 2026-10-05, when the count was 81 and the device verifier had not had its third review: a status record that decided nothing, such as a suspension already lifted, a stranger's record, a record not in effect yet or one of a previous owner; a recall list or a firmware policy that could not be read and stood beside a clean one, which damaged is no longer signed by the manufacturer and counts like one that was not handed; the envelope and its notarization claim, which are optional; and the signature of a Proof of Software attestation, which the device verifier does not read): parts a
- **What a damaged artifact can still pass.** Of the 100,825 malformed inputs (measured 2026-10-18), 4,766 were still accepted, at 255 distinct paths (76 of them in device bundles, 62 in Travel Rule receipts: the originator's presentation and signature inside the message handed with a receipt, which the receipt does not read; on 2026-10-14 the count was 96,757 inputs, 4,280 accepted at 187 paths; the kinds that follow were listed on 2026-10-05, when the count was 81 and the device verifier had not had its third review: a status record that decided nothing, such as a suspension already lifted, a stranger's record, a record not in effect yet or one of a previous owner; a recall list or a firmware policy that could not be read and stood beside a clean one, which damaged is no longer signed by the manufacturer and counts like one that was not handed; the envelope and its notarization claim, which are optional; and the signature of a Proof of Software attestation, which the device verifier does not read): parts a
verifier treats as optional (the transaction facts of a receipt, the envelope of a timeline, the head of an audit log), a policy
field removed that falls back to its default, a log or a ledger without its last entry (still a valid shorter one), a revocation that was not in effect (damaged, it is
ignored as before), and fields no rule reads
@@ -359,8 +421,21 @@ On 2026-10-05, while the identity verifier was being enrolled, one more, fixed t
not read them; the statement carries its own `kind`, which is under the hash. (This file used to quote 526 malformed envelopes,
a figure of 2026-10-03 from a run whose script was not kept; the row above replaces it.)
- **Not part of AIP-23.** The rule ids, the four levels and the verdict form are this suite's reading of the published verifiers;
AIP-23 defines the envelope. The device verifier is enrolled. Of the identity verifiers published beside these, the presentation
verifier, the SD-JWT verifier and the SD-JWT VC profile are enrolled; Travel Rule and compliance are not.
AIP-23 defines the envelope. The device verifier is enrolled, and so are all five identity verifiers published beside these: the
presentation verifier, the SD-JWT verifier and the SD-JWT VC profile, the Travel Rule verifier and the compliance verifier (the last
two since 2026-10-18).
- **A Travel Rule verdict is the receiving party's, and the vectors carry one test decryption key.** A binding, a message or a receipt
is judged with what the originator or the beneficiary brings: the registries it trusts, the status lists it holds, its clock, its
nonce, its replay store, its KEM keys. `VALID` for a message says that it opened for this beneficiary, with these keys, on this
clock, that it was not in the replay store handed, and that the originator's VASP status was judged on the lists handed; it does not
say who a registry is in the world, nor that the IVMS101 inside is true or complete (the module does not validate the schema). The
beneficiary's KEM key pair in the message vectors is test material made at generation, declared so at the scene, and opens only the
messages of these vectors; nothing else in this suite holds a private key. The record of an exchange (an AIP-23 `compliance` envelope
without personal data) is judged as the artifact `envelope`, not here.
- **A compliance verdict is the verifier's policy applied to one presentation.** It says that the presentation was valid for that
verifier and that the claims it established satisfy the policy's rules, with the status judged on the lists handed when the policy
requires it. It is not a zero-knowledge proof (a shown claim is shown whole), not an AML or sanctions screening, and not legal
compliance with anything; a policy that cannot be defined is the verifier's error (the module throws, by design), not a verdict.
- **The SD-JWT vectors say what two libraries agree on, on these inputs.** The tokens of `@sd-jwt/core` and `@sd-jwt/sd-jwt-vc` in
the SD-JWT vectors are the fixtures the identity component derived from those libraries' real output on 2026-10-18 (their versions
are in the vector sources); the expected verdicts are those of our verifiers on them, which the identity component measured against