Skip to content

Release notes ​

Changes to the @tamga-network/* packages, the services and the documentation — newest first.

[Unreleased] ​

Changed ​

  • CRL on a separate host (ADR-0090). Access certificate revocation lists move from trust.<network>/crl/ to crl.<network>/<authority>.crl, served over both http and https without redirection. The CRL Distribution Points extension now holds a single distribution point with two names, http first, then https (ETSI EN 319 412-2 GEN-4.3.11-4; clients that block cleartext use the second). The registry setting roles.access_ca.crl.issuers[].uri is the http address; the publisher derives the https twin (crlUrisOf) and checks the host against the trusted-list host (crlHostOf). New ops/crl-dp.ts; gen-pki.ts and pki-issue.ts --crl-uri http://crl.…/<authority>.crl write both names. The sandbox access CA certificate was reissued with the same key.

0.8.7 — 2026-11-17 ​

All ten packages move to 0.8.7 together (patch release). The code changes are in wallet-core (identity number in the driving licence attestation, TS10 password 12, externalListsDirect) and trust (externalListsDirect); the other eight packages carry the version number. Published on npm on 2026-11-17.

Changed ​

  • wallet-core — driving licence attestation: the identity presentation also discloses the identity number (ADR-0039 open question 1, D-ID-8 note). identityPresentationForIssuer discloses personal_administrative_number in addition to given_name, family_name and birthdate when the identity credential has it; the identity service compares it only as a keyed digest with the number on the card (TR) and never writes it to the credential. Without it, a card that carries an identity number is refused ("identity number not disclosed").
  • wallet-core — TS10 migration file password at least 12 characters (TS10_MIN_PASSWORD 8 → 12; ADR-0027 note). Only export checks it; import keeps opening older files protected with 8+ characters.
  • trust-publisher — ADR-0081 RR3 is enforced: once the previous signed list or the new source contains an issuer or relying party that is not the provisional operator's own record (the first participant institution), no removal is published, even with an approved removal record (participantRecords; production only).
  • trust-publisher — gate groups before suspension (Y9): status and rp-status print the active gate groups bound to the institution and the end-use commands to withdraw them first (ADR-0069 TG1; the build still refuses such a list).
  • Registry — Tamga Verify's uses carry the network privacy page (privacy_policy_uri: https://tamga.network/privacy, ADR-0024 RPR3); it reaches the signed list and the registration certificates with the next publication.

Added ​

  • trust / wallet-core — externalListsDirect (default true, behaviour unchanged): false uses only the publisher's copy of an external list and never contacts the external list server directly (that server would see the client's IP address and the fetch time).

Documentation ​

  • SPEC-ID-0003 §9.3 (driving licence prerequisite and match), GUIDE-0017 §7 (withdraw gate groups before suspending), ADR-0081 implementation note (RR3), ADR-0027 note (password 12), wallet guides (password 12) — tr/en/az. RS-EIDAS-0001 §9.1 intermediate steps for non-EU countries (TC AdES LOTL pilot, regional recognition).

0.8.6 — 2026-11-16 ​

All ten packages move to 0.8.6 together (patch release). The code changes are in wallet-core (standard mdoc path for the identity credential, identity renewal, future-dated credentials, credentialValidity), trust (isIssuerSuspended, walletProviderOfKey), verifier (suspended issuer at C1, verifier/zk fixes), issuer, sd-jwt, mdoc and schemas (nbf, mdoc configuration scope, expiry_date, date_of_expiry) and zk (Android libraries rebuilt with ruzstd 0.9.1); core and onboard carry the version number (and, for onboard, a test time limit). The single-credential rule for presentations is in the reference verifier (apps/verify), not in the packages. Published on npm on 2026-11-16.

Migration notes (for app developers) ​

  • Schema hashes changed. Every credential type's type metadata hash (vct#integrity) is new (nbf, date_of_expiry, name length). Issuers and verifiers must use the current catalog and trust list (already published on the live network, list v266); a hash pinned in your own code must be updated.
  • A suspended issuer's credentials are now REJECTED at C1 (failed_reason: "issuer suspended"), also those issued before the suspension. Before, only credentials issued during the suspension were dropped. Show "temporarily not accepted" rather than "invalid"; once the suspension is lifted, the earlier credentials are accepted again. A custom TrustSource should implement isIssuerSuspended so the reason can be told apart.
  • Wallet developers: the identity credential's mdoc copy now comes from the issuer's separate mso_mdoc configuration; an issuer that only put the mdoc into the non-standard mso_mdoc response field gives a credential without an mdoc copy. Show validity with credentialValidity (not_yet_valid and issuer_suspended are new states) and schedule identity renewal with scheduleIdentityRenewals / identityRenewalDue → renewIdentityCredential; a future-dated credential is kept but not offered for presentation until its nbf.
  • zk: rebuild the app after updating (the native libraries changed); no code change.

Changed ​

  • Identity credential: standard mdoc configuration, renewal of short-lived copies, wallet provider suspension (ADR-0089).wallet-core: obtainCredential requests the mdoc copy through the issuer's separate mso_mdoc configuration (same scope, doctype = vct; new mdocCompanionConfigId) with a second standard credential request using the same keys in the same order; the non-standard mso_mdoc field of the credential response is no longer read. New identity-renewal module: renewIdentityCredential (refresh token + DPoP + WIA + a presentation of a copy with all claims disclosed → new batch replaces the old credential; ZK copies and passes are kept; invalid_grant removes the binding, temporarily_unavailable = provider suspended, binding kept), identityRenewalDue, scheduleIdentityRenewals (2 unused copies / 7 days, random delay ≤ 6 h), fullIdentityPresentation; StoredCredential.renewDueAt; institution silent refresh no longer covers the identity credential. schemas: optional date_of_expiry (administrative validity) on IdentityAttestation (type metadata hash changes). mdoc: expiry_date is a full-date element. issuer: mdocConfigurations[] take an optional scope and reusePolicy. trust: optional TrustSource.walletProviderOfKey (provider id of a WIA/KA signing key, regardless of status).
  • Credentials of a suspended issuer are not accepted (ADR-0088). While an issuer is SUSPENDED in the trust list, C1 rejects all of its credentials regardless of issuance time (REJECTED, failed_step: "C1", failed_reason: "issuer suspended"); once the suspension is lifted, credentials issued before it are accepted again, those issued during it never. Revocation, retirement and expiry keep the issuance-time rule. trust: new optional TrustSource.isIssuerSuspended; ListTrustSource, the chain trust source (apps/chain-indexer) and IssuerRegistry.isCredentialAcceptable give the same answer. Earlier the suspension only dropped credentials issued during it (ADR-0073 K5, changed).
  • wallet-core: a future-dated credential (nbf ahead) is no longer rejected on receipt; verifyIssuedSdJwt returns nbf and notYetValid, the stored credential keeps nbf, its mdoc copy is checked at the start time, and remote and proximity presentation selection skip it until it is valid (ARF 3.0 "Issued"). A malformed nbf or nbf ≥ exp is rejected.
  • issuer: buildCredentials writes nbf (default: the issuance time iat; optional nbf for a future start). sd-jwt: issueSdJwtVc takes an optional nbf (integer, ≥ iat, < exp).
  • schemas: every credential type schema allows nbf; in IdentityAttestation family_name / given_name are limited to 150 characters (EU PID mdoc text rule). The type metadata hashes change (development stage, ADR-0029).

Added ​

  • wallet-core: credentialValidity(cred, { now, trust }) → valid · not_yet_valid · expired · revoked · suspended · issuer_suspended (with validFrom, validUntil, presentable) and isNotYetValid; receipt from a suspended issuer gives a distinct message.

Fixed ​

  • trust: malformed XML that the parser rejects by throwing directly (for example ]]> outside a CDATA section) now surfaces as XmlSignatureError like every other malformed list, instead of a plain Error (found by the property test in CI).
  • verifier/zk: the native backend no longer lets a write to a dead prover process crash the host (stdin error listener).
  • verifier/zk: the bundled WASM verifier is rebuilt with ruzstd 0.9.1 (RUSTSEC-2026-0344).
  • zk: the three Android libraries are rebuilt with ruzstd 0.9.1 (RUSTSEC-2026-0344; 0.8.5 shipped 0.8.3), still 16 KB aligned. No API change.
  • onboard: the security test has a longer time limit (cold CLI starts under load).

Applications and repository (not part of the npm packages) ​

  • apps/verify: a presentation is verified for one credential only (plus an optional pseudonym); a policy with a second credential is refused instead of silently checking the first (ARF discussion #775, credential pooling; SPEC-API-0001 §1.5).

Documents ​

  • ADR-0088; Tamga ARF Risk Register (FW-RISK-0001, self-assessment against the CIR 2024/2981 risk register); Annex D terms (Wallet Instance, LoTE, Access CA, RP Instance, registration certificate provider, scheme owner, logical / technical credential; "verifier" = EU Relying Party); Annex E: eight EU sources; Identity Rulebook PID mapping rows (place_of_birth, issuing_authority without counterpart, issuing_country meaning).

0.8.5 — 2026-11-15 ​

All ten packages move to 0.8.5 together (patch release). The code changes in the packages are in wallet-core (POST fetch of the request object, single-use approvals, the closed chip carrier), verifier (one optional option) and zk (rebuilt Android libraries); the other packages carry the version number and README wording. The chain tools (ADR-0084/0085/0086) and the access certificate revocation list (ADR-0087) are in the list publisher and the repository tools, not in the npm packages. Published on npm on 2026-11-15.

Migration notes (for app developers) ​

  • wallet-core approvals are single-use. Call checkRp again before retrying a failed respond, and do not change the request's state or response encryption key between checkRp and respond (both now give trust_error).
  • request_uri_method=post is optional. A wallet that keeps calling fetchRequestObject (GET) works as before. To support POST: parseVpUri → fetchRequestObjectFor(uri, http, { randomBytes }) → verifyRequestObject(…, { walletNonce }) with the returned walletNonce. A verifier that sets requestUriMethod: "post" must keep serving GET on the request URI.
  • zk: rebuild the app after updating (the native libraries changed); no code change.
  • Chip carrier: nothing to do; it stays closed (see below).

Added ​

  • request_uri_method=post in the wallet core (OpenID4VP 1.0 §5.10): parseVpUri returns requestUriMethod; new fetchRequestObjectFor makes an HTTPS POST (application/x-www-form-urlencoded, Accept: application/oauth-authz-req+jwt) with a fresh wallet_nonce (newWalletNonce) and optional wallet_metadata; verifyRequestObject takes walletNonce and rejects a request object without the same wallet_nonce. The GET path is unchanged; an unknown request_uri_method is rejected. @tamga-network/verifier: requestUriMethod: "post" writes the parameter into the QR / link (a wallet without POST fetches with GET, so the request URI must serve both). The reference verifier (apps/verify) now sets it (its request URI already served GET and POST).
  • wallet-core — identity document chip carrier, switched off (ADR-0083). chipReadRequestOf(url, authorizationServer) checks the identity service's /chip/read?r=…&c=… address (same origin as the authorization server, exact path) and returns the /chip/submit address, the opaque handle and the 8-byte active authentication challenge; submitChipRead(…) relays the raw chip data (SOD, DG1, DG2; DG11, DG14, DG15, the active authentication signature and CardAccess if present) unchanged, base64url in a JSON body with the wallet attestation headers, and returns the next address (same origin only). The wallet does not interpret chip data (CV4); no field goes into logs or error messages. CHIP_READER_PARAM / CHIP_READER_ICAO9303: the PAR field chip_reader=icao9303. Closed: the code ships in this release, but nothing calls it until the chip path is turned on in the identity service; opening depends on the identity service's key and a favourable legal opinion (ADR-0083 K11, CV7).

Changed ​

  • Presentation approvals are single-use and bound to state and the response encryption key (wallet core; self-audit against the EU reference library's 0.32.0 fixes, #440): respond consumes the checkRp approval on its first call, and an approval no longer matches a request whose state or encryption key was changed after checkRp. The approval is consumed before the response is built, so a failed respond cannot be retried with the same approval.
  • zk — Android libraries aligned for 16 KB pages (Android 15+ devices; Google Play requires it for apps targeting Android 15+). The three native libraries are linked with -z max-page-size=16384 and -z common-page-size=16384 (NDK r27c); the build script and packing check every library with packages/zk/scripts/elf-align.mjs (each LOAD segment aligned to at least 16 KB, GNU_RELRO safe) and fail on a 4 KB-aligned one. Earlier releases shipped 4 KB-aligned libraries. No API change.

Applications and repository (not part of the npm packages) ​

  • Revocation list (CRL) for access certificates (ADR-0087, AR1–AR5; ETSI TS 119 411-8 REV-6.3.9-04). The list publisher issues an RFC 5280 v2 CRL per issuing authority (crl/<authority>.crl, DER, AKI + CRL Number, a reasonCode per entry, nextUpdate 24 hours; re-signed on every publication and on the hourly heartbeat). When a verifier is suspended or revoked its access certificate is revoked in the same publication (privilegeWithdrawn), on retirement with cessationOfOperation, when it leaves the registry with superseded; no certificateHold. An active registration that points to a revoked access certificate stops publication before the list is signed (AR3). New commands crl-status and crl-revoke <access_cert> --reason <code>; state in access-crl-state.json (rebuilt from the published CRL if lost). An offline authority's CRL (the root) is signed on its own computer and only checked and published. Setting national_lists[].roles.access_ca.crl (publisher-internal, not written to the LOTL); enabled in the sandbox registry. Registration certificates keep their own status list (ADR-0068).
  • Access certificate authority in the PKI tools (ADR-0087 K2): ops/gen-pki.ts creates access-ca-1 (root-signed, path length 0, keyCertSign + cRLSign) in the development and sandbox PKI, writes the CRL Distribution Points extension into access certificates, and --root-crl [--revoke=<serial>:<reason>,…] signs the root's CRL (365 days). ops/pki-issue.ts gains --ca <authority> and --crl-uri <url> (mandatory for a production access certificate); the authority certificate of an access certificate issued by access-ca-1 is written to <name>.chain.pem.
  • Governance key separated from the node (consensus) key (ADR-0086, KG1–KG5). Every member record in Governance now holds two addresses: the QBFT node address (validatorAddress) and the governance (vote) address (governanceAddress, with governanceSince). All on-chain authority — proposals, votes, vote and proposal retraction, the delegate list, withdrawal, the SchemaRegistry binding — moved to the current governance address (onlyValidator → onlyGovernor, NotValidator → NotGovernor); the node key has no authority on the chain and leaves the Besu account allowlist (the governance key is listed instead). A member changes its node address with its own governance key, without a vote (setValidatorAddress); the governance key changes only through proposeGovernanceKeyChange (kind GOVERNANCE_KEY_CHANGE): 2/3 of active members (at least 2) and a supporting vote cast with the changing member's current key (KeyChangeNeedsOwnVote), so a majority cannot take over a state's delegate list. An address is used in one state and one role only (ValidatorInUse, KeyInUse); released addresses stay bound to their state. initialize(founders, validators, governors) and proposeStateAdmission(code, validator, governance) take the governance address. Storage: members appended to the mapping-value structs, _governanceToState taken from __gap (37 → 36); the layout check passes, the baseline was renewed (no chain is running). Governance code size 23,872 bytes (headroom 704). Key map tamga-chain-keys/1 gains a governance key per state; local development rule: governance key = Hardhat node account + 10 (deploy-dev.ts, testnet.mjs, make-network.sh, scripts/besu-dev.ps1 — an existing local Besu development chain must be reset). SPEC-BC-0001 §1, ARCH-0002 (open issue 6 closed) and the node handbook updated.
  • Governance command tool, switched off (trust:chain-gov, proposed name): status, show, queue, propose <kind> (admit, remove, key-change, upgrade, anchorer, anchor-threshold, founder-recognition, migration-open/extend/close, schema-deprecate/revoke/hash, network-schema, network-record, rp-reassign, rp-reregister), vote, retract, cancel, execute (an upgrade is queued first and applied after the delay), revote (re-casts last votes that are no longer counted after an upgrade or a key change), set-node, set-delegates, withdraw. Signing is abstract (GovernanceSigner): local development keys and the test/staging key map today; the hardware key store path stops with an explicit message. Writes only to the local and test chain; on the real network it reads and prints the call data. With the flag off it does not connect (--dry-run still encodes the call). A reason text is written only as its SHA-256 digest.
  • Chain health and alarms (trust:chain-health, proposed name; format tamga-chain-health/1): block stall, peers, incomplete continuous-projection run, projection lag over two hours, list anchoring NO / CONFLICT / CONTEST and versions left unanchored for more than two hours; --monitor prints one [!] chain: <CODE> <message> line per problem for an operator's monitoring script. With the flag off: "status": "disabled", exit 0. Exit codes 0 / 4 (warning) / 5 (alarm).
  • Shadow chain setup (network/testnet/shadow-chain.sh): one command on a Linux server sets up an N-validator QBFT test chain with generated keys, mirrors the real network's signed lists and archive read-only (apps/chain-indexer/scripts/mirror-lists.ts, verified), and runs the bootstrap with them (contracts, Governance, permissions, anchoring, migration window + replay of the real archive + equivalence); sync (hourly) mirrors new versions, runs the continuous projection, anchors with each anchorer and checks chain health; report; --dry-run prints every command and runs in CI (testnet workflow, lint job). GUIDE-0018: "Shadow chain" with minimum server requirements, "Chain health" and "Governance command tool".
  • Continuous chain projection, switched off (ADR-0085; list is the source, chain is a witness — ADR-0084). After the migration window has closed, trust:chain-sync (proposed name) turns the difference between the last projected signed list archive and the current one into chain operations with the migration's plan engine — plan(now) − plan(before) — and writes them with block-time dates (hard revocation and status list publication moment keep the list's date). Intermediate states of the same record within one run are merged (only the final state is written); a future-dated record (e.g. an authorisation end) is written in the first run after its time has come; network-level records and network schemas go through Governance proposals; execution checks the final state on the chain, so a repeated run writes nothing; at most 500 writes per run. Only a complete run advances the projection point (<dist>/chain-sync.json, written by trust:chain-replay when the migration finishes without differences); an incomplete run exits 5 and is retried. Writes only to the local development chain and the test/staging chain; there is no write path to the real network. A post-publication hook runs chain-sync and chain-submit after build, heartbeat and anchor only while TAMGA_CHAIN_ENABLED=1; with the flag off it does nothing, and its errors never stop or change list publication. Pure planner planChainSync (apps/trust-publisher), executor executeChainSync (apps/chain-indexer); the replay plan engine takes an optional plan time; the equivalence test takes lag intervals [list date, chain date). Tests: planner and hook without a network; continuous equivalence on the local chain (migration → issuer added, suspension, revocation, merged suspend + reinstate, wallet provider key and access certificate change, status list version, future-dated authorisation end — list = chain at every step). No contract change.

Documents ​

  • ADR-0087 (tr / en / az): revocation list (CRL) for access certificates — suspension, revocation and retirement revoke the access certificate in the same publication, permanent revocation instead of certificateHold, online access certificate authority, 24-hour CRL under the trust-list domain (/crl/<authority>.crl), registration certificates stay on their status list, the Tamga wallet core does not fetch the CRL (rules AR1–AR5). SPEC-TRUST-0001 §2 (file layout) and version note; SPEC-PROTO-0002 §3 request_uri_method row and version note; SPEC-PROTO-0001 issuer_info row (the identity service publishes it too).
  • ADR-0084 (tr / en / az): the signed trust lists are the single, authoritative source in every chain stage and the chain is a witness — verification decisions only from the list, reading the chain only for cross-checking, a stopped chain does not affect lists or verification, every difference raises an alarm; the move is a test network first, then the real network. ADR-0051's provision that in the chain stage "lists are published as the chain's projection" changed; the question ADR-0073 left open is closed; ADR-0074's temporary limit on the chain trust source became permanent (notes in all three, three languages). ADR-0085 (tr / en / az): continuous projection (rules SP1–SP7). Tamga ARF §8.1: the trust anchor stays the signed lists in every phase, the ledger is a witness (release 1.0 archive refreshed). ARCH-0002 (Besu network setup): source direction, the first network with two independent operators (2 × 2 validators), current contract names, applications do not read the chain, test network → real network conditions, monitoring; QBFT open point closed.
  • ADR-0083 amendment (2026-11-13; tr / en / az): K11 and CV7 changed — the code of the chip path may be written now, behind a switch that is off by default (the identity service refuses to run on a server while it is on; store builds of the wallet contain no chip reading; the code runs only in local tests with fake document data). The chip path still opens only after a favourable legal opinion. First version: clone check by active authentication only (chip authentication later); no DG11 on the chip closes the chip path for that document; face matching gives the DG2 photo to the provider as the reference image. Interface names /chip/read, /chip/submit, /chip/continue, PAR field chip_reader. Identity proofing specification (version note), ADR-0011 note, Identity Rulebook wording (release 1.0 archive refreshed).

0.8.4 — 2026-11-12 ​

All ten packages move to 0.8.4 together (patch release). The code change in the packages is in wallet-core (additions only; without the new options the behaviour is that of 0.8.3); the other packages carry the version number and README wording. Published on npm on 2026-11-13.

Added ​

  • wallet-core — copy state and reuse decision for proximity and wallet-to-wallet presentation (wallet rules §4.1, target behaviour decided 2026-11-12). Every proximity session uses a new copy; running out must not leave the person standing at the door. The core gives the decision and the state, the app makes the refresh call and shows the warning:
    • proximityCopies(credential, lowAt?) returns { total, remaining, low, exhausted, refreshable } for the copies that can be shown in proximity (those with an mdoc); planProximityCopy(credential, { online, lowAt? }) adds the action for the table in the specification — present, refresh_first (no copy left, device online), reuse_with_warning (no copy left, device offline), unavailable — and refreshInBackground (few copies left and the credential has a refresh token).
    • presentProximity and presentToPerson carry the state to the caller: copies in the consent view (before the session) and in the result (after), and reused in the result.
    • New option reuseLastCopy: when no unused copy is left, the last copy is reused — only when the caller passes the option, that is after the person accepted the warning that this presentation can be linked to the previous one. Reuse always falls on the same copy (copies shown only in proximity are preferred over one a remote verifier has seen), and the presentation log entry is marked reused: true (PresentationLogEntry.reused). Without the option the behaviour is unchanged: the session ends with an error and no copy is reused; the reason is exported as PROXIMITY_NO_COPY_REASON.
    • selectProximityCopy(credential, { reuseLastCopy? }) and PROXIMITY_COPY_PREFIX are exported for callers that build their own flow. Copy selection in proximity now takes the first unused copy that has an mdoc (before: the first unused copy, which failed the session if that copy had no mdoc while another one did).
  • wallet-core — beforeSend hook in presentProximity and presentToPerson (found by an independent review). The copy was marked as used only in the returned state: if the app stopped while the response was being sent, the mark was lost and the same copy could be given to another reader as unused. The optional hook is called once, after the response is built and signed and immediately before it is sent, with the state in which the copy is marked; the caller saves it. If the hook throws, nothing is sent and the returned state is unchanged. Same contract as respond({ beforeSend }).
  • wallet-core — final identity confirmation in the authorization-code flow (confirmIdentity; ADR-0080). When the identity service returns a masked summary of the verified identity with the token (identity_confirmation: initials and birth year, never full values), completeAuthorized calls the new optional confirmIdentity(prompt) before the credential is requested; the app shows the summary and returns the person's decision. The decision is sent to the identity service (DPoP and the wallet attestation, same as the token request). On false no credential is requested and the error code is the new identity_rejected; the confirmation endpoint must be on the authorization server's origin, otherwise the access token is not sent. Without the option nothing changes — an identity service that requires the confirmation then refuses the credential request. Types IdentityConfirmationPrompt, IdentityConfirmationSummary.
  • wallet-core — sharedBefore(state, rpKey, requested, { vct? }) for the notice about earlier sharing (WL6, wallet rules §4.2): from the presentation log on the device it returns how often and when something was sent to this verifier, the field names shared before with the date each was last sent, which requested fields were shared before (again) and which are requested for the first time (firstTime). Only sent presentations count; values are never returned. The key is the verifier's persistent identity (the registered dns_name); proximity readers and wallet-to-wallet peers have none, so nothing is returned for them.

Changed ​

  • onboard — README: the sentence about provenance now says that the package is published by hand for now (0.8.2 and 0.8.3) and will carry provenance once it moves to the automated release workflow; the command table was reformatted. This wording was written after 0.8.3 was published, so it first ships with 0.8.4. No code change.

Applications and repository (not part of the npm packages) ​

  • Trust list publisher — closing a validity period cannot rewrite the past, and the comparison uses the previous signed list (record removal check, SPEC-TRUST-0001 TL2; found by an independent review). (1) An open period of a scope or a terminal group could be closed with any earlier date, even one before valid_from or in 1970, without an approved removal entry — a retroactive rewrite of what the previous signed list stated. The new end must now be at or after valid_from and at or after the publication time (issued_at) of the previous signed list. (2) Whether a period is still open was decided by the time of the new publication: a row ending on 1 December, closed with end-use on 30 November and published on 2 December, counted as already closed and stopped the build. The comparison now uses the publication time of the previous signed list.
  • Chain stage (contracts; no production chain):
    • ADR-0082: the state of a revoked issuer can correct, change or remove its successor afterwards (IssuerRegistry.setIssuerSuccessor, event IssuerSuccessorSet, error IssuerNotRevoked). Before, the successor was written in one step with the revocation and could not be changed: a wrong successor was permanent, and the status lists froze when an issuer was revoked without a successor or when the successor itself was closed.
    • ADR-0082: the delegate key mapping in Governance is kept per state. A state could block another state's delegate assignment by writing the same key into its own list first (DelegateKeyInUse); the error is removed, and one state's list neither touches nor blocks another's. Only a state's own delegate writes to its records, as before. Storage: slot 2 of Governance is retyped (_delegateToState → _isDelegate); there is no deployed chain, so the storage baseline was rewritten. Governance runtime code 22,880 bytes (1,696 bytes of headroom).
    • Migration window (ADR-0073 implementation note): while the window is open the start of validity (validFrom) must be given explicitly when a root CA, an issuer or a schema is registered; an undated start is rejected except from Governance (DateRequiredDuringMigration). Before, the start silently became the block time, could not be corrected, and every credential issued before that moment was rejected for that record.
    • Votes after a Governance upgrade: verified from the code and by test that an upgrade to a version that records vote times cannot lock itself (the threshold is counted before the upgrade call); other open proposals and queued upgrades wait until the members cast their votes again in the same direction, which is accepted. Written as an explicit step into the contract specification (§9) and the network set-up document (step 11). No code change.
    • Development tools: hardhat 3.20.0 → 3.21.2 and @nomicfoundation/hardhat-ethers 4.2.1 → 4.2.2 (no major change); the remaining npm audit notices (zod through hardhat, glob and minimatch through mocha) have no fix without a major change and affect development tools only.

Documents ​

  • Wallet rules (SPEC-WALLET-0001 §4.1, §4.2; tr / en / az): the wallet-core part of the target behaviour when copies run out in proximity and of the notice about earlier sharing is ready in 0.8.4; the app screens are pending.
  • ADR-0082 (accepted 2026-11-12; tr / en / az): correctable issuer successor and per-state delegate keys (IS1–IS2, DK1–DK2). ADR-0073 implementation note (tr / en / az): the explicit-date rule of the migration window also covers the start of a record. Contract specification: N1, §1, §3, §7.3, §9, §16.1.
  • ADR-0083 (accepted 2026-11-13; tr / en / az): the identity document chip is read over NFC by the wallet that started the flow and verified by the identity service (passive authentication and a clone check); face and liveness stay with a replaceable provider (CV1–CV7). IDP3 is narrowed: a wallet may read the chip and relay the raw data unchanged. No code for the chip path until a legal opinion is favourable. Identity proofing specification (IDP3, §9 document_chip_verified), ADR-0011 note, Tamga ARF (Tamga Rulebook RB-AP-ID-01, Identity Rulebook document_chip_verified; release 1.0 archive refreshed).

0.8.3 — 2026-11-11 ​

All ten packages move to 0.8.3 together (patch release) after an independent review of the 0.8.2 code base (2026-11-10). Published on npm on 2026-11-12.

Fixed after a second review (2026-11-11) ​

A code review of the changes above found the following; the fixes are part of 0.8.3.

  • onboard — check --report / node check --report can be run twice. An earlier change in this release made the report file exclusive-create and wrote it before printing the result, so the second run of the same command failed with EEXIST after all checks had run and the result table was never printed. The result is now printed first, and a report file is refreshed when the existing file is an earlier report of this tool (written beside it and renamed, so a symbolic link is never followed). Any other existing file — another JSON document, a symbolic link — is still never overwritten and gives a clear error; the .json and key-like-name rules are unchanged.
  • trust — fetchListTrustSource refuses an additionalStates entry it cannot load. A state that is not in the LOTL, whose list is not ACTIVE (suspended), or whose code is not two letters was skipped silently and the load stayed healthy, so the caller believed the cross-country name rule (ADR-0075) was in effect with fewer lists than it asked for. Each case is now a TrustListError, as the option's documentation already said.
  • chain indexer — an index without errors resumes; pending errors are retried without a new block. An index saved before the errors field existed failed with retry is not iterable; a missing field is now an empty list. Records whose read failed are retried on the next sync even when the chain has no new block (at the block the index is pinned to).
  • chain replay — event counts scan the chain once. Every numbered plan operation re-read the chain from block 0 in 2,000-block slices to count one event; logs are now collected once per contract and event and only new blocks are read after that. The answers are the same.
  • contracts — a network schema proposal no longer becomes unexecutable when its validFrom passes during the vote. Since the 2026-11-10 change the schema registry refuses a past validFrom outside the migration window, while a Governance proposal stores validFrom when it is opened and sends it unchanged at execution: a proposal opened with the current time (or a date that passes while the vote is open) could never be executed. When the caller is Governance, a start that is already past is now written as the execution time; a later date is kept, and the rule is unchanged for delegates and the migration executor. Source and tests only: an already deployed registry needs a protocol upgrade vote. Until then give validFrom as 0 or a date after the voting period.
  • contracts — an upgrade proposal pins the code it was opened with. proposeProtocolUpgrade stored only the address of the new implementation. The chain runs with Shanghai rules, where SELFDESTRUCT removes code, so an implementation deployed with CREATE2 could be destroyed during the 7-day delay and redeployed at the same address with different code. The proposal now stores the implementation's code hash and execute refuses a different code (UpgradeImplementationChanged), both when queueing and when applying. Storage: one member appended to the upgrade queue struct (a mapping value; __gap unchanged).
  • contracts — Governance has room again and the build checks it. The deployed code was 24,530 of 24,576 bytes (EIP-170), which left no room for a fix. The validator check and repeated proposal checks moved into shared internal functions: 22,881 bytes with everything in this list included; external interface and storage layout unchanged. npm run contracts:check now fails when any contract has less than 512 bytes of headroom.
  • contracts — proposal payloads can be read from the chain. New views on Governance: getSchemaPayload (network schema proposal), upgradePayloadOf (initialiser selector and pinned code hash) and removalReasonOf (reason digest of a removal proposal), so that a voter can read what the vote will execute.
  • contracts — Governance.initialize refuses the zero state code. A founder with code 0x0000 was accepted as an active member.
  • contracts — the migration executor can deprecate only the network schemas it wrote. During a migration window the executor could deprecate any network schema with a back-dated time (deprecateSchemaAt(…, 1)), which rejects every credential issued with that schema and cannot be undone. A network schema registered by Governance can now be deprecated only by Governance; replayed schemas are unchanged (ADR-0073 K1). Same reasoning as the 2026-11-04 change for revocation. Storage: one mapping in SchemaRegistry (__gap 44 → 43).
  • contracts — the schema step of C2 honours validFrom; an authorisation needs a registered schema.isSchemaAcceptableAt ignored validFrom, so a schema registered with a future start accepted credentials from the day of registration; it now requires iat ≥ validFrom (the chain indexer applies the same rule). setSchemaAuthorization(…, true) is refused with UnknownSchema when the schema is not registered. The replay plan skips an authorisation whose schema is not in the archive and moves a window that opens before the schema's first status to that time, with a warning.
  • contracts — removing an anchor writer cannot take the writer count below the threshold. setAnchorer(…, false) is refused with InvalidThreshold when it would leave fewer writers than requiredConfirmations (no anchor could be confirmed after that). Rotate a key by adding the new writer first, or lower the threshold first.
  • contracts — a schema with a future validFrom can be registered while a migration window is open. It failed with DateInFuture, so a future-dated network schema proposal could not be executed during the window. The start is written as given and the first status time is the block time.
  • contracts — withdraw is refused in a network with two active members (ADR-0076, accepted 2026-11-12; narrows ADR-0002 #5). With two members, one member's withdraw left a single member, and a single member cannot execute anything (minimum of 2 votes), cannot admit a member and cannot withdraw: governance was locked for good. Governance.withdraw now reverts with TooFewMembers(active, required) while the network has 2 or fewer active members; leaving a network of three or more members is unchanged (unilateral, no vote). A member that wants to leave a two-member network first has a third member admitted, then withdraws. One error added to the ABI (the copy in apps/chain-indexer is regenerated); function signatures and storage layout unchanged; Governance is 22,918 bytes.
  • contracts — the network is founded by at least two founders (ADR-0076 GC4, 2026-11-12). Governance.initialize accepted a single founder; with one member no proposal can ever be executed and no member can be admitted, so governance was locked from the first block. It now reverts with the existing FounderMismatch error for fewer than two founders. The rule is in the contract, not only in the scripts, and there is no flag for a single-founder set-up: the local development chain, the test network and the tests already used two or three founders. The set-up code refuses the same case before anything is deployed, with a clear message (deployTrustLayer, setupStagingNetwork, MIN_FOUNDERS); a test network key map with fewer than two founders is refused (loadChainKeys, testnet.mjs), and make-network.sh --keys generate writes no key map for a one-validator network (node-level checks only). The number of QBFT validators is a separate matter: the local one-validator chain still sets the contracts up with two founders. ABI and storage layout unchanged.
  • contracts, network — the chain is set up with the Cancun rule set (ADR-0077, 2026-11-12). The genesis generators (scripts/besu-dev.ps1, network/testnet/make-network.sh) write cancunTime: 0 next to shanghaiTime: 0; the contracts are compiled with evmVersion: cancun and the in-process test network runs with hardfork: "cancun". Under Cancun SELFDESTRUCT no longer removes code (EIP-6780), which closes the path behind the "upgrade proposal pins the code" fix above; that check stays as a second line of defence and is now tested by replacing the code with the test node's hook, and a second test shows that a self-destructing implementation keeps its code and cannot be redeployed at the same address. Blob transactions are not used and no KZG option is needed (tried on a one-validator Besu 26.11.0 QBFT network). A local chain created earlier has a Shanghai genesis: delete network/dev/genesis.json and keys/, run npm run chain:besu:init, then chain:besu:reset. The exported ABI copies now say "evmVersion": "cancun"; ABI and storage layout unchanged; Governance is 22,920 bytes.
  • verifier — verifyPresentation returns only the values the policy asks for (required_claims). Technical fields of an SD-JWT VC (iss, iat, exp, vct, category, cnf, status with the revocation index) and claims disclosed beyond the request are no longer in claims (AP3/AP4). An always-visible claim that the policy asks for now counts as disclosed: it appears in disclosed_claims and is checked at E3.
  • verifier — D5 bounds the "token newer than its anchor" case. New policy field freshness.max_anchor_lag_sec (default 3600 s): a status token newer than the latest anchor by more than this, or a list with no anchor on a credential older than this, gives INDETERMINATE / STATUS_STALE. External-list issuers are unchanged.
  • verifier — iss is mandatory for SD-JWT VC of Tamga types (A3b); allowLocalIssuerUrls treats only http://localhost and loopback / private IPv4 ranges as local.
  • verifier — a status key outside its valid_from…valid_to window is not accepted as the status list signer (D3). A cached status body that is not a token gives INDETERMINATE / STATUS_UNREACHABLE instead of REJECTED.
  • verifier — an unavailable external list gives INDETERMINATE, not REJECTED (ADR-0036 FD3): when the chain reaches none of the given roots (A3), or the type is not in the catalogue and the anchor does not resolve to an external institution (B2), and an external list that could vouch for the requested type is unavailable (TrustSource.unavailableExternalListFor).
  • verifier — a throwing or rejecting audit sink no longer fails the verification; E4 is reported in checks_skipped. Async sinks are awaited. With rootCertsDer: "none" (SD-JWT VC) A3 is reported in checks_skipped.
  • verifier — pass tokens with a non-string or over-long (more than 128 characters) jti are rejected (AP13 replay list).
  • sd-jwt — an intermediate CA without the KeyUsage extension is rejected (A3; keyCertSign required). Failure reasons are fixed messages: no header or payload value and no library exception text. VerifyFail.internal marks unexpected internal errors (reported as INDETERMINATE by the verifier). The same holds for the mdoc and ZK paths; an unreadable trust anchor gives INDETERMINATE / CHAIN_UNREACHABLE.
  • Tamga Verify — attempts that end INDETERMINATE before proof of possession no longer turn the presentation into REJECTED at the attempt limit; last_attempt carries outcome and indeterminate_reason. The audit record always matches the stored result (pseudonym rejection, wallet decline, attempt limit). The error of a wallet error response is recorded only when it is a defined OpenID4VP / OAuth error code, otherwise as wallet error.
  • Tamga Verify sample site — a session opens only in the browser that started the presentation (flow cookie); /sample-site/start is rate limited. The sign-in guide states the rule with example code. Optional TAMGA_VERIFY_CLIENT_KEY_HEADER separates rate-limit buckets per client behind the proxy.
  • Tamga Verify — the anchor log must be fresh when the service runs on HTTPS. The service loaded the lists with the directory loader's default (anchor log accepted for 365 days), so a stopped anchor log did not make the trust source stale. With an HTTPS public address (production and sandbox) the limit is now 3 hours (the heartbeat is hourly), set with TAMGA_VERIFY_ANCHOR_MAX_AGE_SEC (seconds). When the last anchor is older, the existing stale path applies: /healthz reports trust.healthy: false and verifications return INDETERMINATE, not REJECTED. With an http address (local development and tests) the behaviour is unchanged unless the setting is given. No package change.
  • trust — a dns_name that appears in two records of one national list is ambiguous (answers null by name and by client id) instead of the second record silently replacing the first; the list schema rejects a trailing dot, leading dot or empty label in dns_name (ADR-0075 RO5).
  • trust — questions that depend on an external list that is active in the LOTL but was not loaded answer UNKNOWN instead of NO / null (isWalletProviderKey, externalIssuerByAnchor); new unavailableExternalListFor(vct) (ADR-0036 FD3). An external entity's revocation-service certificates and supply points are bound only to the issuance service of the same role (FD2).
  • trust — a list version that jumps by more than one but names the last seen version as its predecessor is rejected (TL2).
  • trust-publisher — source records are checked against an allow-list of known fields per record type; unknown or computed fields (client_id, rp_id, issuer_id, ca_id, fingerprints) stop the build instead of being published (TL11, ADR-0034 CI3). build rejects a duplicate dns_name (case and trailing dot ignored) and a list operator that is not provisional with a non-empty on_behalf_of (RO5, TL1).
  • trust-publisher — without provisional-operator.json a production registry is not published; the sandbox exception requires the list operator name to be exactly "Tamga Network Sandbox (TEST)" (ADR-0070 OP2); another name that merely carries "(TEST)" is refused.
  • trust-publisher — the removal guard also counts root CAs, schemas, and — in records that stay — scopes, schema authorizations and status-history rows (TL2). The next version, the previous hash and schema registered_at are read from the signed .jws of the previous publication (signature verified), not from the unsigned .json copy (TL9).
  • trust-publisher — registration commands run under registry.lock, roll the source back when list validation fails, and write the change-log line only after a successful build; the lock is refreshed while held. --reason of status, rp-status and wallet-provider suspend|revoke passes the public-text filter; contact fields are format-checked (TL11).
  • wallet-core — checkRegistrationCerts / relevantRegistrationCerts take the trust of the certificate that signed the request (signerTrust: the relying party's registered access-certificate fingerprint and/or root_cas). When given, a registration certificate is valid only if that certificate is anchored (untrusted_access_certificate otherwise) — a self-signed certificate copying a registered organisation's identifier no longer binds to that organisation's public registration certificate (remote flow and ISO/IEC 18013-7 Annex C; proximity already did this). When omitted, the result carries signerTrusted: false and the registration_binding_unverified flag. A registration certificate without exp is rejected (JWT and CWT).
  • wallet-core — parsePassGrant rejects a consent period over 6 months (single-use tickets excepted), an expired grant and an aud that is neither a domain name nor an x509_hash: identifier (the latter is kept with the aud_not_dns_name warning); optional checks verify the grant signature against the request's certificate, cnf_kid against the wallet's pass key and the relying party's registration. mintPassToken accepts the same trust source.
  • wallet-core — respond gains beforeSend, called after signing and before the presentation leaves the wallet, so copies are marked used before delivery (WL5). presentProximity marks the copy before sending and keeps it marked when the transport fails. respond returns the verifier's redirect_uri only when it is https.
  • wallet-core — http is refused by default: parseOffer rejects http offer addresses and http credential_issuer; Digital Credentials API requests from http://localhost / http://127.0.0.1 are accepted only with allowLocalDevHost (the Annex C branch no longer drops the option).
  • wallet-core — matchDcql and presentProximity no longer offer an expired credential. rpRecordOf and registrarKeysOf read from an already verified trust source; fetchRpRecord / fetchRegistrarKeys accept { throwOnListError: true } to tell "list unavailable" from "not registered".
  • wallet-core — TS10 export uses 600,000 PBKDF2 iterations by default and refuses fewer than 200,000; import refuses files with fewer than 100,000.
  • wallet-core — HardwareKeyProvider.attestation() reports the device secure area (Secure Enclave, StrongBox, TEE) as W2 and software as W1; W3 is never reported. A failing backend info() is no longer cached and no longer falls back to software keys silently (hardware_unavailable); a failed hardware key deletion is reported to the caller.
  • docs — SPEC-API-0001, SPEC-TRUST-0001, SPEC-WALLET-0001, ADR-0036 / ADR-0070 / ADR-0075 implementation notes and the sign-in guide updated in tr / en / az. SPEC-WALLET-0001 WL13 now states the exception the code already had: a single-use ticket is exempt from the 6-month consent ceiling (its grant ends when the event ends, ADR-0012 K4).
  • docs — decisions of 2026-11-12 (tr / en / az; no package change). ADR-0078: the wallet takes no backup — credentials are bound to the device's hardware key and are issued again on a new device; the only thing that leaves the device is the migration file started by the person (EU TS10; no credential values, no keys). SPEC-WALLET-0001 (WL2 and §1.4, §7) and Tamga Rulebook RB-WP-07 now describe this; the seed-encrypted backup and the hosted store in the earlier text were never built. ADR-0079 (accepted, implementation before a second state joins): a state may authorise its institution for another state's national schema only with a consent record written by the state that owns the schema; today the contract does not check this. ADR-0080 (accepted, implementation before identity verification is opened to everyone): a final confirmation in the wallet with a masked summary of the verified identity, and a warning to the person doing the verification, against a relayed verification link. ADR-0070 OP2 now states the sandbox exception in the rule text (list operator name carries "(TEST)", published as "Tamga Network Sandbox (TEST)"). SPEC-WALLET-0001 implementation notes: the "previously shared" notice of WL6 is not implemented yet (first wallet update); target behaviour when copies run out in a proximity session (background refresh, immediate refresh when online, reuse of the last copy with a warning when offline) is recorded as pending.
  • docs — SPEC-WALLET-0001 §2.3: the PIN attempt rule now describes the wallet as built (approved by project management, 2026-11-12). After the 5th wrong attempt in a row the wait starts at 30 s and doubles with every further wrong attempt, up to 1 hour; the counter survives an app restart and a clock change. The wallet is not erased or locked for good after 10 wrong attempts, as the text said before: a forgotten PIN is handled by the person resetting the wallet, confirmed with the phone's own lock (§7.6). tr / en / az.
  • trust-publisher — an approved removal entry is bound to one version transition (TL2, ADR-0081 implementation note). registry/removals.json entries now carry previous_version (required: the number of the signed list version before the removal) and optionally previous_version_hash (the digest of that version's .jws); the publisher accepts an entry only when the previously published version is that one. Before, an entry matched on the list name and the counts only, so the entry of 2026-11-11 would also have let through a later removal of the same number of other records and written the old reason to the list's change log. That entry is now bound to the transition from version 240 to 241. An entry without previous_version (the earlier format) matches nothing.
  • trust-publisher — history rows are kept with their content, and more removals are counted (TL2). In a record that stays in the list, every status_history row of the previous version must be present unchanged in the new one (compared canonically): changing a row — for example moving the invalidates_from of an existing REVOKED row forward — counts as removing it. A schema authorization row must stay as it was; the only free change is closing an open period (valid_until absent → a date), so a closed authorization can no longer be reopened or its end date changed. Before, rows were recognised by two fields only and such edits were not seen. Also counted now: an issuer's delegate_keys rows (by fingerprint and purpose) and the national_lists, wallet_providers (with their status history) and external_lists records of the LOTL; removal entries carry them as optional counts of the same names. What the registry commands write (status, rp-status, authorize, authorize --revoke, scope, end-use, wallet-provider) passes unchanged. Operating note: when a status list key is renewed, keep the old key in the issuer's delegate_keys with a valid_to date instead of dropping it.
  • trust-publisher — the public-text filter accepts an ISO date. --reason "key compromise 2026-11-12" was refused as a "phone or identity number"; a valid calendar date (YYYY-MM-DD) with no digit or hyphen next to it is no longer counted as a digit run. The other rules are unchanged: two capitalised words in a row (Contract Ended) are still read as a person's name — write the reason in lower case.
  • trust-publisher — the "previous list could not be verified" message no longer suggests removing the publication folder. On the real network that would restart the list at version 1 and break the hash chain and the removal check. The message now says: never remove the folder on the real network; when the list signer changes, keep the old signer in the source (signing_certs / anchor_signing_certs) for one publication. Removing the folder is for local development only.
  • verifier — a status list signed with a registered but lapsed status key gives INDETERMINATE, not REJECTED (D3). When an institution renews its status key, a verifier's cache can still hold a list — inside its own validity — signed with the old key. If that key is still in the trust list but outside its valid_from…valid_to window (or RETIRED), the result is now INDETERMINATE / STATUS_STALE and the next prefetch settles it; before it was REJECTED D3 once a new key was registered (and INDETERMINATE only when there was none). A signer that is not registered, or a REVOKED / SUSPENDED key, is still REJECTED. The same rule applies to identifier lists.
  • verifier — operating note for D5 (freshness.max_anchor_lag_sec, default 3600 s). The anchor log must be reloaded more often than max_anchor_lag_sec: a verifier that keeps refreshing status lists but holds the anchors it loaded at start-up answers INDETERMINATE / STATUS_STALE at D5 for every credential after about an hour. A verifier that loads its trust source without anchors (fetchListTrustSource without anchors: true, the default) has no anchor for any list and gets the same answer for every Tamga credential with a status entry that is older than max_anchor_lag_sec: verifiers that check revocation must load with anchors: true. Example 02 (examples/02-verify-own-server) loaded the lists once; it now exposes refresh() (trust lists and anchors, then the status lists) for a timer, and trust returns the set in use. The server guide and the troubleshooting page say the same (tr / en / az).
  • verifier — a nested path requested from an always-visible object is reported under the requested path (E3). When the policy asks for address.country and the issuer left the whole address object undisclosable, disclosed_claims carried the root name address, and a relying party whose registered scope is address.country was REJECTED at E3 for a legitimate presentation. The requested path itself is now reported and checked.
  • verifier — PassRegistry.issue refuses a pass longer than 6 months (WL13). valid_days must be a positive number of at most PASS_MAX_VALID_DAYS (184, the same limit as wallet-core's PASS_GRANT_MAX_VALIDITY_SEC) unless the pass is single_use; before, a longer pass was issued and the 0.8.3 wallet discarded it.
  • Tamga Verify — one audit record per response at the attempt limit. The last failed response of a presentation that closes on the attempt limit wrote two records with the same verification_id (the attempt and the closing result); now only the closing record is written (also on the ISO/IEC 18013-7 Annex C route). The sample site's flow cookie is re-sent on every start, so its Max-Age is extended together with the server-side flow. SPEC-API-0001 §2.3 now states why an internal error after the presentation has been used up is reported as INDEXER_STALE with an empty failed_step (the closed set has no "internal error" value; no new value was added).
  • wallet-core — migration note for applications (0.8.2 → 0.8.3): the application must be updated, not only the package. (1) http and local development: parseOffer refuses an http offer address or credential_issuer (invalid_offer), and respond drops an http redirect_uri. An application that issues or presents against a local development server (localhost, .test / .local, a private IPv4 address) must pass { allowLocalDevHost: true } to parseOffer and allowLocalDevHost: true in the respond input — in a development build or on the sandbox only. (2) Registration certificates: checkRegistrationCerts / relevantRegistrationCerts called the 0.8.2 way, without signerTrust, still return valid: true — the check stays open, and the only signal is signerTrusted: false with the registration_binding_unverified flag. To get the protection the application passes signerTrust (the relying party's access_cert_fingerprint_sha256 from its trust-list record as registeredFingerprints, {} when there is no record, and/or root_cas) and does not treat a result with signerTrusted: false as valid. (3) Authorization-code issuance with an identity presentation: the institution returns the result (code or error) in redirect_uri on the wallet's own callback address, which is usually an app scheme and not https. respond returns such an address only when the application passes it as the new callbackUri input (exact address, optionally followed by a query or fragment); without it redirectUri is undefined and the issuance cannot be completed.
  • contracts — the migration executor adds a version hash only to a network schema it replayed itself.SchemaRegistry.addSchemaContentHash on a network schema registered by Governance now reverts with NetworkTierRequiresGovernance for the executor (the same limit as deprecation): it could otherwise add a content hash nobody voted on (hashes cannot be removed) or fill the hash quota. The in-process test network is now really Cancun (Hardhat 3 names it default; the hardhat entry was never used and the tests ran with a newer rule set). ABI and storage layout unchanged. SPEC-BC-0001 §16.1 and ADR-0077 (implementation note) updated.
  • docs — SPEC-CRED-0003 §7 step Ş6 follows the D5 definition of SPEC-API-0001. The step still said "REJECT when the token digest differs from the anchor" and referred to a version field the token does not carry; it now lists the D5 cases (older token: rollback or prefetch delay; newer token: allowed up to max_anchor_lag_sec; no anchor). Ş4 and S11 state the lapsed-key case (tr / en / az).
  • trust-publisher — the validity period of a scope and of a terminal group is protected (TL2). In a relying party that stays in the list, scopes and terminal_groups rows were compared by identifier only, so an ended use could be reopened or extended by editing its dates. A row that stays keeps its valid_from; valid_until may only move towards closing a period that is still open (no end, or an end that has not passed, set to an earlier time — what end-use, rp-status REVOKED|RETIRED, re-registration and reassignment write). A period that has ended is not changed, and no end is moved later or removed: a new period is a new row with a new identifier. A row changed in any other way counts as removed (scopes / terminal_groups) and stops the build unless an approved removal entry covers it. Descriptive fields (purpose text, translations, requested claims, label, policies) can still be edited. The check is not applied in the sandbox, as before. SPEC-TRUST-0001 (TL2 implementation note) updated (tr / en / az).
  • trust-publisher — the 2026-11-11 removal entry carries the digest of the version it applied to.registry/removals.json now has previous_version_hash (sha256: + 64 hex digits, the form the publisher computes for the previous signed version) besides previous_version; the comment in the source named the form sha-256:.
  • contracts — a re-admitted member's earlier votes are no longer counted. When a member that withdrew or was removed was admitted again with the same validator address, its "for" votes on proposals that were still open counted again without the member voting. A vote is now counted at execution only if it was cast after the member's latest admission; the member casts its vote again (a vote from the earlier membership period can be repeated in the same direction without AlreadyVoted; the raw forVotes / againstVotes counters do not change). ABI unchanged. Storage: one mapping in Governance (vote time; __gap 38 → 37, layout baseline updated). Governance is 23,121 bytes (1,455 bytes of headroom). Source and tests only: an already deployed Governance needs a protocol upgrade vote, and votes cast before that upgrade have no recorded time, so they are cast again on proposals that are still open. SPEC-BC-0001 §1 updated.
  • docs — the pass grant limit is written as a number. The code allows 184 days (PASS_MAX_VALID_DAYS, PASS_GRANT_MAX_VALIDITY_SEC); the wallet specification said "≤ 6 months". SPEC-WALLET-0001 (§ on the pass grant and WL13), the education rulebook and the limitations page now say "at most 6 months (184 days)" (tr / en / az). No code change.
  • docs — the result example of SPEC-API-0001 §2.2 matches the reference implementation. The example listed A3c (certificate revocation query) and B5 (extends chain) under checks_performed; the reference verifier does not perform these two steps and reports them in checks_skipped for every presentation. The example now shows that, with E4 under checks_performed (audit record written), and a note explains it (tr / en / az). No code change.
  • docs — key backup while the network has two members (ADR-0076 implementation note). In a two-member network the loss of one member's governance key means that no proposal can pass and the member can neither be removed nor withdraw. Operating rule: until a third member joins, every member keeps a backup of its governance key, stored in a separate place and tested by restoring it. Written into ADR-0076 (tr / en / az), the Besu network set-up document (step 11) and the test network guide.

Correction to the 0.8.2 notes ​

The 0.8.2 entry said that wallet-core's fetchRpRecord "applies the cross-country name rule on the x509_hash: path too" and presented this as a fail-closed behaviour change. That statement was misleading: fetchRpRecord loads the LOTL and one national list (stateCode), and the rule only compares records across the national lists that are loaded. With a single list loaded, an ambiguity with another country's list cannot be seen, so the 0.8.2 change had no effect for the wallet in practice; its test built a multi-list store by hand that the real loader never produces. What is true as of 0.8.3: the rule lives inside ListTrustSource (both lookups), it is tested through the real loader with two signed lists, and it takes effect for callers that load several national lists (the reference verifier, the onboarding tool, fetchListTrustSource with additionalStates). The wallet's single-list scope is now documented in the code.

Behaviour changes in 0.8.3 (fail-closed) ​

  1. trust — ListTrustSource.relyingParty(clientId) returns null for an ambiguous name (ADR-0075). The cross-country rule (the same dns_name not revoked in more than one loaded national list, or no structured reassignment record) was applied only by relyingPartyByDnsName; a lookup by client identifier returned the record. Both now answer null. Affects callers that load more than one national list.
  2. issuer — WalletStatusChecker counts status list entries from the list's own bits. The minimum-size rule (10,000 entries, CIR 2026/1731 Annex Ib) computed entries as bytes × 4, which is right only for 2-bit lists: a compliant 1-bit list of 10,000 entries was reported NONCOMPLIANT, and a 4-bit or 8-bit list half or a quarter of the required size was accepted. The count is now bytes × 8 / bits.
  3. onboard — --report never overwrites and refuses key-like targets. check --report / node check --report wrote the report over any existing file. The file is now created with exclusive create (an existing file is an error), must end in .json, and a name that looks like a key or certificate file is refused.

Added ​

  • trust — fetchListTrustSource option additionalStates. Loads further national lists besides stateCode so that the cross-list rules can take effect; every listed state must have an ACTIVE list that verifies (a missing one refuses the load).
  • verifier — verifyPseudonym option clientStatus ("optional" default, "required"): with "required" a wallet instance attestation without a revocation entry (client_status) is refused, so a wallet unit that cannot be revoked cannot log in with a site pseudonym. Tamga Verify uses "required" on the real network.

Fixed ​

  • onboard — icacls is called by its full path (%SystemRoot%\System32\icacls.exe) when a private key file's permissions are narrowed or checked on Windows; calling it by name let a planted icacls.exe earlier in the search path run.
  • verifier — comment on RequestBranch.branchId: uniqueness within a presentation is not guaranteed by createRequestBranch (48 random bits); BranchSet is the unit that keeps branches apart.

Applications and repository (not part of the npm packages) ​

  • Tamga Verify — branchless Digital Credentials API response path. The response key identifier for this path (enc-dc-<presentation>) derives from the public presentation identifier. A presentation without a DC API request now answers such a response with a cheap 400; with one, the response is decrypted first and only a response that decrypts is charged to the presentation's rate bucket and single-use lock (also on the ISO/IEC 18013-7 Annex C endpoint). Before, junk responses from anyone who saw the QR could exhaust the bucket and hold the lock against the page's real response.
  • Tamga Verify — /healthz chain field returns a fixed reason when the chain cannot be reached or is misconfigured; the error detail (which may carry an RPC address) goes to the service log only. English sandbox guide links point to the site root.
  • Trust list publisher — record removal is checked (SPEC-TRUST-0001 TL2). A build stops when an issuer, relying party or terminal group of the previously published national list is missing from the new one, unless the registry carries an approved removal entry with exactly matching counts (registry/removals.json); the public changelog of the list then gets a line without names. Used once: test records left from the pre-pilot test period were removed from the real network's list (2026-11-11).
  • Chain stage (contracts, indexer, node tooling; no production chain):
    • RelyingPartyRegistry.stagePeriodChange requires a registered identifier; TrustListAnchorRegistry.anchorLogHead caps the sequence step (as list versions already were); SchemaRegistry.registerSchema no longer accepts a past validity start outside the migration mode; deployment verifies the Governance → SchemaRegistry link.
    • Governance: a member can change its vote (vote to the other side) or take it back (retractVote) until the proposal is executed, including a queued upgrade during its delay; the threshold is recounted at execution.
    • Indexer: reacts to state-changing events only (staging events that anyone can emit no longer make it read a record that does not exist and stop), a record whose read reverts is recorded as an error instead of stopping the cursor, events are read in chunks of at most 2,000 blocks with the cursor advancing per chunk (also in the replay's "already written" checks), and an index resumed against another chain id, other contract addresses or a shorter chain is refused.
    • ChainTrustSource: healthy only when the caller binds it to content (level projected on chain ≥ level of the signed lists) and the index has no unreadable record — otherwise every answer is UNKNOWN; a status list lookup whose last path segment is shared by two issuers no longer returns the other issuer's anchor; a terminal group whose institution is not in the index is inactive. It must not be used in verification until an ongoing projection exists (ADR-0074 K5 note).
    • Equivalence test: a reverse pass (every indexed issuer, authorization, relying party, terminal group, status list and wallet provider key must be in the signed lists or never have been active), comparison of the index against the replay plan's record set, and cheap record fields (certificate fingerprints, registration periods, gate certificates, offline flag).
    • Besu allowlist reader accepts IPv6 enode addresses; the JSON-RPC filter forwards the request it parsed and checked instead of the client's bytes (repeated-key bodies) and refuses net_enode / net_services; make-network.sh --keys dev (public test keys) is refused with non-loopback hosts.
  • Release workflow: GitHub Actions are pinned by commit SHA and the npm CLI by exact version.

Documents ​

  • ADR-0073 (the migration window closes by itself regardless of the equivalence result; failure means redeploying; keep it short and close early), ADR-0074 (read path wording; content-bound health; not consumed in verification yet), ADR-0055 (vote change and retraction), ADR-0067 (real cost of the eviction attack; proxy burst lowered), ADR-0075, the chain test network guide and the node operator handbook (governance and consensus key are the same key today — HSM required on the real network, separation is an open decision), trust list specification (record removal check; contact is a role address).
  • ADR-0081 (accepted 2026-11-12): the test-record exception to "no record is deleted from the trust list" (SPEC-TRUST-0001 TL2) is tied to a decision. Only a record entered for testing, which never issued to a real person and never received a real presentation, may be removed, before the first participant institution enters the real network's list and with the reason in the public changelog; the exception closes with the first institution; signed list versions stay in the archive. The trust list specification (§4, TL2) refers to it. No code change.
  • Four deviations left from the document–code scan are closed on the document side (2026-11-12; no behaviour change): verification pipeline specification — in a ZK presentation C1/C2 are asked at proof time, written into AP11 as an explicit exception (ADR-0032 implementation note); C4 is not applied to mdoc and ZK presentations and the issuer class is read from issuer.class (ADR-0010 implementation note); the reporting of A3d and A8 under neighbouring codes is the binding behaviour of the reference implementation (ADR-0056 implementation note); trust list specification — the designated operator status is reserved for the handover: the loader recognises it, the publisher does not publish it in the list stage (ADR-0070 implementation note).

0.8.2 — 2026-11-05 ​

All ten packages move to 0.8.2 together (patch release). New: the first publication of @tamga-network/onboard, the joining tool for institutions and for state / operator nodes (it was built and checked with 0.8.1 but not published). One change in wallet-core refuses more (below); no API change in the other packages. Published on npm on 2026-11-05.

Behaviour changes in 0.8.2 (fail-closed) ​

  1. wallet-core — fetchRpRecord applies the cross-country name rule on the x509_hash: path too (ADR-0075). In 0.8.1 the lookup by dns_name returned null for a relying party whose name is ambiguous between national lists (no structured reassignment record), but the lookup by client identifier read the record directly. Now both return null: the request is treated as unregistered ("not found in the trust list" warning; a request that needs a registration is refused). A properly reassigned name (old record REVOKED with reassigned_to) still resolves. Nothing to migrate.

Added ​

  • onboard — new package @tamga-network/onboard (command tamga-onboard; first published in 0.8.2). An onboarding tool for an institution's IT team: init builds the registration application(s) from the institution's answers and checks them with the same rules as the operator's registration tool (ADR-0024; no unknown fields, so no names of people); validate checks an application; keys generates the institution's P-256 keys on its own computer and writes CSRs whose subject carries the organizationIdentifier (ADR-0050) and, for an access certificate, the DNS name and support address (ADR-0058 AC1) — keys --inspect checks a CSR made in an HSM; check checks the institution's own setup (keys ↔ CSRs ↔ certificates, domain and DNS TXT confirmation, https addresses, own-service metadata, lookup endpoint probed with invalid requests only) and, with --listing, its record in the signed trust list against embedded root pins (status, registration data, credential types, status list anchor, registration certificates, metadata chain to the listed root); sandbox prints the "Try your institution" steps. tamga-onboard mcp offers the same operations as a local MCP server (stdio; files only under its root, private keys never returned, network text marked untrusted). Nothing is written to the network or the list. First publication in 0.8.2, by hand without npm provenance (trusted publishing from GitHub Actions can only be set up for a package that already exists on npm); later releases come from the release workflow.
  • onboard — node steps for a state or operator (tamga-onboard node init | declare | check; ADR-0052). node init generates the Besu node key (secp256k1, Besu key file format) on the node's own machine with the same key file protections as keys (owner-only permissions, refused in a cloud-synced folder, never overwritten), prints the enode public key and the validator address, and writes a besu.toml template: permissioned mode, JSON-RPC on 127.0.0.1 only (outside clients get ETH, NET, WEB3 through network/rpc-proxy), P2P on one internal interface (p2p-interface; 0.0.0.0 / :: are refused), discovery, WebSocket and GraphQL off; genesis is not generated — it comes from the operators and its hash is compared out of band. node declare writes the tamga-node-declaration/1 file, validated with the same rules as the schema (contact is a role address; a non-role mailbox gets a warning). node check checks the running node read-only — only read-only JSON-RPC methods are called: sync and genesis against a reference endpoint, peers, running key, node and account allowlists against the rendered file and the reference endpoint, validator set, the external endpoint refuses admin_/perm_/qbft_/ debug_/txpool_, besu.toml interfaces and permissioning flags, clock. Only addresses typed by the user are contacted; loopback is allowed by default, other private networks need --allow-private, plain http only to local addresses, no redirects. MCP tools generate_node_key, create_node_declaration, check_node (key never returned; loopback / private endpoints only when listed in TAMGA_ONBOARD_PRIVATE_NODES; network text marked untrusted). Nothing is written to the chain, the allowlist or the network. New dependency: @noble/hashes (Keccak-256 for the node address).

Security (second review, 2026-11-04) ​

  • onboard — paths stay inside the onboarding folder. onboarding.json is validated before use (a broken profile stops the command); application file names must be <slug>.issuer.json / <slug>.rp.json and key names issuer-… / rp-…; every path is checked after symbolic links and Windows junctions are resolved (nearest existing parent), in the CLI and in the MCP server's root check. MCP validate_application reads only *.json and does not echo parse errors.
  • onboard — no requests to local networks. check follows redirects itself (scheme checked on every hop, at most 5) and refuses loopback, private, link-local, CGNAT and IPv6 unique-local addresses after name resolution, at connect time (--allow-private in the CLI for local tests; not available over MCP). Over MCP, request addresses outside the institution's domain are reported as a warning row.
  • onboard — private key files. On Windows the key file is created empty, narrowed with icacls and only then written; if icacls fails the file is removed and the command stops. Keys are not written under OneDrive / Dropbox / Google Drive / iCloud folders without --allow-synced; on Windows an unencrypted key needs --no-passphrase; a passphrase has at least 12 characters, and over MCP the passphrase variable name must start with TAMGA_.
  • onboard — trust list checks. Root pins can no longer be overridden over MCP; a --pin given in the CLI is reported as a warning row. Registration certificates listed in the unsigned wrprc/index.json are now downloaded and their signature is verified against the registrar keys of the signed list (row H5, also for verifiers).

Applications and repository (not in the npm packages) ​

  • release — packages may ship a command (bin). The pack script maps bin to lib/ and requires a #!/usr/bin/env node line; the smoke test runs each command with --version from the installed tarball. release:version now sets ten packages.
  • ops — pki-issue --org-id accepts a CSR that already carries the same organizationIdentifier (as tamga-onboard keys writes it); a different value is refused (exit 2). Before, any organizationIdentifier in the CSR subject was refused when --org-id was given.
  • Security (second review, 2026-11-04) — ops — pki-issue reads the CSR subject as an ASN.1 name, not as text. Only CN, OU, O, organizationIdentifier and C are taken, each at most once (two organizationIdentifier values, unknown attributes and multi-valued RDNs are refused); the certificate subject is rebuilt from these fields. With --prod, --org-id is required for every certificate and must equal the value in the CSR. Signing with the production root needs TAMGA_CONFIRM_PROD=<institution slug> matching the certificate name.
  • Security (second review, 2026-11-04) — trust-publisher — registration checks the certificate's institution number.register compares the certificate's organizationIdentifier (ASN.1, not text) with the application's identifiers (issuer certificate, status list certificate and a verifier's own access certificate); on the production registry a certificate without it is refused. Writing to the production registry (register, status, authorize, scope, rp-status, end-use without --check) needs TAMGA_CONFIRM_PROD set to the slug or DNS name of the record.
  • Security (second review, 2026-11-04) — repository — *.key.pem is ignored in every folder.
  • chain — test network path C: Governance with generated keys (GUIDE-0018; network/testnet/, CI job staging; production chain still off). make-network.sh --keys generate now uses chain id 31339 (31337/31338 stay the local ids of the public test keys and are refused in this mode; --keys dev refuses 31339) and also generates the role keys of a key map keys/keys.json (tamga-chain-keys/1: deployer, migration executor, two list anchorers with threshold 2, one delegate per state; validator = node key; every file 0600; genesis balances and the start-up allowlist hold only generated accounts — no Hardhat account). Test and staging networks only: production keys are generated by each state on its own hardware and kept in HSMs. New contracts/scripts/deploy-network.ts (npm --prefix contracts run deploy:network, Hardhat network besuStaging, URL TAMGA_CHAIN_RPC_URL, chain id from the key map; scripts/lib/network-setup.ts): founders and their delegates, founder recognition by Governance vote (proposeFounderRecognition), list anchor registry administered by the Governance contract → deployments/besuStaging.json; refuses 31337/31338 and every non-test id. New network/testnet/bootstrap-governance.sh (idempotent, each step logged): deploy → admission of the other states by 2/3 vote (each sets its delegate) → permissions rendered from the chain on every node (the deployer drops out; an unlisted key is refused) → anchoring by both anchorers → migration windows opened by vote, permissions rendered again with the window's executor listed → sample archive replayed with the key map → equivalence; --only permissions for one-node-per-server layouts. trust:chain-replay writes to the test/staging chain with TAMGA_CHAIN_KEYS + TAMGA_CHAIN_DEPLOYMENT (the real network keeps the TAMGA_CONFIRM_PROD gate and still stops) and gains --open-only; besu-smoke.ts --archive-dir keeps and reuses its archive; testnet.mjs gains check-keymap and admit/accounts --keys. Reference loader apps/chain-indexer/src/chain-keys.ts (refuses a map that is not purpose: "test", not on 31339, or whose key file is missing, readable by others or belongs to another address); contracts test staging-setup.test.ts (557 equivalence questions, no decision difference). CI job staging: 4 validators under systemd with generated keys (heap -Xmx640m through a unit drop-in), the bootstrap end to end, then a second run that must write nothing. ADR-0052: dated note — the executor of an open migration window is on the account list (the decision is unchanged).
  • chain — Linux multi-node Besu test network (network/testnet/, CI testnet.yml; production chain still off). Bash scripts (shellcheck-clean): install-besu.sh (Temurin JDK 25 + Besu 26.11.0 from the official release pages, sha256-pinned; --system installs root-owned binaries in /opt/tamga-besu, a besu service user and /var/lib/tamga-besu), make-network.sh (4 QBFT validators + 1 extra node by default: genesis extraData, static peers, start-up permissions file, node declarations, one besu.toml per node with JSON-RPC on 127.0.0.1 and p2p-interface set; --keys generate uses besu operator generate-blockchain-config, --hosts one node per test server), node.sh (process or systemd mode), besu@.service (hardened unit) and deploy-and-wire.sh, the end-to-end test: contracts → list replay and equivalence → trust:chain-submit / chain-check → Governance admission of the other validators' test states → permissions rendered from each node's own chain view, reloaded and checked (equal shared_sha256) → validator added and removed by QBFT vote → one stopped validator does not stop the chain, two do, restart resumes → RPC protection (rpc-proxy-check.sh: method filter and nginx mutual TLS). The GitHub Actions workflow runs it on ubuntu-latest (manually, weekly and on chain code changes) plus a systemd job, and writes the results to the job summary. Chain id 31338 and Hardhat's public test keys — test only.
  • chain — Besu local permissioning and operations (ADR-0052; production chain still off).
    • npm run trust:chain-permissions -- render reads Governance, IssuerRegistry, TrustListAnchorRegistry and the open migration windows at one pinned block and writes a deterministic permissions_config.toml (sorted, unique, lower case, LF; no block number or time — the same chain state gives the same bytes): accounts = active members' validator addresses and delegate keys, delegates of operational issuers, list anchorers, the executor of an open migration window; nodes = the declared validator nodes whose key matches an active validator address in Governance (plus, with --operator <CC>, that operator's own RPC nodes). It prints sha256 and shared_sha256 (without the operator's own RPC nodes — must be equal on all validators). check compares the node's perm_getAccountsAllowlist / perm_getNodesAllowlist with the expected list (loopback admin endpoint only); exit 3 on a difference or a rejected declaration. There is no option to add an account by hand. Read-only on the local development chains while TAMGA_CHAIN_ENABLED=0.
    • network/permissions/: node declaration format tamga-node-declaration/1 (JSON schema, examples; state code, role validator | rpc, node public key, IP literal, P2P port, institutional contact — no personal data) and the matching rule.
    • scripts/besu-dev.ps1 -Permissioned (-Init, -Start [-Node 2], -Apply, -Stop, -Reset, -Status): a local two-node network with both permissioning flags on and PERM/ADMIN on 127.0.0.1 only; -Apply renders each node's list from the chain, reloads it and checks it. Tried locally: an unlisted account is refused ("Sender account not authorized"), a state delegate writes; a node removed from the list is disconnected; node 2 is added to and removed from the QBFT validator set by qbft_proposeValidatorVote (apps/trust-publisher/scripts/besu-permissions-smoke.ts). Besu rewrites the permissions file in its own format on reload, so the rendered file is kept next to it and compared with check. Fix: the local P2P port now binds to 127.0.0.1 (p2p-interface; p2p-host is only the advertised address).
    • network/rpc-proxy/: nginx example with TLS 1.3 and a mandatory client certificate, and filter.mjs, a dependency-free JSON-RPC method filter (only eth_*, net_*, web3_* without the signing, mining and subscription methods; one refused call refuses the whole batch; body and batch limits; only refusal counts are logged), a systemd unit example and a local test certificate script.
    • Verifier /healthz has a chain field (C32 (7)): whether the loaded lotl.jws / tl-<cc>.jws are anchored on chain (YES / NO / UNKNOWN). With TAMGA_CHAIN_ENABLED=0 and in the sandbox it is UNKNOWN without connecting; it never changes ok or a verification result (CH1).
  • chain — reading and transfer side (ADR-0073 K1/K6, ADR-0074 K4/K5, ADR-0075; production chain still off).
    • npm run trust:chain-replay replays the signed list archive into the contracts: it verifies the archive (signatures, version chain, anchor chain, environment), builds a deterministic plan starting at the first archived version and prints it with its replayPlanHash (default and --dry-run); when writing it checks that every migration-capable registry has its window open with this digest, writes in time order with the dates from the lists, skips what is already on chain (resumable), uses the state delegate for national records, the single migration executor for network schemas and wallet providers, and a Governance vote for network schema revocation and relying party reassignment / re-registration. It ends with the equivalence test. Writing to a non-local chain needs TAMGA_CONFIRM_PROD=<plan digest>; a sandbox set is refused outside the local development chain.
    • New application apps/chain-indexer/: event-based indexer (events find the changed records, the records are read at the same pinned block into a plain-JSON index) and ChainTrustSource, the TrustSource interface answered from the index with the contract rules (C1/C2/C3/D5). ethers stays in the application; the packages/* libraries take no chain dependency.
    • Equivalence test contracts/test/chain-equivalence.test.ts (Hardhat, runs in CI; the contracts job now installs the root packages): a multi-version fixture archive (suspension and reinstatement, soft and hard revocation, retired root with successor, schema versions, deprecated and revoked schemas, authorisation windows, recognition on and off, wallet keys, scopes, terminal groups, re-registration after revocation, reassignment between two states) is replayed and the same 493 questions go to the list source, the chain source and direct contract reads: no difference in C1/C2/C3/D5; one documented known difference (the same dns_name left in two state lists after a reassignment — the list source treats it as ambiguous). Local Besu smoke script apps/chain-indexer/scripts/besu-smoke.ts.
    • trust:chain-submit also anchors the new anchor log lines (tamga:trust-list-view:<env>:<file>, tamga:registration-status:<env>:<name>) and refuses a sandbox set outside the local development chain (ADR-0074 K7); trust:chain-check also checks a view file or the registration certificate status list. The trust list publisher writes the new lines only while the chain projection is on (TAMGA_CHAIN_ENABLED=1).
    • contracts/scripts/export-abi.mjs also exports the registry ABIs to apps/chain-indexer/src/abi/ (contracts:check).
    • Phase D remainder (2026-11-05). Relying party suspensions, reinstatements and revocations are replayed with the list date (new contract functions below); the issuer successor (successor_id) is written with the revocation when it is an active issuer of the same state at that moment (otherwise a warning); all other NetworkRegistry record kinds are replayed from the LOTL and the national lists (ZK circuits, external lists, EAA categories, list signers, list operators, state and role slots, catalogue — apps/chain-indexer/src/network-records.ts; a record that leaves the list is written RETIRED). The status list's bit count and size come from the anchor line, else from the token at the list address (https, sub must match), else the default — refused on a real network. The indexer keeps every field and the status history of network records and the issuer successor; ChainTrustSource gains isRelyingPartyAcceptableAt, zkCircuit, networkRecord, registrationPeriods. The equivalence test also asks about a relying party's status at past moments, the issuer successor and every network record kind: 557 questions, 0 differences, no known difference left (the gap between the list date and the execution date of a reassignment / re-registration is not asked: ADR-0075 dates it at execution).
    • trust-publisher: anchor --token <file> writes the status list's bits and size from the token (its digest must equal --content-hash and its sub the --list-uri); rp-status <dns_name> REVOKED --reassigned-to <CC> --approval <ref> is the old-country side of a reassignment (ADR-0075 RO5): the record becomes REVOKED with the reassignment record as the reason and the structured reassigned_to: "<CC>" in the history entry (what the loader reads, 0.8.1), its uses and terminal groups end.
    • Fix: every chain provider of the replay, the equivalence test and trust:chain-submit turns off the ethers request cache (cacheTimeout: -1). ethers v6 shares identical requests for 250 ms; on a fast machine the gas estimate of a registration data write was taken from an earlier write with the same call data (period 0, before a re-registration), and the transaction ran out of gas inside the proxy (CI failure, no revert data). A failed replay write now names the decoded custom error, or says that the gas limit was too low.
  • contracts — dated relying party status writes (2026-11-05; ADR-0073 K1/K5). RelyingPartyRegistry.suspendRelyingPartyAt, reinstateRelyingPartyAt, revokeRelyingPartyAt(rpId, at): at = 0 is the block time; a past date only while the migration window is open, never ahead of the block time, in order per record (StatusOutOfOrder). The undated forms now follow the same rule as the other registries: while the window is open they are frozen for the state delegates (DateRequiredDuringMigration). A reassignment or re-registration is still dated at execution (ADR-0075). No storage change.
  • contracts — ADR-0075 accepted (D-BC-14): relying party identity ownership and re-registration after revocation. The owning state of a relying party identity (rpId = keccak256(dns_name)) changes only by a typed Governance proposal (2/3): Governance.proposeRelyingPartyReassignment(registry, stageId) (identity captured by another state) and proposeRelyingPartyReRegistration(registry, stageId) (identity revoked; new AdminAction values REASSIGN_RELYING_PARTY, REREGISTER_RELYING_PARTY, appended). The content is staged first in RelyingPartyRegistry.stagePeriodChange(PeriodChange) (identity, old and new state, name digest, access certificate fingerprint, reason digest; no free text) and the proposal carries only its stageId; execution calls commitPeriodChange(stageId, action) (Governance only). A stage is bound to the record's period count (StalePeriodChange), the proposal type must match (UnknownPeriodChange), and the record, owner, status and new state are checked at execution (InvalidPeriodChange, CertificateInUse). Both paths open a new registration period: the record is not deleted, status history and periods are append-only (registrationPeriodsOf, relyingPartyStatusHistoryOf), scopes, registration data and the terminal group list are kept per period (the new period inherits none; the old period's open terminal groups close), and relyingPartyAt(rpId, t) / isRelyingPartyAcceptableAt(rpId, t) answer for the period in force at t. Events PeriodChangeStaged, RelyingPartyReassigned, RelyingPartyReRegistered. Storage layout only appended (__gap 39 → 35); Governance stays under the 24 KB code size limit. Contract tests 247; Slither 0 results.
  • trust-publisher — same rule in the registry tool (ADR-0075 RO5). A dns_name is never registered twice, whatever its status; the error now says that an ownership change needs project management approval. A revoked relying party can be re-registered only with register rp <application> --approval <approval record>: the same record gets a new period (status_history → ACTIVE, reason re-registration (approval …)), old uses and terminal groups stay closed, new uses need new scope_ids. Writing to the production registry still needs TAMGA_CONFIRM_PROD.
  • contracts — ADR-0073 and ADR-0074 accepted (D-BC-12, D-BC-13); contracts/, network/ and docs/ledger are public. The contracts are not an npm package; no production chain exists (ADR-0009 K4).
  • contracts — one-time migration window (ADR-0073 K1, CE1). Every registry (RootCARegistry, IssuerRegistry, SchemaRegistry, RelyingPartyRegistry, CrossRecognition, StatusListRegistry) carries a migration state that only moves forward (not started → open → closed). Governance opens it once per registry by a typed proposal (proposeMigrationOpen(registry, replayPlanHash, window, executor), window ≤ 30 days, counted from execution); it may be extended only while open and within 30 days of opening (proposeMigrationExtend), and closes by proposal (proposeMigrationClose) or by itself when the time runs out — finally. While open, dated writes (*At functions, the registeredAt field) may carry a past date (never later than block time, in order per record) and the daily quotas are not applied; outside the window an explicit date is refused (PastDateOutsideMigration). Network schemas may be written by the single migration executor while the window is open. Governance compares each upgrade target's migrationState() before and after the upgrade and reverts on any change (MigrationStateChanged), so no upgrade can reopen or extend a window. The state lives in ERC-7201 namespaced storage (tamga.storage.MigrationWindow).
  • contracts — C1/C2 evaluated at the credential's iat (ADR-0073 K5, CE5). Issuers, root CAs and schemas keep an append-only status history (*StatusAt, *StatusHistoryOf); intervals are half-open. A suspended issuer's credentials issued before the suspension are accepted (list rule; before, a suspension rejected all of them). Two boundary fixes: a credential issued at the revocation second or at the schema-authorisation withdrawal second is now rejected (iat < revokedAt, iat < until), and a retired root CA no longer accepts credentials issued after its retirement (isChainAcceptableAt). A deprecated schema accepts only credentials issued before the deprecation; a schema or root CA ever revoked accepts none. List mapping helpers: retireIssuer (soft revocation + IssuerRetired), announceRootCARollover (ROLLING_OVER).
  • contracts — read views (C33 (1)): Governance.memberList, IssuerRegistry.issuerDelegatesOf.
  • contracts — hard revocation invalidatesFrom (ADR-0073 K2, CE2). IssuerRegistry.setIssuerInvalidatesFrom(issuerId, from) marks a compromised issuer: credentials with iat ≥ from fail C1. Only on a revoked issuer, validFrom ≤ from ≤ revokedAt, and the date can only be moved earlier (never removed); it is the one past date that may be written outside the migration window. Read with invalidatesFromOf.
  • contracts — schema version digests are append-only (ADR-0073 K3, CE3). SchemaRegistry.addSchemaContentHash(schemaId, contentHash) adds a new version digest (national schema: the owning state; network schema: Governance proposeNetworkSchemaContentHash, or the migration executor); matchesContentHash accepts the first digest or any added one, none on a revoked schema; contentHashesOf lists them. At most 32 added digests per schema; empty and duplicate digests are refused. SPEC-BC-0001 SC1 now reads "every written digest never changes; new version digests are only appended".
  • contracts — relying party identity and request scopes (ADR-0073 K4, CE4). RelyingPartyRegistry takes the identity rpId = keccak256(utf8(dns_name)) from the registrar (no domain text in the ABI); renewing the access certificate keeps it (updateAccessCertificate, old and new fingerprint in AccessCertificateUpdated; a fingerprint belongs to one relying party at a time, rpIdOfCertificate). Suspension can be lifted (reinstateRelyingParty); revocation is final. The coarse allowedScopes / updateScope / hasScope are removed: each use is a RequestScope (scope, service, type, format dc+sd-jwt/mso_mdoc/mso_mdoc_zk, mdoc namespace, sorted element-path digests, validity, details digest), set with setRequestScope and closed (never deleted) with closeRequestScope; wallets ask mayRequest(rpId, service, type, format, namespace, element). Caps: 32 scopes, 64 elements. Storage layout baseline updated (no deployed state).
  • contracts — new NetworkRegistry (ADR-0074 K3, PJ1–PJ3). The network's own records (wallet providers and their WUA signing keys, ZK circuits, external lists, EAA categories, list signers, list operators, state and role slots, catalogue) as typed records: identifier digests, fingerprints, closed-set values, numbers, dates and a details digest only — no free text. Written only through Governance: content is pinned with stageRecord, a typed proposal proposeNetworkRecord(registry, stageId) carries its digest, and 2/3 executes commitStaged; during the migration window the single migration executor writes dated records (writeRecord). Status history is append-only; isListedProviderKey(fingerprint) answers "is this a WUA key of a listed wallet provider now". UUPS, deployed by scripts/lib/deploy.ts; covered by the privacy ABI, UUPS and storage layout checks.
  • contracts — registration data and gate groups on chain (ADR-0074 K2). IssuerRegistry.setIssuerProfile (class PUB/QUALIFIED/EAA, public-sector flag, entitlement bit mask, registration and operations detail digests) and RelyingPartyRegistry.setRelyingPartyProfile (registration digest, flags, alias policy, intermediary and served relying parties as rpId arrays). Gate groups (ADR-0069) as TerminalGroup records: the group id is unique across the network, bound to an institution and at least one gate policy; withdrawn groups are closed, not deleted; isActiveTerminalCertificate(groupId, fingerprint).
  • contracts — read views (C33 (1), continued) and the 2026-10-19 security round remainder (F-18).TrustListAnchorRegistry.anchorers(); DelegateKeysSet now carries the keys; SchemaRegistrySet event; proposeStateRemoval(stateCode, bytes32 reasonHash) takes a reason digest instead of an unused string and StateRemoved emits it; status list and anchor versions may grow by at most MAX_VERSION_STEP (1 000 000) per step, so version = 2^64-1 can no longer freeze a list; unused CANCELLED, ProposalCancelled and SchemaNotAuthorized removed. The anchor registry ABI copy in apps/trust-publisher/src/chain/abi/ is regenerated.
  • contracts — security review (2026-11-04). No deployed state; storage layout baselines updated.
    • High: the single migration executor could permanently revoke a network schema during the window. It now writes only registrations, version digests and deprecations; revoking a network schema is Governance-only (NetworkTierRequiresGovernance).
    • Medium: voted NetworkRegistry proposals could be executed by anyone in any order (e.g. an old ACTIVE after REVOKED), and executed content could be re-staged and written again by an old proposal. A stage is now bound to the record's write counter (stageId = keccak256(abi.encode(rec, baseRevision)), revisionOf, stageIdFor, stagedRevisionOf); a commit on a changed record reverts (StaleStage), so any newer write supersedes pending proposals. REVOKED is not final for network records (ADR-0074 does not say so); re-activation needs a proposal staged after the revocation. Every write emits RecordWritten(kind, recordId, stageId, contentHash, revision); status changes emit RecordStatusChanged. A proposer can withdraw an unexecuted proposal: Governance.cancelProposal (ProposalStatus.CANCELLED re-added at the end, ProposalCancelled, NotProposer).
    • Medium: "cannot be reopened by an upgrade" relied only on the before/after comparison. Registries now refuse upgrades while their window is open (UpgradeDuringMigration), and contracts:check pins the source digest of MigrationWindow.sol (storage-layout/MigrationWindow.pin.json, --update-pin), its ERC-7201 slot, and that no other source references the slot or uses inline assembly. ADR-0073 carries a dated implementation note (decision unchanged).
    • Medium, decision needed: relying party identity ownership and re-registration after revocation — ADR-0075, accepted the same day and implemented (see Applications and repository).
    • Low: while the window is open, undated ordinary writes (at = 0, registeredAt = 0, publishList(publishedAt = 0)) are refused except from Governance (DateRequiredDuringMigration; ADR-0073 K1 "dates explicit"); a closed request scope or gate group cannot be silently reopened under the same id (ScopeClosed, TerminalGroupNotOpen); a gate group's institution must be the relying party itself or a registered relying party / issuer of the same state (UnknownInstitution; RelyingPartyRegistry.initialize takes the issuer registry); outside the window issuer and root CA validFrom cannot be in the past and validUntil is checked against the effective start; revocation reasons are bytes32 reasonHash digests (revokeSchema, revokeRootCA, retireList, proposeNetworkSchemaRevocation; the privacy ABI test no longer allows a reason string); Initializable / UUPSUpgradeable imported from @openzeppelin/contracts (same code in 5.6, namespaced storage). Not changed: the quota exemption stays for the whole window (CE1), and isChainAcceptableAt does not check the CA validity interval (the list rule does not either; CE6).
    • Slither is green (0 results): SchemaRegistrySet(address indexed), four false positives excluded inline with reasons; scripts/slither.mjs finds a pip --user install. New tests: security-round-2026-11-04.test.ts and migration-invariants-fuzz.test.ts (history order, ordinary write vs replay, executor powers; seeded).

Documents ​

  • docs (2026-11-05; currency check after the 0.8.2 release): version sentences 0.8.2 (README — @tamga-network/onboard added to the package table —, docs home and guides in three languages, package index, code examples page, SPEC-API-0001 example sdk_version, audit package "Version under review"); GUIDE-0014 and GUIDE-0015 (three languages) install the onboarding tool from npm (npm install -g @tamga-network/onboard), running from source stays as an optional note; the guides' package table lists @tamga-network/onboard.

0.8.1 — 2026-11-05 ​

All nine packages move to 0.8.1 together (patch release). The API additions are optional (new methods and fields; VerifyInput.aud became optional — a widened type; the Anchor union gained two line types, see below). Some behaviours changed in the fail-closed direction; they are listed under "Behaviour changes in 0.8.1" below. The version stays 0.8.1 (0.x test release; every change refuses more — the one name it resolves again, a relying party reassigned between countries, needs a signed, structured reassignment record). The changes come from the 2026-11-04 review round (per-branch lock, Digital Credentials API audience, registration status warning, mdoc namespace scope, ambiguous gate groups) and the 2026-11-05 trust additions (anchor line types for the chain projection, bits / size, reassignment rule).

Behaviour changes in 0.8.1 (fail-closed, with migration) ​

  1. verifier — Digital Credentials API audience. A mismatching aud on this path is rejected at A1 with an explicit message (was: a generic "aud mismatch" at A6); origin together with aud = client_id is now REJECTED (the audience on this path is origin:<origin>, also for signed requests). Migrate: pass origin and leave aud out.
  2. trust — gate groups are null / inactive when ambiguous. terminalGroup(id) returns null when the same group_id appears in more than one verifier record; terminalGroupByCertFingerprint(fp) returns null when the fingerprint is in more than one active group; a verifier whose dns_name appears in more than one national list is ambiguous (relyingPartyByDnsName → null, its groups inactive) unless the lists show a reassignment (item 5); a group's institution_id slug is looked up in the verifier's own national list only.
  3. wallet-core — mdoc registration scope is narrower. allowedClaims lists only elements whose [namespace, element] path matches the request's namespace; a single-element path without a namespace grants nothing for an mdoc registration. Elements outside it are shown as over-asking.
  4. verifier — per-branch lock; consume() throws once the presentation is completed. begin(branch) locks only that branch, so two branches' valid responses can be verified at the same time. BranchSet.consume() now throws PresentationAlreadyConsumedError when the presentation is already completed: the 0.8.0 pattern isOpen → await verifyPresentation → consume() fails instead of accepting a second response. Migrate: accept with if (!branches.tryConsume()) { /* do not accept */ }. A failed-attempt limit no longer rejects the presentation while another response is being processed (only that branch closes).
  5. trust — reassignment between countries only with a structured record (ADR-0075 RO1/RO5). When the same dns_name is in more than one national list, the loader takes the single record that is not REVOKED / RETIRED (a SUSPENDED record counts as not revoked) only if every other record's last REVOKED history entry carries reassigned_to naming that record's country. Otherwise the name stays ambiguous (null, fail closed): no reassignment record, one naming another country, two records not revoked, or a re-registration after revocation in another country (RO2 — until a network-level record exists). The free-text reason is never read for this. If all records are revoked, the record whose status changed last is returned. The result does not depend on the order in which lists are loaded. Migrate: write the old country's side with rp-status <dns_name> REVOKED --reassigned-to <CC> --approval <ref> (trust-publisher), which adds reassigned_to.

Added ​

  • trust — two new anchor log line types (ADR-0074 K4). The loader recognises registration_status (every publication of the registration certificate status list, ADR-0068: list_uri, content_hash, a per-list list_version, published_at) and list_view (every ETSI XML / LoTE view, ADR-0066: file, format, source_file, source_version, content_hash); the store keeps the latest line per list and per file. A step back stops the load: per list for registration_status, per (file, source_file) pair for list_view (a file moved to another source list continues from that source's own version). A checkpoint state may carry both; its list_views[].file / source_file follow the same rules as the line (no .., source lotl or tl-<cc>). An unknown line type still stops the loader, so loaders before 0.8.1 stop on these lines: the publisher writes them only once 0.8.1 is the minimum loader version of every consumer. The lines do not enter the verification decision.

  • trust — a status_list anchor line may carry the list's bit count and size (bits, size). Both are optional but come together (bits from the Token Status List set 1, 2, 4, 8; size a positive integer = inflated lst bytes × 8 / bits, so size × bits is a multiple of 8, at most STATUS_LIST_MAX_SIZE = 2^32 − 1, the chain field's uint32); a line breaking this stops the load. Kept in the store's StatusAnchorRow and in a checkpoint's state.status_lists[] (same rule). They are read from the token by the publisher and are needed by the list record on chain (StatusListRegistry.registerList); they do not enter the verification decision. Older loaders ignore the extra fields (the line type is unchanged). SPEC-TRUST-0001 §5.

  • trust — StatusHistoryEntry.reassigned_to (optional, two capital letters): on a REVOKED entry, the country list the identity moved to (ADR-0075 RO1/RO5; behaviour change 5). Older lists without it stay valid.

  • trust — TrustStore.relying_party_records, relyingPartyAmbiguous(dns), relyingPartyStateOf(dns). relying_party_records is dns name → country → record; relyingPartyAmbiguous applies the reassignment rule (for a store built by hand without relying_party_records, a name seen in more than one list is ambiguous); relyingPartyStateOf is the selected record's country (undefined when ambiguous). relying_party_states keeps every list a name appears in.

  • verifier — PresentationAlreadyConsumedError (thrown by BranchSet.consume() on a completed presentation; see above).

  • verifier — BranchSet.tryConsume() and BranchSet.declineBlocked(branch). tryConsume completes the presentation atomically and returns false when another response already did (use it instead of consume when accepting); declineBlocked tells whether a decline must wait (its own branch's response is being processed, or the decline would close a single-fetch presentation while another response is being processed).

  • verifier — aud may be omitted on the Digital Credentials API path. For dc+sd-jwt, when origin is given and aud is not, verifyPresentation derives origin:<origin> (OpenID4VP 1.0 Annex A.4). VerifyInput.aud is now optional; without origin it is still required (A1).

  • wallet-core — AuthStart.registrationStatusUnknown. startAuthorized reports true when the issuer's registration certificate status could not be checked (no list, no unexpired cached copy); the app warns the person (ADR-0068 WRS4). A revoked certificate still throws.

Changed ​

  • verifier — the single-use lock is per request branch (ADR-0067, note 2026-11-04). BranchSet.begin(branch) locks only that branch; another branch's response can be processed at the same time and acceptance is decided by tryConsume. Before, one slowly processed response on an attacker's branch made the real wallet's response get "a response is being processed" (400). The branch-less Digital Credentials API path keeps one lock per presentation. busy still means "any response in progress".
  • verifier — a mismatching aud on the Digital Credentials API path is rejected at A1 with an explicit message (was: a generic "aud mismatch" at A6).
  • wallet-core — registration-certificate scope for mdoc compares namespace + element. allowedClaims lists only elements whose [namespace, element] path in the certificate matches the request's namespace (OpenID4VP and proximity); an element of the same name in another namespace counts as over-asking.
  • trust — ambiguous gate groups are closed. terminalGroup(id) returns null when the same group_id appears in more than one verifier record (e.g. two national lists); terminalGroupByCertFingerprint returns null when the fingerprint is in more than one active group (a withdrawn old group does not count); a verifier dns_name listed by more than one national list is ambiguous (relyingPartyByDnsName → null, its groups inactive); a group's institution_id slug is matched only against the issuers of the verifier's own national list (institution + country), and is not active if that still matches more than one.
  • wallet-core — an mdoc registration path without a namespace ([element]) grants nothing (was: allowed the element in any namespace).
  • trust — the Anchor union is wider and refined. Anchor (the zod schema and its TypeScript type) now also has the registration_status and list_view members; code that switches exhaustively on kind must handle them (a never check fails to compile until it does). Anchor is now a refined schema (the bits / size rule), so Anchor.options and other discriminated-union helpers are no longer available on it; parse / safeParse are unchanged.
  • trust — relying party reassigned between countries (ADR-0075). relyingPartyByDnsName and the terminal group answers follow the reassignment rule of behaviour change 5 instead of treating every name in two lists as ambiguous.
  • verifier — failedAttempt does not reject the presentation while another response is being processed; it closes only that branch (on the branch-less path the limit applies once the other response is done).

Fixed ​

  • wallet-core — wiaStatusInList list bound is 8 / bits. 4- and 8-bit lists no longer treat entries past the list as inside it (which threw "idx outside the list").

Applications and repository (not in the npm packages) ​

  • Tamga Verify — ISO/IEC 18013-7 Annex C decline carries no status token (ADR-0067 RQ3). The redirect_uri returned for a declined org-iso-mdoc response is the bare result page; a decline while another response is being processed gets 400.
  • Tamga Verify — a response whose processing fails after another branch completed the presentation no longer overwrites the result.
  • Tamga Verify / sandbox list — sandbox gate group ids are fictional. Sandbox test institutions and their gate groups are example-university-campus, example-events-gate, example-cinema-gate (also the defaults of TAMGA_VERIFY_CAMPUS_GROUP / TAMGA_VERIFY_TICKET_GROUP); sandbox terminals paired with the previous group ids must be paired again.
  • trust-publisher — history-reset (sandbox only). Cleans the sandbox publication's history: each list keeps only its current version in the archive, the public changelog restarts, retired registration-certificate paths are anonymised. Current lists, version numbers, the version chain and status bits are unchanged; refused on the real network.
  • conformance — OpenID4VP vectors (conformance/vectors/openid4vp/basic.json; vector set version 8). KB-JWT aud on both paths (client identifier on the cross-device path, origin:<origin> on the Digital Credentials API path; expected: A steps pass, or A6 / A1), per-fetch request branches (encrypted response to a branch key, encrypted and plaintext decline, soft decline, attempts, responses no branch key opens) and branch kid naming. Keys, time, state/nonce and the wallet's JWE ephemeral bytes are fixed (test keys from public seeds); the runner checks them against the current packages.
  • Tamga Verify — the store-review over-18 policy (review-age-over-18, ADR-0033) requests mso_mdoc (tamga.id.1, as age-over-18-mdoc). The verifier's registered over-18 usage (age-over-18-1) is mso_mdoc only, so the SD-JWT request was sent without a registration certificate and the wallet refused it; the review credential carries an mdoc per copy.
  • contracts — VersionNotMonotonic is declared once in ITamgaErrors (shared by IStatusListRegistry and ITrustListAnchorRegistry; same selector; the anchor registry ABI's first parameter is now named current).

Documents ​

  • SPEC-PROTO-0002 PV7 and §7.1 (Digital Credentials API origin: audience, also for signed requests), §7.4 (Annex C decline); SPEC-PROTO-0001 §2.1 display[].locale canonicalisation (full ICU note); SPEC-CRED-0002 Ş5(g) forbidden claim names (__proto__, constructor, prototype); SPEC-CRED-0003 §3.3 0x03 is APPLICATION_SPECIFIC and read fail-closed; ADR-0067 K1 note on request_uri_method and residual-risk note on the per-branch lock; hosted verifier OpenAPI (Annex C decline). SPEC-PROTO-0002 §10.1 change note 2026-11-04 (per-branch lock, atomic acceptance, 400 for a decline while a response is processed, consume() throws once completed) and §6.1 (mdoc scope by namespace + element); SPEC-API-0001 §1.A A1 also carries caller configuration errors, example sdk_version 0.8.1; ADR-0067 note on the Annex C decline 400; verifier README and "Verify on your own server" guide accept with tryConsume().
  • docs (2026-11-05; currency check after the 0.8.1 release): version sentences 0.8.1 (README, docs home and guides in three languages, code examples page, package index, audit package "Version under review"). @tamga-network/onboard is not part of this release (first published in 0.8.2).

0.8.0 — 2026-11-03 ​

All nine packages move to 0.8.0 together (minor bump: one interface default changed). The code changes below come from the second-model review of the 0.7.4 work (per-fetch branches, status lists, gate groups, WIA status); the second half of the list is behaviour that now fails closed.

Breaking / behaviour changes in 0.8.0 (with migration) ​

  • verifier — createPresentationRequest defaults to per-fetch branches (ADR-0056 safe default). initialRequestObject now defaults to false: no shared cross-device request object is produced and the result is a PresentationSession (no requestJwt, encPrivateKey, encPublicJwk, encJwkThumbprint); a response whose kid names no branch is rejected. initialRequestObject: true keeps the old PresentationRequest for one release and is deprecated. Not backward-compatible for integrators that served req.requestJwt: with 0.8.0 that field is undefined. Migration: packages/verifier/README.md "Migrating from one shared request object" — open presentations without the flag, create one BranchSet per presentation, serve request_uri with BranchSet.fetch, find the branch from the response kid; examples/02-verify-own-server shows the full flow. To keep the old shape for one more release pass initialRequestObject: true explicitly.
  • wallet-core — WIA status bit reads fail closed. wiaRevokedInList / wiaRevokedByList now treat the undefined value 3 as revoked (was: only 1); new wiaStatusInList / wiaStatusByList return valid | suspended | revoked (WiaListStatus) and wiaValidInList is true only for 0 — every non-zero value means "do not use this WIA", only revoked (1 / 3) justifies deleting it locally. Migration: gate WIA use on wiaValidInList (or wiaStatusByList(...) === "valid"), treat suspended as temporary (do not delete); code that only called wiaRevokedByList keeps working and now also deletes on 3.
  • trust — an active gate group needs an ACTIVE institution (ADR-0069 TG2/TG3). TrustSource.terminalGroupsAll / terminalGroup report active: false when the group's institution_id names an issuer or verifier that is REVOKED, SUSPENDED or not in the list, so a withdrawn institution's gates close with the list (403 in Tamga Verify). Groups without institution_id (legacy) are still judged by the verifier record and the validity window only. Migration: none for conforming lists; the publisher refuses to build an active group whose institution is not ACTIVE (valid_until withdraws it).
  • Tamga Verify — real network refuses terminal keys from the environment (ADR-0065 TK3). On the real network (https, not sandbox) the service does not start when TAMGA_VERIFY_TERMINAL_KEYS is set; sandbox and local development are unchanged. Migration: operators keep the variable in sandbox.env only; real-network gate keys come from the trust list.

Fixed ​

  • verifier — BranchSet.fetch evicts only after a successful signature. The victim branch is dropped after the new branch is minted (a failed or late signature loses no branch; a victim that started receiving a response meanwhile is re-selected), the presentation expiry is re-checked after minting, and BranchRegistry counts branches being minted in its budget so concurrent fetches cannot exceed it (_makeRoom may now evict more than one branch to make room).
  • Tamga Verify — /vp/response rate limit per request branch. The bucket key is the branch (kid), not the presentation, on both the encrypted and the plain-decline path (unknown or branch-less kid → 400 before the bucket); only the branch-less Digital Credentials API path stays per presentation. A flood on an attacker's branch no longer returns 429 to the real wallet's branch.
  • wallet-core — registration-certificate status cache never rolls back. fetchRegistrationStatuses keeps the cached list when a freshly fetched valid list is older than it (iat smaller: a stale proxy or a rolled-back publication) and does not overwrite the cache; StatusList exposes iat. A revocation once seen cannot disappear while the cached list has not expired.
  • trust-publisher — old registration status lists keep following their entries (WRS3). After a registrar's status_list_uri changes, VALID entries of the previous lists are revoked with the publication: registration_ended when the old path is no longer published, superseded when its content changed; unchanged content stays valid.
  • trust-publisher — XML signer slot check counts the validity window. xmlSignerSlotProblems checks the xml_signing_keys entry's valid_from / valid_until, not only its presence (ADR-0066 §5.7.1); statusOf with no current history entry starts the status at the list's publication time (not at the previous status' start) — SPEC-ID-0002 §8.1 notes the SKI approximation.
  • trust-publisher — own-record detection (ADR-0070). isOwn also recognises a record whose operator.name or tax number equals the provisional-operator value, not only the note.
  • Tests. Fuzz property test for hostile XML allows 6 s under full load; the spawn-heavy publisher test files get a 180 s budget (docs/audit/build-and-test.md says how to run them alone).

Added ​

  • trust-publisher — single provisional-operator value (ADR-0070). registry/provisional-operator.json holds the legal provisional operator of the network's own services; every publication checks that own records carry exactly this value and that the list operator name is "Tamga Network" (OP1–OP3). The pending app-store review signer record carries the same value.
  • ops/brand — DOM builders for the service pages. tamga-ui.js gains el / set / small / pillNode / row / cell / link so fetched data enters the page as text nodes (no inline scripts, no innerHTML; strict CSP on the operator's pages).

Documents ​

  • ADR-0070 (provisional operator chain; the provisional operator's postal address was later removed from the public text), ADR-0071 (no fees in the provisional phase; Trust Framework §5.5 rewritten) and ADR-0072 (value layer suspended; ADR-0003 marked superseded) accepted; ADR-0028 (health credentials) parked. ADR-0067 K2 / RQ2, SPEC-PROTO-0002 §10.1 + PV15 and D-PROTO-5 say a presentation is REJECTED "if it has a single fetch" (branches being minted count; an evicted branch is not subtracted). docs/audit/limitations.md §5 Q4 (WIA status reading). ADR-0006/0007/0011/0035/0040 carry a "partly superseded" note.
  • docs (2026-11-03; currency check after the 0.8.0 release): version sentences 0.8.0 (README, docs home and guides in three languages, code examples page, sdk_version examples, package index, audit package "Version under review").

0.7.4 — 2026-10-29 ​

Breaking / behaviour changes in 0.7.4 (with migration) ​

  • wallet-core — Digital Credentials API KB-JWT aud. SD-JWT VC presented over the DC API binds the Key Binding JWT to aud = "origin:<origin>" (OpenID4VP 1.0 Appendix A.4), no longer to the client identifier; Tamga Verify expects the same and rejects a proof bound to the other path. Not backward-compatible: there is no transition code — a 0.7.3 wallet's SD-JWT presentation over the DC API is rejected by a 0.7.4 verifier, and the other way round (by decision: development phase, no compatibility shims before the beta, ADR-0029). Migration: wallets and verifiers update to 0.7.4 together for SD-JWT over the DC API; a verifier that checks DC API presentations itself must expect origin:<origin>. Cross-device (QR) keeps the client identifier and is unaffected.
  • verifier — registrationScopesFor matches the presentation format. A registered use only matches a request of the same format (dc+sd-jwt default, mso_mdoc, mso_mdoc_zk). Migration: registry scopes for mdoc / ZK requests set format (and mdoc_namespace for mdoc); otherwise the request finds no registration certificate.
  • wallet-core — checkDcqlShape is stricter. Malformed DCQL (non-object credential query, claims not an array, invalid claim path, empty values) throws a WalletError instead of a TypeError or passing. Migration: catch WalletError; fix queries that relied on the lenient shape.
  • wallet-core — registration status. New flag registration_status_unknown when a registration certificate's status could not be checked (also when no statuses are passed); a revoked certificate makes the request invalid. startAuthorized (auth code issuance) now fetches the registrar's status list when registrarKeys is given; a registration-certificate status list without exp is not accepted (reads as unknown). Migration: pass fetchRegistrationStatuses(...) results to the registration checks (or accept the flag as a warning); allow the wallet to reach the registrar's /status/... address.
  • core — resolveSdPayload rejects __proto__. A payload with a plain __proto__ key is rejected. Migration: none for conforming issuers; never use __proto__ as a claim name.
  • wallet-core — statusBitAt reads 4- and 8-bit lists. Values above 3 read as 3 (invalid). Migration: none; treat 3 as invalid as before.
  • trust — XML list signers in their own LOTL field (xml_signing_keys). The ETSI TS 119 612 XML list signer is published in the country slot's new national_lists[].xml_signing_keys instead of signing_keys; JSON lists are validated only against signing_keys. As defence in depth, a LOTL or tl-<cc> JSON list whose signer certificate has EKU id-tsl-kp-tslSigning (0.4.0.2231.3.0) is still not loaded. The publisher refuses a tslSigning-EKU certificate in signing_certs and checks the XML signer against xml_signing_keys before writing the XML (stops on the real network). Migration: registries move the XML signer from signing_certs to xml_signing_certs; XML readers look the signer up in xml_signing_keys; sign JSON lists with the JSON list signer only.
  • verify — gates fail closed. A terminal key with an owner, or a key of a group once seen in the list, gets 403 when the list is stale or the group is gone; a pass from a policy not in the group's allowed_policies gets 403 without being consumed. Migration: keep the trust list fresh; passes issued before 0.7.4 (no policy id) still pass when every policy of the group is allowed.
  • trust-publisher — wrprc-revoke reason codes. --reason takes compromised | superseded | ceased | policy_violation | other, optional --note (short, no personal data). A lost wrprc-status.json stops the build. Migration: use a code; after state loss run wrprc-status --reset --reason "<why>".
  • purpose removal in createPresentationRequest happened in 0.7.3 (now flagged there).
  • verify / operator issuer — no 429 for a request-object fetch past 10 branches (ADR-0067 amendment 2026-10-29). The fixed "10 branches, then 429" rule let a bystander lock the real wallet out with 10 fetches. Now a new fetch past the soft limit (10) replaces a closed branch or the oldest never-answered branch at least 120 s old; at the hard ceiling (32) the age condition is dropped; a branch whose response is being processed is never evicted. A response to an evicted branch gets 400 unknown request object (not counted; the person scans again). A shared budget caps branches across presentations (20,000; when every branch is in flight a fetch gets 503). The per-presentation fetch bucket is gone; fetches are limited per client address (nginx zone tamga_vpreq, 2 r/s, burst 20; application-wide ceiling vpRequest). Migration: none for wallets; operators reload nginx.
  • verifier — createPresentationRequest({ initialRequestObject: false }). Without the shared cross-device request object the result is a PresentationSession (no requestJwt, encPrivateKey, encPublicJwk, encJwkThumbprint) and a response whose kid names no branch is rejected. The default (true, old shape) stays for 0.7.x and is deprecated: one object served to every fetch exposes state to anyone who sees the QR. openPresentationResponse / decryptPresentationResponse now type req as ResponseKeys and branches as BranchKeys (generic) — PresentationRequest and RequestBranch still fit. Migration:packages/verifier/README.md "Migrating from one shared request object"; examples/02-verify-own-server shows the full flow (its requestObject(id, walletNonce) is now async; new handleDecline(state)).

Changes ​

  • docs + ARF (2026-10-29; currency check after the 0.7.4 release): version sentences 0.7.4 (README, docs home and guides, sdk_version examples, package index); ADR-0066/0067/0069 notes no longer say "not on npm"; the trust-list spec and the audit package say registration-certificate status is configured on the real network too (ADR-0068 implementation note); Trust Framework: the real network's ETSI XML view waits for the foundation that will operate the list (postal address, signer); Event Ticket rulebook rule 5 names the gate group's institution and accepted pass policies (ADR-0069 TG1–TG3; the Azerbaijani text also gains the ADR-0065 TK1 sentence it lacked).

  • verifier + verify + operator issuer (2026-10-29; ADR-0067 amendment, K16): one branch state machine. New BranchSet / BranchRegistry in @tamga-network/verifier (branches.ts): fetch (fresh branch; signed object returned, not stored; the branch keeps the SHA-256 of state, nonce, private key, kid, timestamps), lookup by kid and by state (hash map, no linear scan; timingSafeEqual), soft decline (decline, REJECTED only after a single fetch — fetches still being signed count), attempts per branch (failedAttempt), single-use lock (begin before decrypting, isOpen after, end), consume, dispose, eviction (BRANCH_LIMITS: soft 10, hard 32, 120 s, 5 attempts). Tamga Verify and the operator's inline identity presentation both use it; their duplicated logic is deleted. This fixes drift in the operator service: it took the single-use lock only after decrypting, so a decline arriving during decryption could close the branch and the response was still accepted; it compared state with === and scanned every pending branch for a decline; its /{slug}/vp/req/{id} had no rate limit (now per address at the proxy plus an application ceiling). Tamga Verify and the operator no longer create the unused first request object (one signature and one key generation less per presentation). examples/02-verify-own-server rewritten to the branch API (lock before decrypting, used up only after A6, the pending entry is never deleted before decryption); the SDK page copy on tamga.network regenerated. Code comments use the RQ codes of ADR-0067 (were FB1–FB6); ADR-0067 tr RQ3 wording fixed.

  • trust + trust-publisher (2026-10-29; ADR-0066 implementation note): xml_signing_keys. The country slot in the LOTL carries the ETSI TS 119 612 XML list signers in their own field (national_lists[].xml_signing_keys; registry xml_signing_certs), separate from the JSON list signers. The sandbox LOTL moved tl-xml-signer-1 there. Publisher checks: no tslSigning-EKU certificate in signing_certs; the XML signer must be active in xml_signing_keys (stops on the real network, warning in the sandbox). OpenAPI Lotl schema, SPEC-TRUST-0001 and SPEC-ID-0002 updated.

  • trust-publisher (2026-10-29; ADR-0068 on the real network): registration certificates of the real network carry policy_id2.25.338612186327611064481769354006034529929 (UUID-based OID), certificate_policyhttps://arf.tamga.network/policies/registration-certificate and status → https://trust.tamga.network/status/wrprc/1 (1-bit Token Status List, re-signed hourly). FW-POL-0003 records the OID.

  • docs (2026-10-29): the legal operator of the network's own services is stated with one sentence everywhere it appears — "Operated by a provisional operator on behalf of Tamga Network (foundation to be established)" (ARF definitions, roles, trust framework, rulebooks). The lists keep naming the operator "Tamga Network".

  • verify + verifier + trust (2026-10-29; ADR-0069 TG3 follow-up): gates fail closed. "List stale" and "group not in the list" are told apart (freshness().healthy); a key with an owner or a group once seen in the list (listed_groups in terminal-keys.json) that cannot be confirmed gets 403 at /terminal/verify and no new key (409). Unowned keys issued while a group was unlisted are bound to the group's institution when the group appears. allowed_policies is enforced at the gate: passes carry their policy (PassPolicy.policy_id → PassRecord.policyId; verifyToken option policyAllowed), a pass from a policy that is not allowed is refused before it is consumed.

  • trust-publisher + wallet-core (2026-10-29; ADR-0068 follow-up): the registration-certificate status state is never silently restarted — without wrprc-status.json but with a published list (or an archived state) the build stops; wrprc-status --reset --reason "<why>" rebuilds it from the published list (revoked bits) and certificates. Every state change is also written to archive/wrprc-status.<time>.json. When status_list_uri changes, revoked entries and blocks move to the new list as revoked and the old list keeps being re-signed until its last certificate expires. Manual revocation reasons are a code list plus an optional short note checked for e-mail addresses, numbers, links and names. wallet-core requires exp on registration-certificate status lists (parseStatusToken option requireExp).

  • trust-publisher (2026-10-29; ADR-0066 follow-up): in the ETSI XML view a wallet solution's status timeline is the solution's own history (the provider's current status is added only when the provider is not active); repeated entries of the same status collapse and no history instance repeats the current status. Characters not allowed in XML 1.0 (C0 controls except tab, CR, LF; U+FFFE/U+FFFF; lone surrogates) stop the real-network build and are stripped with a warning in the sandbox (sanitizeTrustedListInput); the generator never writes them. Root CA service_type in the JSON registries is the ETSI Svctype/CA/PKC URI (was NationalRootCA-QC, a qualified claim — SPEC-ID-0002 §8.1, TX2); the publisher rejects QC values.

  • trust (2026-10-29; K5 finding): the JSON list loader refuses LOTL / tl-<cc> signed by a certificate with EKU id-tsl-kp-tslSigning (certExtendedKeyUsages, pure DER reader). A separate xml_signing_keys field would be narrower; it is a new public name and waits for a decision.

  • verify (2026-10-29; OpenID4VP session and replay acceptance tests, SPEC-PROTO-0002 §10.1, PV10; no package change): a wallet error response (error + state) that arrives while a response to the same presentation is being verified is now refused with 400 (a response is being processed) instead of closing the presentation — before, the decline wrote REJECTED and the in-flight verification then overwrote it with its own result, so the outcome could change after it was written. The response path also re-checks that the presentation is still open after verification before writing a result. New apps/verify/test/session-replay.test.ts covers eight cases: an old response sent to a new attempt, a proof made for another verifier (KB-JWT aud), the same valid response sent concurrently, a result requested by another session or RP, an expired attempt, malformed input first (and state / nonce swapped between two sessions), re-reading the result after acceptance, and a credential with a missing field; plus a Digital Credentials API origin mismatch and a response after a decline. The server-side verification guide has a "a success page is not proof" checklist item.

  • docs (2026-10-28; data-protection pre-review, no package change): ADR-0040 note — the sandbox's real identity path defaults to the invitation mode (invite) until the legal review is complete, the quick trial stays open to everyone; RI1 rewritten (tr/en/az, INVARIANTS). Sandbox guide §8 and the warning text now say deletion of the provider session is requested at issuance. SPEC-ID-0003: time-based purge of expired/revoked identity records (30 days, with the provider session) and event-log rows (365 days), erasure response provider: "partial" without the delete permission (tr/en/az).

  • verify + docs/ARF sites + brand (2026-10-29; K14): fonts are self-hosted — no Google Fonts. Onest, IBM Plex Sans (upright + italic) and IBM Plex Mono are served from our own origin: ops/brand/fonts/ (woff2 built from the google/fonts sources with fontTools — Latin, Latin Extended, Cyrillic, Cyrillic Extended; variable weight; OFL 1.1 licence files alongside, fonts.css). tamga-ui.css imports fonts/fonts.css instead of fonts.googleapis.com; Tamga Verify serves /assets/fonts/*; the docs and ARF sites bundle the same files through Vite. The visitor's IP address no longer reaches a third-party font host. Tamga Verify's CSP tightens to style-src 'self'; font-src 'self'. No package code changed (packages/* untouched).

  • verify + verifier/web (2026-10-29; security round K10): strict Content-Security-Policy on every Tamga Verify page. No inline script or style any more: page scripts (waiting page, sample site, gate terminal, Digital Credentials API test), the brand stylesheet and the early theme stamp are separate files under /assets/*, values reach them through data-* attributes; the gate's QR reader (jsQR 1.4.0, unchanged file, hash pinned in the test) is served by the verifier itself — no CDN. Policy: default-src 'none'; script-src 'self'; style-src 'self'; font-src 'self'; … base-uri 'none'; object-src 'none'; require-trusted-types-for 'script'; trusted-types 'none' (no nonce, no 'unsafe-inline', no 'unsafe-eval'; since K14 no font or style host other than 'self'). The site kit (@tamga-network/verifier/web) sets its styles through CSSOM instead of style attributes and clears the mount point without innerHTML, so it also works on integrator sites whose CSP has no 'unsafe-inline' and enforces Trusted Types. Shared ops/brand/tamga-ui.css gains small utility classes; tamga-ui.js builds fingerprint groups with DOM nodes.

  • trust + trust-publisher + verify (2026-10-29; ADR-0069, completes ADR-0065 K2/K5): gate groups in the trust list. The verifier record's terminal_groups[] (ADR-0012 K5) gets a schema: group_id (unique in the list), institution_id (issuer slug or verifier dns_name operating the gates), label, allowed_policies[], optional cert_fingerprints[] and offline_allowed, valid_from / valid_until. The publisher refuses to publish an active group without a known institution and a policy (TG1). TrustSource.terminalGroup() / terminalGroupByCertFingerprint() read it (the latter prepares certificate-based gates; gates still use terminal keys). Tamga Verify records the group's institution on every terminal key and accepts an institution-scoped admin token (x-tamga-institution + x-institution-token = base64url(HMAC-SHA256(admin token, "tamga-terminal-keys/v1:" + institution))): an institution gets, lists and revokes keys only for its own listed groups (TG2); GET /terminal/keys also returns groups and each key's owner and lastUsedAt. A key of a group withdrawn from the list, or whose institution changed, gets 403 at /terminal/verify (TG3). Groups not in the list keep the ADR-0065 path (operator only).

  • core + wallet-core (2026-10-29; external-audit preparation, property/fuzz tests with fast-check): three hardening fixes the new property tests found. resolveSdPayload (@tamga-network/core/sd-structure, used by the verifier and the wallet) rejects a plain __proto__ key anywhere in the payload — JSON keeps it as an own key and the assignment changed the result object's prototype, so a claim could be read through inheritance without appearing in any key (issuer-signed content only). statusBitAt (wallet-core) reads 4- and 8-bit lists correctly — the CWT path accepts them and the old reader took every non-1-bit list as 2-bit, so in an 8-bit list it read a neighbour's bits (a revoked entry could read as valid); values above 3 now read as 3 (invalid). checkDcqlShape rejects malformed queries with a WalletError instead of a TypeError: credential queries must be objects, claims an array, each claim path a non-empty array of strings, null or non-negative integers (OpenID4VP 1.0 §7), values a non-empty array. Property tests: packages/*/src/property.test.ts; contract invariant/fuzz sequences: contracts/test/invariants-fuzz.test.ts.

  • verifier + verify (2026-10-29; ADR-0067, OpenID4VP 1.0 §5.10 / §8.2 / §8.3.1, HAIP §5): request branches and soft decline (protection against forged declines). OpenID4VP does not authenticate error responses, and state sat in a request object that anyone who saw the QR code could fetch, so a bystander could close the real person's presentation with error=access_denied&state=…. Now every fetch of the request_uri (GET, or POST with wallet_nonce echoed) mints a new request object with a fresh 128-bit state, a fresh nonce and a fresh ephemeral encryption key (kid enc-<presentation>.<branch>). A decline — unencrypted or encrypted — closes only its own branch; the presentation becomes REJECTED only if it has exactly one branch and that branch is closed, otherwise it stays open until expiry and the first valid presentation wins. Decline answers are 200 and their redirect_uri no longer carries the status token. Responses that no branch key can decrypt no longer count as attempts; attempts are per branch (5); at most 10 branches per presentation (then 429 — replaced the same day, see the amendment entry above). The Digital Credentials API path is unchanged (its object is not a branch). New in @tamga-network/verifier: createRequestBranch, openPresentationResponse (separates an encrypted error response), acceptableWalletNonce, RequestBranch, RequestContent, ResponseBinding; responseKidOf returns branchId, decryptPresentationResponse takes an optional branch lookup; state is now 128 bits. The GET /presentations/{id} contract is unchanged. Same rule in the operator's inline identity presentation.

  • trust-publisher + wallet-core (2026-10-29; ADR-0068 Accepted, ETSI TS 119 475 V1.2.1 Table 7 and §6): registration certificates carry policy_id (Tamga's own OID; ETSI's EU OID 0.4.0.19475.3.1 is refused by the publisher), certificate_policy (the new Tamga ARF page "Registration Certificate Policy", FW-POL-0003) and status (status_list {idx, uri}). The registrar publishes a 1-bit IETF Token Status List (statuslist+jwt, signed with the registrar key that signs the certificates, ttl 1 h, exp 24 h, re-signed by heartbeat). Indexes are random and never reused: the same path with the same content keeps its index, changed content or an earlier expiry gets a new index and the old one is revoked (superseded); certificates that disappear from the publication are revoked (registration_ended). New publisher commands wrprc-status and wrprc-revoke <path> --reason r (the content stays blocked until it changes); the state is kept in wrprc-status.json next to the published files. Enabled only when the registry's roles.registrar.wrprc is set — today the sandbox (2.25.… OID, trust.sandbox.tamga.network/status/wrprc/1); the real network's OID and addresses wait for name approval. @tamga-network/wallet-core: fetchRegistrationStatuses (one request per list, signer must be a LOTL registrar key, verified tokens cached, unexpired cached copy used offline), registrationStatusRefs, wrprcStatusRef, MemoryRegistrationStatusCache; checkRegistrationCerts, relevantRegistrationCerts, checkIssuerRegistration and checkProximityRegistration take the statuses as an optional last argument (presentProximity option registrationStatuses): a revoked certificate makes the request invalid, an unchecked status adds the flag registration_status_unknown (secure default when no statuses are passed); a malformed status or policy_id invalidates the certificate. Certificates without status are accepted as before.

  • trust-publisher + trust (2026-10-29; ADR-0066 Accepted the same day, ETSI TS 119 612 V2.4.1): optional ETSI TS 119 612 XML view of each country list, generated from the same signed tl-<cc> object and the LOTL with the same version (TSLSequenceNumber = version) and signed XAdES-B-B (enveloped, Exclusive C14N, SigningTime / SigningCertificateV2 / DataObjectFormat, only the signer certificate in KeyInfo). Off by default: only TAMGA_TL119612=1 makes build write tl-<cc>.xml, tl-<cc>.sha2 (§6.1) and archive/tl-<cc>.vNNNN.xml; signer TAMGA_TL119612_SIGNER must follow the §5.7.1 profile (on the real network a non-conforming signer or missing publication data stops the build; warning in sandbox). No EU "notified/qualified" URIs (EUgeneric, granted, recognisedatnationallevel, …/QC): list type, status and rules URIs under https://trust.tamga.network/tl/ (names approved). Verifiers are not listed; inactive records stay with their history (SKI). @tamga-network/trust now exports canonicalizeXml and parseXml (the signer uses the reader's canonicalisation). Official ETSI XSDs in apps/trust-publisher/etsi/19612/; tests validate every generated list against them (libxml2 via the dev dependency xmllint-wasm) and verify the signature with the package reader and independently with xml-crypto; a sandbox sample is in apps/trust-publisher/test/fixtures/tl119612/. After acceptance: ops/gen-pki.ts issues a separate §5.7.1 XML signer tl-xml-signer-1 (root-issued leaf, basicConstraints CA=false, keyUsage digitalSignature + nonRepudiation, EKU id-tsl-kp-tslSigning); the sandbox registry lists it among the TR slot's signing keys and carries placeholder addresses marked "Sandbox (TEST)"; the sandbox publishes trust.sandbox.tamga.network/tl-tr.xml + .sha2. The URIs are defined on the new docs page concepts/etsi-trusted-list (en/tr/az). The real network stays off until real postal addresses and the production signer exist.

  • trust-publisher + trust + verifier + verify (2026-10-29; independent test with the open-source EU test wallet eudi-dev 3.5.0 against the sandbox): (1) registration certificates (ETSI TS 119 475 Annex B.2.9, ARF RPRC_21) now register each use in its presentation format — a relying-party scope may carry format (dc+sd-jwt default, mso_mdoc, mso_mdoc_zk) and, for mdoc, mdoc_namespace; the credentials entry is then doctype_value + [namespace, element] (element names per CIR 2026/1731 Table 6) instead of always dc+sd-jwt + vct_values. An EU wallet in strict mode treated the mdoc and ZK age requests as over-asking. registrationScopesFor (verifier) picks a use with the same format; the age scopes in both registries set it. (2) Tamga Verify accepts a Digital Credentials API response without state (OpenID4VP 1.0 Appendix A.2: state is not defined for the DC API); a state that is present must still match, and the cross-device path still requires it. (3) The wallet-provider certificate check accepts any EN 319 412-1 semantic identifier (e.g. NTRNL-NLTEST.00000000), not only letters and digits after the hyphen. (4) SD-JWT VC over the Digital Credentials API: the Key Binding JWT aud is origin:<origin> (OpenID4VP 1.0 Appendix A.4, also for signed requests; SPEC-PROTO-0002 §7.1) in wallet-core and in Tamga Verify — both used the client identifier, so an EU wallet's DC API presentation was rejected. Cross-device keeps the client identifier (PV7); a proof bound to the other path is rejected. Wallets on wallet-core 0.7.3 need 0.7.4 for SD-JWT over the DC API (mdoc and ISO 18013-7 Annex C are unchanged). (5) ETSI TS 119 602 lists (the trust-publisher LoTE projection and the sandbox test LoTE script) carry the JAdES signing time in iat (ETSI TS 119 182-1 V1.2.1 §5.1.11) instead of a critical sigT, which new signatures must not use since 2025-07-15 (§5.2.1); a JOSE library without JAdES support rejected the old header. Readers still accept sigT in older lists. The sandbox test LoTE oidf-test-pid was re-signed (sequence 3, same signer). (6) wallet-core reads a verifier_info registration certificate whose data is the base64url encoding of the JWT (ETSI TS 119 472-2 V1.3.1 RO-16 as eudi-dev applies it) as well as the plain JWT that Tamga Verify and the EU reference implementation send; checked against registration certificates from the eudi-dev registrar.

0.7.3 — 2026-10-27 ​

  • issuer (2026-10-27; OpenID4VCI 1.0 §12.2.4, OpenID conformance checks VCIValidateDisplayLocales / VCIWarnOnNonCanonicalDisplayLocales): display locale values in the Credential Issuer metadata are strict BCP 47. credentialDisplay, issuerDisplayFrom and the top-level display of issuerMetadata write the canonical form (en-us → en-US, TR → tr), drop an entry whose tag is malformed or has an unregistered language or region subtag, and keep one display object per language (the first; also only one entry without a locale). Two registry keys that canonicalize to the same tag become one entry. The values served today (tr-TR, en-US) do not change. Regression tests also pin two properties the newer conformance checks look at: every presentation request carries a new response-encryption key with a kid (VP1FinalCheckEncryptionKeyNotReused), and batch copies get distinct, non-sequential status indices on one shared list (VCIEnsureBatchStatusReferencesAreDistinct, VCIEnsureBatchStatusListIndicesAreUnpredictable).
  • Breaking (flagged retroactively on 2026-10-29): createPresentationRequest no longer accepts the purpose option and RespondOutput.showUrl is gone (details in the next entry). Migration: drop the option; show the registration certificate's purpose / purposeLocalized that checkRegistrationCerts returns.
  • OpenID conformance self-test, verifier plan round 1 (2026-10-27; OpenID4VP 1.0 §5.1, §8.2; SPEC-PROTO-0002 §3, §8.1). Two warnings in every module are fixed. verifier: createPresentationRequest no longer writes a purpose parameter into the signed request object (not an OpenID4VP parameter; the purpose option is removed) — the purpose shown to the person is the purpose of the registration certificate in verifier_info (ETSI TS 119 475 intended use) and the registered use in the trust list. wallet-core: checkRegistrationCerts / checkProximityRegistration return the certificate's purpose (English or first text) and purposeLocalized (BCP 47 → text); respond no longer reads show_url (RespondOutput.showUrl removed). Tamga Verify: the direct_post response carries only redirect_uri (plus pass_grant / pass for access-pass policies, ADR-0012 B); on ACCEPTED the face-to-face check view key is part of that address (/p/{id}?st=…&show=…, valid 5 minutes after the result, then the address falls back to the status page; without the status token an old key gets 410). Tamga Wallet shows that address as the "Have it checked" QR.

0.7.2 — 2026-10-27 ​

  • verifier (2026-10-27; SPEC-CRED-0003 §9.1 / publishing rule T1, ADR-0036 K5 D): an external (federated) issuer's Status List has no anchor, so its address is now learned on first sight like an identifier list (StatusCache.want; that verification is INDETERMINATE, later ones read the prefetched list) — previously it was never fetched. New explicit opt-in VerifyInput.statusFetchOnDemand (default off): a missing Status List on the issuer's declared status host is fetched during that verification (PrefetchStatusCache.fetchNow: same https / declared-host / public-IP / pinned-connection checks, time-boxed, not added to the prefetch set). Tamga Verify enables it only for the sandbox OpenID conformance self-test policy (oidf-selftest-eu-pid; the test tool serves a new list URL in every test and checks that it was fetched). Sandbox registry: the self-test LoTE (oidf-test-pid, sequence 2) lists the tool's PID signing certificate as the PID revocation service and the tool's host as the service supply point.
  • Tamga Verify (2026-10-26; ADR-0065, security review): gate terminals authenticate to POST /terminal/verify with an operator-issued terminal key bound to a terminal group (Authorization: Bearer tk_…); without a key the request gets 401 and the pass token is neither read nor consumed (a photographed single-use ticket QR can no longer be spent by a bystander). Admin endpoints /terminal/keys (issue once, list without hashes, revoke; terminal-keys.json stores SHA-256 only); TAMGA_VERIFY_TERMINAL_KEYS for local/sandbox demo gates; the /terminal page gets a key field (browser tab only).
  • Protocol review fixes (2026-10-24; SPEC-PROTO-0001 §2, §13, SPEC-PROTO-0002 §2, §10.1; ADR-0059 note). issuer: authServerMetadata({ preAuthorized: false }) — an authorization server without the pre-authorized grant advertises neither the grant, nor pre-authorized_grant_anonymous_access_supported, nor the none auth method (the identity service uses it); issuerMetadata({ issuerDisplay }) + issuerDisplayFrom — the issuer's display comes from the trust-list record (legal_name, service_description per BCP 47 locale) instead of the first credential type's name with a hard-coded tr-TR; tokenErrorResponse maps offer_used / offer_expired / PIN failures to the standard invalid_grant (reason in error_description); dpopChallenge builds the WWW-Authenticate: DPoP error=…, algs="ES256" header for 401 credential responses; distinctCnfKeys checks PR6 per request (invalid_proof); redeemCode rejects a malformed code_verifier (RFC 7636 §4.1, 43–128 chars) with invalid_grant. sd-jwt / mdoc: status lists with bits 4 or 8 are parsed on the read side (READ_STATUS_BITS, STATUS_LIST_CWT_READ_BITS); Tamga publishers still write only 1 or 2 (signStatusListToken refuses others); verifySdJwtVc({ allowMissingSdAlg }) accepts a missing _sd_alg as sha-256 and reports sdAlgPresent. verifier: a Tamga type without _sd_alg is rejected at A4, external types may omit it; a status value outside 0/1/2 is INDETERMINATE STATUS_VALUE_UNKNOWN (not REJECTED); vp_formats_supported lists only the formats used in the DCQL (vpFormatsFor); DCQL never carries an empty claims array (claims is optional in DcqlQuery). wallet-core: declineRequest posts error=access_denied + state to the response_uri when the person declines (PV5; no reason). Tamga Verify: /vp/response accepts the OpenID4VP §8.4 error response (error + state) and closes the presentation without storing a reason; a presentation is consumed only after holder binding passes (A6 / Z1 / P1) — undecryptable bodies, state mismatch, empty vp_token and A1–A6 failures leave it open, count as attempts (attempts, last_attempt in the pending status) and close it as REJECTED after 5; concurrent responses to one presentation are serialised. Conformance vectors: VERSION 7.
  • Security round (2026-10-24). wallet-core: the local-network exception for a presentation request's response_uri (localhost / private IP without a matching SAN) is now off by default — verifyRequestObject / parseDcApiRequest take allowLocalDevHost: true, which a wallet passes only in a development build or on the sandbox network. Tamga Verify: every HTML page carries a Content-Security-Policy with a per-request nonce for its inline scripts (default-src 'self', frame-ancestors 'none', form-action 'self', base-uri 'self', object-src 'none'), X-Frame-Options: DENY and nosniff; styles keep 'unsafe-inline' (inline style="" attributes). Dependencies: fastify 5.12.7, fast-uri, zod 4.6.7, vitest 4.1.12 (npm audit clean).
  • Fixes after a code review of ADR-0059…0062. wallet-core: startAuthorized adds the ZK copy companion scope only when the authorization server lists it in scopes_supported (a server without it would reject the PAR); when a refresh or ZK copy binding ends with invalid_grant, removedKeyRefs also carries the binding's instance key unless the wallet's WIA or another binding still uses it (no orphaned keys); removeCredential computes the keys in use once. issuer: createPar accepts a companion scope when the credential type comes from authorization_details (RFC 9396 §3.1).
  • ADR-0064 accepted (2026-10-23): age_over_15 in the identity credential. schemas: the identity credential and its ZK copy carry age_over_15 next to age_over_18 (ISO/IEC 18013-5 age_over_NN pattern; the threshold set is closed, {15, 18}, and changes only by ADR); selectively disclosable, derived at issuance, not required. The Longfellow circuit proves equality, so the same circuit proves age_over_15 = true (end-to-end test with the desktop prover). Tamga Verify: age-over-15-mdoc and age-over-15-zk policies, trust list scopes age-over-15-1 and age-over-15-zk-1, a 15+ option on the browser test page. Credentials issued earlier get the attribute when they are issued again (no migration).
  • ADR-0063 accepted (2026-10-23): the on-chain status list registry accepts the list's own bit size. StatusListRegistry takes bitsPerEntry 1, 2, 4 or 8 (IETF Token Status List) instead of always 2, so identity service lists (bits = 1, ADR-0048) can be anchored; the value is written once and emitted in ListRegistered. trust-publisher: statusListRegistrationOf derives the registration parameters from a signed status list token. No production chain (local development and test only).
  • ADR-0062 accepted (2026-10-23): the ZK copy refresh token only when the ZK copy scope is requested. issuer createPar({ allowedCompanionScopes }) accepts a companion scope next to one credential type (ParRequest.companionScopes); wallet-core startAuthorized requests the ZK copy scope with the identity credential when the issuer declares ZK copies (companionScopes). A refresh token is then for the scope it was granted for (RFC 6749 §6).
  • issuer: issuerMetadata follows OpenID4VCI 1.0 (Final) §12.2.4 — credential configurations carry their display only in credential_metadata.display (the legacy top-level display is gone) and display entries use locale (the type metadata's lang is translated by the new credentialDisplay). Wallet-core already read credential_metadata.display and locale. Only the OpenID4VCI issuer metadata changes: SD-JWT VC Type Metadata (vct documents, display[].lang, claims[].display[].lang) and the credentials themselves keep lang, as SD-JWT VC defines.
  • ADR-0060 accepted (2026-10-22): refresh token bound to the client instance key. issuer clientInstanceJkt (RFC 7638 thumbprint of the client attestation's cnf). wallet-core: refresh and ZK copy bindings keep instanceKeyRef (the WIA key of the issuance); autoRefreshCredential / refreshZkCopies take wuaForInstance to get a fresh WIA for that key (wuaForBinding); the DPoP key may change on refresh (RFC 9449 §5, attestation-based client authentication §10.3). removeCredential also deletes the binding's key unless it is in use (instanceKeysInUse).
  • ADR-0061 accepted (2026-10-22): pseudonym seed as a separate credential configuration. wallet-core obtainCredential requests urn:tamga:id:PseudonymSeed:1 with the same access token after the identity credential (single proof with the first copy's key) when the issuer declares it; the credential response no longer carries a non-standard pseudonym_seed field.
  • ADR-0059 accepted (2026-10-21): several credential requests per access token. The access token can be used for more than one credential request within its lifetime (≤ 5 minutes), as OpenID4VCI 1.0 §8 allows and the EU reference issuer does: only the configuration the token covers, at most 10 copies per token in total (MAX_COPIES_PER_ACCESS_TOKEN, withinAccessTokenAllowance in issuer), every request with the token's DPoP key. The ZK copy token and tickets stay one package.
  • issuer: authServerMetadata now publishes client_attestation_signing_alg_values_supported and client_attestation_pop_signing_alg_values_supported (["ES256"]), which draft-ietf-oauth-attestation-based-client-auth-07 §10.1 requires whenever token_endpoint_auth_methods_supported includes attest_jwt_client_auth (OpenID conformance self-test, issuer metadata check).
  • issuer: DPoP binding at PAR (RFC 9449 §10). createPar takes dpopJkt (the dpop_jkt form parameter) and dpopProofJkt (the key of a verified DPoP proof on the PAR request); if both are present they must match (invalid_dpop_proof). The bound key is kept on the PAR record (ParRequest.dpopJkt) and redeemCode({ dpopJkt }) refuses a token request signed with another DPoP key (invalid_grant).
  • issuer: new checkParParams — a PAR body with a repeated parameter or a request_uri is refused (invalid_request, RFC 9126 §2.1), and only response_type=code is accepted (unsupported_response_type, FAPI 2.0). A plain PKCE method now answers invalid_request (RFC 7636 §4.4.1) instead of the non-standard unsupported_code_challenge.
  • issuer: DPoP htu is compared after RFC 3986 §6.2.2–6.2.3 normalisation (normalizeHtu: case of scheme and host, default port, query and fragment ignored; RFC 9449 §4.3). redeemCode answers a missing code_verifier with invalid_grant and burns the code (OAuth 2.1 §4.1.3), and flags a reused code (reused: true) so the caller revokes tokens issued from it (RFC 6749 §4.1.2).
  • issuer: new unlinkableTimeClaims(now, exp, { acceptableAt }) and certsValidAt — credential iat/exp (and mdoc validity) rounded down to the hour so copies and verifiers cannot correlate them by the issuance instant (RFC 9901 §10.1); iat stays exact only when the rounded instant would precede the signing certificate or the issuer's listing.

0.7.1 — 2026-10-21 ​

  • Wallet side of ISO/IEC 18013-7 Annex C (org-iso-mdoc) in wallet-core. parseDcApiRequest now also accepts the browser's org-iso-mdoc request (parseDcApiMdocRequest): it parses DeviceRequest + EncryptionInfo, builds the SessionTranscript with the dcapi handover for the calling origin, and requires reader authentication (readerAuth) valid for that transcript — an unsigned request, or one signed for another origin, is refused (PV6). The reader certificate becomes the request's x509_hash client identifier, so the request goes through the same matchDcql → checkRp (approval, ADR-0056 K8) → registration certificate → disclosure policy path as OpenID4VP. The registration certificate travels in requestInfo.euWrprc (CBOR, rc-wrp+cwt) and is bound to the reader certificate (checkRegistrationCerts; new hasRegistrationCert; ADR-0056 K10 still refuses a request without one). respond answers with the selectively disclosed, device-signed DeviceResponse, HPKE-encrypted to the verifier (dcApiResponse, no POST). One document and one namespace per request (Tamga profile). mdoc: DeviceRequest version 1.1 is read as well.
  • verifier: the Annex C request carries the relying party's registration certificate (createMdocDcApiRequest({ registrationCwt }); the reference verifier reads the publisher's .cwt next to the JWT). Interop tests: wallet-core ↔ verifier for both browser protocols, origin binding and single use.
  • Reference verifier: Digital Credentials API test page /dc-api-test (sandbox only; the real network redirects to verify.sandbox.tamga.network/dc-api-test). It calls navigator.credentials.get with openid4vp-v1-signed, org-iso-mdoc or both, forwards the encrypted answer to the verifier and shows the outcome, the checks, the trace and (sandbox sample data only) the disclosed values; the page's server opens the request with an RP assertion like any relying party. A browser without the API gets a "not supported in this browser" message. /sample-site/start accepts dc_api_origin (only the site's own origin) and returns the DC API requests, so the sample site's "Share from this device" button works.
  • Per-site pseudonym bound to the registered domain (ADR-0031 K2). wallet-core derivePseudonym / presentPseudonym now refuse a site key that is a client identifier (x509_hash:…, x509_san_dns:… or any other prefixed value): the site is the relying party's registered dns_name from the trusted list, which wallets obtain with stableRpKey after checkRp. A verifier's access certificate can be reissued (new client_id) without changing anyone's pseudonym on that site; a test covers the whole path (signed request → registration → pseudonym) across a reissue with the same registration. recordPseudonymUse refreshes the stored value on every use. verifier verifyPseudonym rejects an expected site in client-identifier form.
  • ADR-0058 accepted (2026-10-21): access certificate profile (ETSI TS 119 411-8). The network's verifier access certificates (production and sandbox) were reissued with the same key: CN is the trade name, the SAN carries the registered domain name, the support address and an organisational email. Their client_id changed, their registration (dns_name) and the pseudonyms at those sites did not. pki-issue: --contact-uri is required for production access certificates, new --contact-email, and --key + --replace for a same-key reissue. The publisher warns when an ACTIVE production verifier's certificate has no SAN contact. The identity service certificate gets organizationIdentifier at the foundation handover (prepared, not done).
  • wallet-core: ts8ReportAttachment(state, entry, lookup) — the machine-readable attachment for a report to a data protection authority (EU TS8, RPT_DPA_04): the reported request's single record in the TS10 transaction log format (claim names, never values), with the same transactionIdentifier as in ts10TransactionLog.
  • pki-issue: --contact-uri writes the relying party's support address into the access certificate's SAN and --service-id writes a service identifier into OU (ETSI TS 119 411-8 §6.6.1; ADR-0058, proposed). Both optional; a production access certificate without --contact-uri gets a warning.
  • Wallet specification §5.4.1: item-by-item mapping of per-site pseudonyms to the EU pseudonym rules (ARF Topic 11, PA_01–PA_31), with the open points. ADR-0058 (proposed): access certificate profile and the timing of the identity service certificate change.
  • Documentation in Azerbaijani: docs.tamga.network/az/ and arf.tamga.network/az/ (machine translation, awaiting a native speaker's review; every translated page carries a short notice). Generated pages (release notes, binding rules, packages, API reference) and the ARF change page are English only; their /az/ addresses link to the English page.
  • Institution onboarding: a new working example, examples/05-institution-source — the institution's lookup endpoint for the hosted issuing service (it checks the signed request against the trust list: an agreed, ACTIVE relying-party record, aud, lifetime, single use; it returns only the fields the document type needs and never the national ID number). Tested against the hosted service end to end.
  • Example 02 (verify on your own server) now attaches the verifier's registration certificate to every request (registrationScope, read from trust.tamga.network/wrprc/index.json); since 0.7.0 Tamga Wallet refuses requests without one. The "Verify on your server" guide has the same step.
  • Registry tool: a REVOKED entry is final and a RETIRED one can only become REVOKED (same rule as the registry contracts); ACTIVE is reached again only from SUSPENDED. pki-issue --prod requires --dns and --org-id for access certificates.
  • Institution source contract: isced_f_code is required (null means no mapping: no credential is issued, E11).
  • ADR-0057 (accepted 2026-10-20): in hosted issuance the institution's signing key stays with the institution; signatures are requested through the Cloud Signature Consortium API v2 with the digest only.
  • Production trusted list: the network's own verifier (verify.tamga.network) and identity service (tamga-id) now carry their registration data (the tax number of the provisional operator, marked provisional until the foundation is established; postal address; data protection authority complaint route), so registration certificates are published for them (trust.tamga.network/wrprc/). The verifier's access certificate was reissued with the same key and carries organizationIdentifier (ADR-0026 K3); its client_id changed, its registration (dns_name) did not. Revoked records no longer produce registration-data warnings.

0.7.0 — 2026-10-20 ​

Misuse-resistant package defaults (ADR-0056). Code written against 0.6.0 has to pass the new required security inputs (or an explicit "none"); see the breaking changes below.

Breaking changes — misuse-resistant defaults (ADR-0056) ​

A security input that affects the acceptance decision is now required; forgetting it is a rejection, and skipping a check deliberately is written explicitly as "none". No compatibility layer (development stage, ADR-0029).

  • sd-jwt: verifySdJwtVc requires rootCertsDer (trust anchors, or "none" to skip the chain check deliberately); an empty or missing value fails at A3.
  • issuer: createPar requires allowedRedirectUris; a client without registered redirect addresses is rejected (invalid_redirect_uri).
  • trust / issuer / verifier: verifyWalletAttestation, verifyKeyAttestation (verifyKaProof, verifyAttestationProof) require statusOf and verifyPseudonym requires walletStatusOf (a status check, or "none"). New result field statusChecked; a successful PseudonymResult carries clientStatus.
  • verifier: verifyPresentation requires rp (the relying party's registration, null for an unregistered party, or "none" to skip E3 deliberately); omission is rejected at E3.
  • issuer: verifyDpop is replaced by verifyTokenDpop (token endpoint) and verifyResourceDpop (resource endpoints; access token and bound key required).
  • sd-jwt: verifyStatusListToken, verifyStatusListCwt and verifyStatusListAny require a fourth argument { expectedSignerFingerprints }; an unexpected signer fails with D3 before the signature check. The verifier pins the institution's registered status keys; WalletStatusChecker pins the wallet provider keys of the trusted list.
  • mdoc: verifyIssuerSigned returns valid: false when the MSO has no device key.
  • wallet-core: respond requires the approval that checkRp returns for the same request (ApprovedRequest; bound to client_id, nonce, response address/origin, signing certificate and intermediary). No approval for impersonation, an inactive registration or an unverified intermediary.
  • verifier: PassRegistry.issue({ verified, … }) takes the ACCEPTED output of verifyPresentation (in-process registry); the presentation input is removed.
  • wallet-core: a request without a registration certificate is rejected (registration_missing), remote and in proximity — the warning-until-2028 transition of ADR-0026 K5 is removed; WRPRC_REQUIRED_FROM and the time argument of missingRegistrationPolicy are removed. Wallet-to-wallet proximity is unchanged.
  • verifier: E4 is in checks_performed only when an audit function was given; otherwise it is in checks_skipped.
  • core: EpochSeconds / EpochMillis with epochSeconds, epochMillis, nowSeconds, nowMillis, secondsToMillis, millisToSeconds, secondsOrNow, millisOrNow (subpath @tamga-network/core/time for React Native). Acceptance functions take now in seconds; the wallet's registration certificate checks, checkRp, the disclosure policy and the verifier's scope helpers in milliseconds. The wrong unit is a compile error and a RangeError at run time.
  • verifier / schemas: a credential without a status entry is rejected at D1 when its type uses a status list (usesStatusList).
  • trust: rollback protection (TL2) is on by default — loads without versionMemory use an in-process memory per network and root fingerprints (versionMemory: "none" turns it off; resetDefaultListVersionMemory for tests).
  • Clock skew options (maxSkewSec, clockSkewSec, maxClockSkewSec) are capped at MAX_CLOCK_SKEW_SEC = 600 s.
  • New: isYes(output, claim) — reads a yes/no attribute safely (true only for an ACCEPTED result with the value exactly true).
  • Conformance vectors version 6: the status list vectors add an "unexpected signer" negative case; the runner pins the signer.

Trust list publisher (apps/trust-publisher) ​

  • Chain projection (ADR-0051, accepted 2026-10-19; off by default, no production chain exists): npm run trust:chain-submit writes only the digests of the signed trust lists (sha256(<file>.jws), version, previous digest, issue time) and of the anchor log's latest line to a trust list anchor registry contract; chain-check tells a verifier whether a list digest is anchored (YES / NO / UNKNOWN). The signed lists remain the source of truth: on conflict the list prevails and the chain answer is never required for verification. Feature flag TAMGA_CHAIN_ENABLED (default 0): while off nothing connects to a chain; --dry-run prints the plan. An anchor counts only once the registry's confirmation threshold of distinct writers has submitted identical data (production threshold ≥ 2). New dependency ethers (app only, not in the published packages). The command is chain-submit, not chain-anchor: one writer's submission is a vote, and the name stays clear of the hourly anchor log command trust:anchor.

  • Competing anchor candidates (ADR-0053): the first writer to open a list version can no longer lock it. When the registry holds a different, not yet confirmed digest for a version, chain-submit now submits its own verified digest as a competing candidate (decision CONTEST, reported as contested with a warning on stderr) instead of skipping it; the first candidate to reach the threshold wins and every conflict is an on-chain event. A confirmed different digest is still CONFLICT (exit code 3).

  • npm run trust:wallet-provider -- list|show|check|activate|suspend|revoke manages wallet_providers[] in the production and sandbox registries. activate checks the provider's signing certificate against the wallet attestation policy (EC P-256, ecdsa-with-SHA256, digitalSignature, not a CA, within its validity) and the ETSI TS 119 412-6 §5 profile: the subject's organizationIdentifier equals the one derived from the entry's identifiers[] (e.g. TR-VKN → VATTR-…) and the qcStatements carry the QcType id-etsi-qct-wal. check runs the same checks without writing (signing key rollover).

  • Tamga Wallet's provider TAMGA-WP-1 is ACTIVE in the production and the sandbox trust lists (certificate wallet-provider-tamga-wp-1).

Packages ​

  • sd-jwt: verifySdJwtVc option skipValidityPeriod — skips A7 (exp/nbf) for proofs of possession that are not acceptance decisions (the identity service's erasure request accepts an expired credential, whose record is still held).
  • issuer: redeemCode rejects a request without a code, or a PAR that has no code yet, as an unknown code (invalid_grant).
  • wallet-core: fixed wiaRevokedByList — the "entry beyond the list" bound assumed 2-bit status lists; on a 1-bit list a revoked WIA entry in the upper half of the last bytes read as "not revoked". The bound now follows the list's bits (new wiaRevokedInList).
  • wallet-core: proximity presentation (presentProximity) and the wallet-to-wallet holder (presentToPerson) no longer offer a suspended credential — the same rule as the remote presentation (matchDcql).
  • verifier: documented that the mdoc A3 step anchors the x5chain leaf directly (anchor itself or signed by the anchor; no intermediates) — conformant with ISO/IEC 18013-5 Annex B (document signer issued directly by the IACA). SPEC-API-0001 A3 row.
  • Misuse guards (security review 2026-10-19). Checks that compared against an expected value now fail when the expected value is empty or missing instead of comparing against it: sd-jwt verifySdJwtVc with a KB-JWT (expected aud/nonce), issuer verifyProofJwt (credential_issuer/c_nonce), verifyKaProof and verifyAttestationProof (nonce), verifyDpop with jkt: "" (a token record without its bound key), verifier pass-key proof and verifyPseudonym. verifier verifyPresentation returns INDETERMINATE at T0 when the policy's freshness limits are missing or not finite non-negative numbers (or max_clock_skew_sec > 600) — before, a missing limit silently disabled the trust-list and status token age checks. allowLocalIssuerUrls compares the host name exactly (http://localhost.example.org is not local). wallet-core missingRegistrationPolicy throws when given seconds instead of milliseconds (with seconds the 2028 rejection date was never reached). Reported steps match what ran: verifySdJwtVc lists A6 only when a KB-JWT was verified, and verifyIssuedSdJwt lists B4 only when the catalogue knows the type.

Reference verifier (apps/verify) ​

  • Fixed: the scope check E3 now uses the registration of the relying party that opened the presentation. Before, a presentation opened on behalf of another relying party was checked against the verifier's own (wider) registration, so a wallet that disclosed more than asked could pass that party an attribute outside its registered scope (ADR-0017 K7/HV6, AP6).
  • The control view key (?show=) is compared in constant time.
  • Rate limits no longer share one bucket behind the reverse proxy (which does not pass client addresses): opening a presentation counts against the authenticated relying party's own bucket (unauthenticated requests share one), and the wallet response endpoints (/vp/response, /vp/dc-mdoc/:id) count per presentation after the cheap lookups. Before, one client within the proxy's per-address allowance could exhaust the shared bucket and block every relying party.
  • Fixed: sign-in with a site pseudonym now checks that the wallet unit is not revoked (the WIA's client_status list, signed by a wallet provider in the trusted list), as ADR-0031 PS5 requires. Before, the hosted verifier checked the WIA's signature but not its revocation, so a wallet unit closed after a lost phone could still sign in to sites.

Documents ​

  • ADR-0056 (accepted 2026-10-19): misuse-resistant package defaults (above). ADR-0026 K5: a request without a registration certificate is rejected from today (the transition until 2028-08-11 is removed). SPEC-API-0001: E3 needs the RP registration ("none" skips), E4 only with an audit sink, D1 rejects a missing status entry for status-list types, D3 pins the signer; SPEC-CRED-0003 signer pinning; SPEC-PROTO-0001 PAR allowlist and the two DPoP functions; SPEC-PROTO-0002 / SPEC-WALLET-0001 wallet approval and registration rule. Tamga ARF RB-WP-19 updated.
  • ADR-0052 (accepted 2026-10-19): Besu 25.6.0 removed onchain permissioning and Tessera privacy, so the chain stage uses Besu local permissioning — a permissions_config.toml (node and account allowlists) on every node, derived from the on-chain contract state, identical on all validators and checked for drift; a node's JSON-RPC endpoint is never exposed to the internet (reverse proxy with mTLS). The onchain permissioning contract assumption is removed from the chain-stage documents.
  • Status list verification step Ş5 and verification step D4: ttl is a refresh hint; the token stays usable until exp and the policy's max_status_token_age_sec (as in §8.1 and in the code). PR13: a redirect address outside the allowlist is rejected with invalid_request (RFC 9126 §2.1), as the services answer.

Fixed before release (code review 2026-10-20) ​

  • verifier: verifyPresentation with rp: null (unregistered relying party) is now always rejected at E3, as SPEC-API-0001 specifies. Before, a presentation that disclosed no claims passed E3 with an unregistered party (an empty scope has no overrun).
  • wallet-core / trust: TrustPins.versionMemory carries a persistent "last seen" list version memory (TL2) to every helper that loads the trusted list (fetchTrustSource, fetchRpRecord, fetchRegistrarKeys, the issuer directory). Without it the rollback protection is in-process only and resets when the app restarts. @tamga-network/trust/core now exports ListVersionMemory, ListMark and MemoryListVersionMemory.

0.6.0 — 2026-10-13 ​

EU alignment (ADR-0048, ADR-0049, ADR-0026 K5, EU TS9, ISO/IEC 18013-7 Annex C). Credentials issued with earlier packages — identity credentials and diplomas — have to be issued again (new status lists; the diploma's Type Metadata changed, ADR-0029).

  • sd-jwt, mdoc: status lists with 1 or 2 bits per entry (the identity service publishes bits = 1, institutions bits = 2); the CWT form of the same list (application/statuslist+cwt) for mdoc copies; verifyStatusListAny.
  • schemas: suspension_allowed (diploma only); the verifier rejects a suspension value in a type without suspension.
  • mdoc: reader authentication (signReaderAuth, verifyReaderAuth), requestInfo with the CBOR registration certificate (euWrprc), the EU TS9 presentation offer, status-only DeviceResponse, HPKE and ISO/IEC 18013-7 Annex C.
  • verifier, apps/verify: browser verification through the Digital Credentials API by default (Annex C for Apple WebKit, QR as a fallback on desktop); the cross-device and the DC API requests are separate objects with their own keys.
  • wallet-core: a request without a registration certificate carries a warning and defaults to "don't share" (refused after 2028-08-11); proximity readers are verified against the trust list's anchors (readerTrust, breaking); wallet-to-wallet presentations follow the TS9 offer; new log events and log retention.
  • trust: walletProviderListing for the "Listed on Tamga Network" indicator (ADR-0049).
  • issuer: keyStorageStatus policy for key attestations.
  • Conformance vectors version 5 (status lists in JWT and CWT).

0.5.2 — 2026-10-13 ​

Security fixes and EU format alignment (0.5.1 was not published). Breaking: registrationCert (one per request) and the wallet attestation result (clientStatus).

  • Security: an embedded disclosure policy is evaluated only when the access certificate is anchored in the trust list; trust anchors may be certificates (TrustAnchor); status list fetching only over https, on hosts the issuer declares, never to private addresses, redirects re-checked and connections pinned (SSRF, DNS rebinding); external issuers' identifier list hosts come from the external list or the document signer certificate.
  • EU format: iat in the request object header and the chain without the root (TS 119 472-2); one registration certificate per request; every OAuth client attestation (draft -07) is read as a wallet instance attestation; vc+sd-jwt accepted for external types; DCQL trusted_authorities with etsi_tl.
  • Hardening: wallet status lists under 10,000 entries are refused (CIR 2026/1731).
  • Fixes: wallet-to-wallet revocation checks have three outcomes; mdoc clock tolerance only at validFrom; an unreadable mdoc status entry invalidates the credential; the revocation maintenance period is compared with a tolerance.

0.5.0 — 2026-10-12 ​

  • Embedded disclosure policy (ADR-0046): core/disclosure-policy, published by the issuer in its metadata, stored and evaluated offline by wallet-core; never sent to the verifier.
  • Issuer preferences for wallet attestations (EU ARF WUA_05a, WUA_32, ISSU_12c): issuerAttestationPrefs, capToRevocationMaintenance.
  • EU trusted lists in the XML format (ETSI TS 119 612): readTrustedListXml with platform-independent XMLDSig; external etsi-tl-xml lists also in the wallet. New dependency @xmldom/xmldom.
  • Attestation Revocation List (identifier list, CWT) verified in step D and in the wallet.
  • Wallet-to-wallet protocol in wallet-core; the registration certificate carries service_id; optional revocation_policy_uri for institutions (ADR-0047).

0.4.0 — 2026-10-12 ​

  • Identity credential attribute names follow the EU PID encoding (ADR-0045): birthdate, nationalities[] (SD-JWT VC); birth_date, nationality (mdoc). New core/pid subpath.
  • Zero-knowledge presentations only with the short-lived ZK copy urn:tamga:id:ShortLivedIdentityAttestation:1 (≤ 24 hours, no revocation entry, refreshed by wallet-core; ADR-0044).
  • mdoc verifyIssuerSigned({ clockSkewSec }); issuer issuerMetadata({ mdocConfigurations }).

0.3.1 — 2026-10-09 ​

  • sd-jwt: a status list token is valid until its exp plus the policy's maximum age (the 6-hour outage buffer of the network's lists); signStatusListToken({ expSec }).
  • verifier: a missing accept_unrevocable_zk means false.
  • wallet-core: on invalid_nonce the wallet fetches a fresh nonce and retries once.

0.3.0 — 2026-10-09 ​

Alignment with OpenID4VCI 1.0 Final, OpenID4VP 1.0 and HAIP 1.0: key attestation typ key-attestation+jwt; the nonce only from the nonce endpoint; no notification_id; OpenID4VCI 1.0 error codes; SD-JWT disclosure serialisation as specified.

0.2.0 — 2026-10-08 ​

The nine packages as a set: core, trust, schemas, sd-jwt, mdoc, issuer (+ /client), verifier (+ /web, /zk), wallet-core, zk (wallet-side Longfellow ZK prover: /node, /react-native).

0.1.0 — 2026-09-28 ​

First publication of the package names on npm.

Documentation 1.0.0 — 2026-10-16 ​

The current state of the documentation set; changes before the public announcement are made in this release.

  • Tamga ARF 1.0 (arf.tamga.network, English and Turkish): the main document; Annex A — Trust Framework; Annex B — Tamga Rulebook; Annex C — the Education, Identity, Event Ticket and Contact Rulebooks in the EU Attestation Rulebook template; Annex D — Definitions; Annex E — References; the Revocation Policy and the Wallet Attestation Policy (mapped to ETSI TS 119 471); Reading path, Roles and Onboarding.
  • Developer documentation (docs.tamga.network, English and Turkish): guides (including the sandbox), concepts, specifications, decision records ADR-0001 … ADR-0050, the API reference generated from the OpenAPI files, and a glossary.
  • Services: trust lists (trust.tamga.network), the reference verifier Tamga Verify (verify.tamga.network) and the sandbox test network (sandbox.tamga.network). The network operates no wallet (ADR-0042); it lists wallet providers, and Tamga Wallet's provider is listed as ACTIVE.