@metalabel/dfos-protocol 0.44.0 → 0.46.0

package/dist/index.js

@@ -6,10 +6,12 @@ import {
   CountersignPayload,
   CreditClaimPayload,
   CreditClaimVerifyError,
+  DeclaredKeyState,
   IdentityOperation,
   Iso8601,
   MAX_ARTIFACT_PAYLOAD_SIZE,
   MAX_CREDIT_CLAIM_SIZE,
+  MAX_KEY_PROOFS,
   MAX_OPERATION_SIZE,
   MAX_SERVICES_ENTRIES,
   MAX_SERVICES_PAYLOAD_SIZE,
@@ -23,6 +25,7 @@ import {
   SignRequestPayload,
   SignRequestVerifyError,
   VerifiedIdentity,
+  VoidKeyMembership,
   anchorsByLabel,
   assertCanonicalSignRequestPayload,
   assertServicesWithinCap,
@@ -49,7 +52,7 @@ import {
   verifyIdentityExtensionFromTrustedState,
   verifyRevocation,
   verifySignRequest
-} from "./chunk-4YBXPYEU.js";
+} from "./chunk-ZRA7FRBE.js";
 import {
   ApiRequestVerifyError,
   Attenuation,
@@ -90,12 +93,20 @@ import {
 import {
   DEFAULT_KEY_PROOF_SKEW_SECONDS,
   KEY_ADD_JWS_TYP,
+  KEY_ROLES,
   KeyProofVerifyError,
   MAX_KEY_PROOF_SIZE,
+  isCanonicalRoleSet,
   keyProofSigningInput,
+  keyWordFingerprint,
+  parseRoleSet,
+  roleSetCovers,
+  serializeRoleSet,
   signKeyProof,
+  unsafeKeyProofSubject,
+  verifyChainKeyProof,
   verifyKeyProof
-} from "./chunk-VEJBAY3T.js";
+} from "./chunk-JVSC67DC.js";
 import {
   ED25519_PRIV_MULTICODEC,
   ED25519_PUB_MULTICODEC,
@@ -152,6 +163,7 @@ export {
   DEFAULT_PROOF_WINDOW_SECONDS,
   DFOSCredentialPayload,
   DFOS_AUTH_SCHEME,
+  DeclaredKeyState,
   ED25519_PRIV_MULTICODEC,
   ED25519_PUB_MULTICODEC,
   EMPTY_BODY_SHA256,
@@ -162,11 +174,13 @@ export {
   JwsVerificationError,
   JwtVerificationError,
   KEY_ADD_JWS_TYP,
+  KEY_ROLES,
   KeyProofVerifyError,
   MAX_ARTIFACT_PAYLOAD_SIZE,
   MAX_BODY_BYTES,
   MAX_CREDENTIAL_SIZE,
   MAX_CREDIT_CLAIM_SIZE,
+  MAX_KEY_PROOFS,
   MAX_KEY_PROOF_SIZE,
   MAX_OPERATION_SIZE,
   MAX_PROOF_FRESHNESS_SPAN_SECONDS,
@@ -184,6 +198,7 @@ export {
   SignRequestPayload,
   SignRequestVerifyError,
   VerifiedIdentity,
+  VoidKeyMembership,
   anchorsByLabel,
   apiIdentitySigningInput,
   apiRequestSigningInput,
@@ -220,11 +235,13 @@ export {
   importEd25519Keypair,
   invalidProof,
   isAttenuated,
+  isCanonicalRoleSet,
   isCanonicallyEqual,
   isRecognizedServiceType,
   isValidEd25519Signature,
   isValidId,
   keyProofSigningInput,
+  keyWordFingerprint,
   linearize,
   matchesResource,
   misconfiguredProof,
@@ -232,7 +249,10 @@ export {
   parseDagCborCID,
   parseDfosAuthorization,
   parseProtocolTimestampUnix,
+  parseRoleSet,
   relayEndpoints,
+  roleSetCovers,
+  serializeRoleSet,
   sha256,
   sha256BodyHash,
   signApiIdentityRequest,
@@ -245,8 +265,10 @@ export {
   signKeyProof,
   signPayloadEd25519,
   signRevocation,
+  unsafeKeyProofSubject,
   unverifiableProof,
   verifyArtifact,
+  verifyChainKeyProof,
   verifyContentChain,
   verifyContentExtensionFromTrustedState,
   verifyCountersignature,

package/dist/key-proof/index.d.ts

@@ -1,3 +1,47 @@
+/**
+ * The CLOSED role set. Membership in an identity operation's `authKeys`,
+ * `assertKeys`, and `controllerKeys` arrays respectively — the three positions a
+ * key can hold in a chain, and the only three a proof can consent to.
+ *
+ * THIS ORDER IS THE CANONICAL SERIALIZATION ORDER. It is not sorted; it is the
+ * order the roles appear in an identity operation.
+ */
+declare const KEY_ROLES: readonly ["auth", "assert", "controller"];
+/** One role a key can hold in an identity chain. */
+type KeyRole = (typeof KEY_ROLES)[number];
+/**
+ * Serialize a set of roles to its ONE canonical spelling. Duplicates in the input
+ * collapse (a set is a set); an unknown role or an empty result throws, because
+ * neither can be signed.
+ *
+ * This is the producer half. `parseRoleSet` is the verifier half, and the two are
+ * inverses on exactly the canonical strings: `parseRoleSet(serializeRoleSet(r))`
+ * round-trips, and `serializeRoleSet(parseRoleSet(s)) === s` for every `s` the
+ * parse admits.
+ */
+declare const serializeRoleSet: (roles: Iterable<KeyRole>) => string;
+/**
+ * Parse a role set from its canonical spelling, or `null` when the bytes are not
+ * that spelling. Returns `null` rather than throwing so the caller raises the
+ * failure in ITS OWN vocabulary — a `schema` rejection inside key-proof
+ * verification, a chain error inside the identity walk.
+ *
+ * THE PARSE IS THE CANONICALITY CHECK. It is strict in every direction at once:
+ * an unknown role, a duplicate, a member out of the fixed order, any whitespace
+ * (` auth` is not `auth`), an empty segment, and the empty string all return
+ * `null`. There is no lenient mode and no normalization — a producer that meant
+ * `auth,assert` must spell it `auth,assert`.
+ */
+declare const parseRoleSet: (value: string) => KeyRole[] | null;
+/** True when `value` is exactly the canonical spelling of the set it names. */
+declare const isCanonicalRoleSet: (value: string) => boolean;
+/**
+ * Does this role set cover `role`? The question the CHAIN WALK asks: an
+ * introduction of key K to role R is proved only by an envelope whose role set
+ * includes R. A non-canonical role set covers nothing — it never parsed.
+ */
+declare const roleSetCovers: (value: string, role: KeyRole) => boolean;
+
 /**
  * The first registered purpose in KEY-PROOF.md's purpose registry: the candidate
  * key presents for addition to a ceremony-named identity's `authKeys`/
@@ -17,22 +61,38 @@ declare const MAX_KEY_PROOF_SIZE = 4096;
  */
 declare const DEFAULT_KEY_PROOF_SKEW_SECONDS = 300;
 /**
- * The closed payload. Exactly these four members, each a string, in exactly this
+ * The closed payload. Exactly these seven members, each a string, in exactly this
  * order — the member set is EXHAUSTIVE and no amendment may introduce a member
  * that carries intent or content.
  */
 interface KeyProofPayload {
     /** The verifier-minted, single-use challenge, exactly as the carriage delivered it. */
     nonce: string;
-    /** The completion endpoint's lowercase authority — `host`, or `host:port` off 443. */
+    /**
+     * The completing authority's lowercase authority — `host`, or `host:port` off
+     * 443. Held here as an opaque string: a leg whose completing authority IS a
+     * chain rather than a host audiences to that chain's DID, byte-equal to `did`,
+     * and this module does not special-case the two spellings. The VERIFIER
+     * supplies the expectation; the envelope only carries what it was signed for.
+     */
     audience: string;
+    /** The chain this key is introduced to. */
+    did: string;
+    /** The canonical role set (see role-set.ts) this envelope consents to. */
+    roleSet: string;
+    /**
+     * The chain head the introduction builds on — equal to the introducing
+     * operation's `previousOperationCID`. The member that forecloses standing
+     * consent.
+     */
+    prevCID: string;
     /** The candidate key's Multikey — and the key that signs this envelope. */
     publicKeyMultibase: string;
     /** ISO 8601 creation time, floor-normalized to whole seconds (`.000Z`). */
     timestamp: string;
 }
 /** The verification step a failure arose in. Branch on this, never on message text. */
-type KeyProofFailureReason = 'size' | 'header' | 'schema' | 'audience' | 'freshness' | 'signature';
+type KeyProofFailureReason = 'size' | 'header' | 'schema' | 'audience' | 'did' | 'roleSet' | 'prevCID' | 'key' | 'freshness' | 'signature';
 /** Thrown by `verifyKeyProof`. Branch on `reason`, never on message text. */
 declare class KeyProofVerifyError extends Error {
     readonly reason: KeyProofFailureReason;
@@ -41,7 +101,8 @@ declare class KeyProofVerifyError extends Error {
 /**
  * THE BYTE CONTRACT. Serializes a payload to the canonical bytes that ARE the
  * JWS payload segment: minimal UTF-8 JSON, no insignificant whitespace, members
- * in exactly the order `nonce, audience, publicKeyMultibase, timestamp`.
+ * in exactly the order `nonce, audience, did, roleSet, prevCID,
+ * publicKeyMultibase, timestamp`.
  *
  * PURE and clientless: import it in a holder's signing tool and in a ceremony
  * operator's verifier alike. Byte-for-byte identical to Go's
@@ -53,8 +114,17 @@ interface SignKeyProofInput {
     typ: string;
     /** The verifier-minted nonce, exactly as the carriage delivered it. */
     nonce: string;
-    /** The completion endpoint's lowercase authority — the one the human confirmed. */
+    /** The completing authority — the one the human confirmed. */
     audience: string;
+    /** The chain this key is being introduced to. */
+    did: string;
+    /**
+     * The canonical role set — build it with `serializeRoleSet` rather than by
+     * hand; a non-canonical spelling is refused here, not silently normalized.
+     */
+    roleSet: string;
+    /** The chain head the introduction builds on. */
+    prevCID: string;
     /**
      * The candidate key's raw 32-byte Ed25519 private key. `publicKeyMultibase` is
      * DERIVED from it rather than accepted as an input: this envelope is
@@ -77,12 +147,20 @@ interface SignKeyProofInput {
  * carry.
  *
  * HOLDER OBLIGATIONS THIS FUNCTION CANNOT DISCHARGE (KEY-PROOF.md, Holder
- * Obligations). A holder MUST show its human the audience and the purpose before
- * calling this, and SHOULD refuse to sign for a key any identity's chain has
- * ever declared — the `key=` reverse index is has-ever-declared, and one key in
- * two chains publishes an irreversible public link between them. Both are
- * decisions about a human and a network, made before there is a signature to
- * make; neither belongs to a pure signer.
+ * Obligations). A holder MUST show its human — before calling this — the
+ * audience, the purpose, the adopting identity, and the roles. A proof is
+ * consent, and consent that was never displayed was never given.
+ *
+ * It SHOULD also refuse to sign for a key some identity's chain has already
+ * PROVED, its own included: the `key=` reverse index is has-ever-proved across
+ * all three key sets, its rows survive rotation and deletion, and proving one
+ * key into two chains publishes an irreversible public link between them. An
+ * unproved DECLARATION of the key elsewhere is neither a link nor a burn — it is
+ * void, it never indexes, and it never obligates the true holder, which is
+ * precisely why the index counts proofs and not claims.
+ *
+ * Every one of those is a decision about a human and a network, made before
+ * there is a signature to make; none belongs to a pure signer.
  */
 declare const signKeyProof: (input: SignKeyProofInput) => Promise<{
     proof: string;
@@ -102,6 +180,28 @@ interface VerifyKeyProofOptions {
      * defense against challenge relay.
      */
     expectedAudience: string;
+    /**
+     * THE CHAIN THIS CEREMONY IS COMPLETING FOR. Like the audience, it is the
+     * completing authority's own value — the identity whose ceremony this is — and
+     * never a DID read back out of the envelope being checked.
+     */
+    expectedDid: string;
+    /**
+     * THE ROLES THIS CEREMONY GRANTS, in canonical spelling (`serializeRoleSet`).
+     * Byte-equality, not coverage: a ceremony that will write `auth,assert` MUST
+     * NOT accept an envelope consenting to `auth` alone, and MUST NOT accept one
+     * consenting to `auth,assert,controller` either — the second is the holder
+     * conceding more than was asked, which a completing authority has no business
+     * banking. A non-canonical expectation is a MISCONFIGURATION and throws.
+     */
+    expectedRoleSet: string;
+    /**
+     * THE HEAD THE INTRODUCTION WILL BUILD ON — the `previousOperationCID` the
+     * completing authority is about to write. A chain that moved between minting
+     * the challenge and completing it invalidates the proof here rather than
+     * writing an operation whose embedded envelope no walker will accept.
+     */
+    expectedPrevCID: string;
     /** Acceptance window, seconds, EITHER SIDE. Default `DEFAULT_KEY_PROOF_SKEW_SECONDS`. */
     maxSkewSeconds?: number;
     /** Clock injection (unix ms). Default `Date.now()`. */
@@ -122,10 +222,15 @@ interface VerifiedKeyProof {
     now: number;
 }
 /**
- * Verify a key proof — KEY-PROOF.md's verification algorithm steps 1–5 and 7:
- * size cap, header gates, the closed payload schema over CANONICAL bytes,
- * audience byte-equality, freshness, and the signature against the payload's OWN
- * `publicKeyMultibase`.
+ * Verify a key proof AT PRESENTATION TIME — KEY-PROOF.md's verification algorithm
+ * steps 1–5 and 7: size cap, header gates, the closed payload schema over
+ * CANONICAL bytes, the four expectation arms (audience, did, roleSet, prevCID),
+ * freshness, and the signature against the payload's OWN `publicKeyMultibase`.
+ *
+ * EVERY EXPECTATION IS THE DEPLOYMENT'S OWN VALUE. There is no arm here that
+ * compares the envelope to itself. `expectedDid`, `expectedRoleSet` and
+ * `expectedPrevCID` are the position the completing authority is about to WRITE;
+ * if the envelope names a different one, the holder consented to something else.
  *
  * STEP 6 (NONCE) IS THE CALLER'S, and this function cannot stand in for it. The
  * nonce MUST be one this verifier minted, for this ceremony, not yet consumed,
@@ -134,11 +239,89 @@ interface VerifiedKeyProof {
  * `payload.nonce` precisely so the caller can run that step next. Without it a
  * proof is replayable for the length of the freshness window.
  *
- * What the seven steps together establish is exactly one fact: THE NAMED KEY WAS
- * HELD, AND CONSENTED TO THIS CEREMONY AT THIS VERIFIER, INSIDE THIS WINDOW.
- * Everything after — appending the key to a chain, custody policy, notification
- * — is the ceremony operator's.
+ * What the steps together establish is exactly one fact: THE NAMED KEY WAS HELD,
+ * AND CONSENTED TO THIS POSITION IN THIS CHAIN AT THIS VERIFIER, INSIDE THIS
+ * WINDOW. Everything after — appending the key to a chain, custody policy,
+ * notification — is the ceremony operator's.
  */
 declare const verifyKeyProof: (jws: string, options: VerifyKeyProofOptions) => VerifiedKeyProof;
+interface VerifyChainKeyProofOptions {
+    /** The registered `typ` the introduction requires — `KEY_ADD_JWS_TYP`. */
+    expectedTyp: string;
+    /** The DID of the chain being walked. */
+    did: string;
+    /** The carrying operation's `previousOperationCID`. */
+    prevCID: string;
+    /** The Multikey of the key this envelope is being read as the proof FOR. */
+    publicKeyMultibase: string;
+    /** The role the introduction needs covered. Coverage, not equality — see below. */
+    role: KeyRole;
+}
+/**
+ * Verify a key proof AT CHAIN-WALK TIME — the mode a replayer uses on an envelope
+ * embedded in a signed identity operation.
+ *
+ * WHAT IT CHECKS: the signature, the `typ`, the closed schema over canonical
+ * bytes, and the four position arms — `publicKeyMultibase` is the key being
+ * introduced, `did` is this chain, `prevCID` is the carrying operation's
+ * `previousOperationCID`, and `roleSet` COVERS the role in question.
+ *
+ * WHAT IT DELIBERATELY DOES NOT CHECK, AND WHY. Neither FRESHNESS nor AUDIENCE.
+ * Both are properties of a live ceremony, and the walk is not one: the envelope
+ * was fresh when it was presented, against a clock and an authority that belonged
+ * to the completing operator and not to whoever replays the chain a year later.
+ * Checking freshness at walk time would make every chain expire; checking
+ * audience would make a chain verifiable only by the relay that wrote it. The two
+ * members still travel, still sign, and are still returned — they are FIXED
+ * TRANSPORT the signature covers, evidence of which ceremony this was, not gates
+ * a walker is positioned to run.
+ *
+ * COVERAGE, NOT EQUALITY, ON THE ROLE. Presentation-time takes byte equality
+ * because the completing authority knows exactly which roles it is about to
+ * write. The walk asks a narrower question, once per (key, role) introduction:
+ * did the holder consent to THIS role? One envelope consenting to
+ * `auth,assert,controller` therefore proves three introductions in one operation,
+ * which is the ordinary rotation case.
+ *
+ * Returns the validated payload. Throws `KeyProofVerifyError` — a chain walker
+ * treats every throw as "this introduction is not proved", never as "this chain
+ * is invalid": an unproved introduction voids a key-role membership and nothing
+ * more.
+ */
+/**
+ * The `publicKeyMultibase` an envelope NAMES, read WITHOUT verifying anything —
+ * no signature, no schema, no gates. `null` when the bytes do not decode to an
+ * object carrying a string there.
+ *
+ * UNSAFE IS IN THE NAME BECAUSE THE ANSWER PROVES NOTHING. The only sound use is
+ * as an INDEX HINT. An operation carrying several envelopes and introducing
+ * several keys would otherwise be a quadratic scan — every envelope gated
+ * against every candidate — so the chain walk uses this to pick WHICH candidate
+ * an envelope is about, then runs the full `verifyChainKeyProof` against that
+ * candidate's real, DECLARED Multikey. The gate's own `publicKeyMultibase` arm
+ * is what makes the pairing sound: a wrong or forged hint routes the envelope to
+ * a candidate it then fails against, which is exactly the verdict the exhaustive
+ * scan would have reached. Never read this value as an assertion about a key.
+ */
+declare const unsafeKeyProofSubject: (jws: string) => string | null;
+declare const verifyChainKeyProof: (jws: string, options: VerifyChainKeyProofOptions) => KeyProofPayload;
+
+/**
+ * The word fingerprint of a key: six lowercase words, space-joined, from the
+ * first six bytes of SHA-256 over the UTF-8 bytes of the key's multikey string.
+ *
+ * Both surfaces a human compares a key across SHOULD render this, and render it
+ * from the same string — the `publicKeyMultibase` as the chain declares it, `z…`
+ * form, no `did:key:` prefix and no truncation.
+ *
+ * The input is not validated: this renders words for eyes, and admission of a
+ * multikey happens elsewhere.
+ *
+ * ```ts
+ * keyWordFingerprint('z6MkrzLMNwoJSV4P3YccWcbtk8vd9LtgMKnLeaDLUqLuASjb')
+ * // 'ragtime decadence python coherence belfast provincial'
+ * ```
+ */
+declare const keyWordFingerprint: (publicKeyMultibase: string) => string;
 
-export { DEFAULT_KEY_PROOF_SKEW_SECONDS, KEY_ADD_JWS_TYP, type KeyProofFailureReason, type KeyProofPayload, KeyProofVerifyError, MAX_KEY_PROOF_SIZE, type SignKeyProofInput, type VerifiedKeyProof, type VerifyKeyProofOptions, keyProofSigningInput, signKeyProof, verifyKeyProof };
+export { DEFAULT_KEY_PROOF_SKEW_SECONDS, KEY_ADD_JWS_TYP, KEY_ROLES, type KeyProofFailureReason, type KeyProofPayload, KeyProofVerifyError, type KeyRole, MAX_KEY_PROOF_SIZE, type SignKeyProofInput, type VerifiedKeyProof, type VerifyChainKeyProofOptions, type VerifyKeyProofOptions, isCanonicalRoleSet, keyProofSigningInput, keyWordFingerprint, parseRoleSet, roleSetCovers, serializeRoleSet, signKeyProof, unsafeKeyProofSubject, verifyChainKeyProof, verifyKeyProof };

package/dist/key-proof/index.js

@@ -1,20 +1,36 @@
 import {
   DEFAULT_KEY_PROOF_SKEW_SECONDS,
   KEY_ADD_JWS_TYP,
+  KEY_ROLES,
   KeyProofVerifyError,
   MAX_KEY_PROOF_SIZE,
+  isCanonicalRoleSet,
   keyProofSigningInput,
+  keyWordFingerprint,
+  parseRoleSet,
+  roleSetCovers,
+  serializeRoleSet,
   signKeyProof,
+  unsafeKeyProofSubject,
+  verifyChainKeyProof,
   verifyKeyProof
-} from "../chunk-VEJBAY3T.js";
+} from "../chunk-JVSC67DC.js";
 import "../chunk-IDVYITX7.js";
 import "../chunk-4LG2GEB2.js";
 export {
   DEFAULT_KEY_PROOF_SKEW_SECONDS,
   KEY_ADD_JWS_TYP,
+  KEY_ROLES,
   KeyProofVerifyError,
   MAX_KEY_PROOF_SIZE,
+  isCanonicalRoleSet,
   keyProofSigningInput,
+  keyWordFingerprint,
+  parseRoleSet,
+  roleSetCovers,
+  serializeRoleSet,
   signKeyProof,
+  unsafeKeyProofSubject,
+  verifyChainKeyProof,
   verifyKeyProof
 };

package/examples/identity-restore.json

@@ -3,9 +3,9 @@
   "type": "identity",
   "chain": [
     "eyJhbGciOiJFZERTQSIsInR5cCI6ImRpZDpkZm9zOmlkZW50aXR5LW9wIiwia2lkIjoia2V5X3I5ZXYzNGZ2YzIzejk5OXZlYWFmdDgzbm4yOXp2aGUiLCJjaWQiOiJiYWZ5cmVpY29naHZqem52bGl1bG94eG1iZjU0dHB6cXdhaG5xcGlsazduY3hlcGppbmVkcGtnYTNuZSJ9.eyJ2ZXJzaW9uIjoxLCJ0eXBlIjoiY3JlYXRlIiwiYXV0aEtleXMiOlt7ImlkIjoia2V5X3I5ZXYzNGZ2YzIzejk5OXZlYWFmdDgzbm4yOXp2aGUiLCJ0eXBlIjoiTXVsdGlrZXkiLCJwdWJsaWNLZXlNdWx0aWJhc2UiOiJ6Nk1rcnpMTU53b0pTVjRQM1ljY1djYnRrOHZkOUx0Z01LbkxlYURMVXFMdUFTamIifV0sImFzc2VydEtleXMiOlt7ImlkIjoia2V5X3I5ZXYzNGZ2YzIzejk5OXZlYWFmdDgzbm4yOXp2aGUiLCJ0eXBlIjoiTXVsdGlrZXkiLCJwdWJsaWNLZXlNdWx0aWJhc2UiOiJ6Nk1rcnpMTU53b0pTVjRQM1ljY1djYnRrOHZkOUx0Z01LbkxlYURMVXFMdUFTamIifV0sImNvbnRyb2xsZXJLZXlzIjpbeyJpZCI6ImtleV9yOWV2MzRmdmMyM3o5OTl2ZWFhZnQ4M25uMjl6dmhlIiwidHlwZSI6Ik11bHRpa2V5IiwicHVibGljS2V5TXVsdGliYXNlIjoiejZNa3J6TE1Od29KU1Y0UDNZY2NXY2J0azh2ZDlMdGdNS25MZWFETFVxTHVBU2piIn1dLCJjcmVhdGVkQXQiOiIyMDI2LTAzLTA3VDAwOjAwOjAwLjAwMFoifQ.TeznHnzrtKOGTr0FzkDL2z-luMWnAbKXrmDbi-Exgw_xMPCnYwGHORMjw-BM28f0RoTirIAeD7d20W5RSuGuBg",
-    "eyJhbGciOiJFZERTQSIsInR5cCI6ImRpZDpkZm9zOmlkZW50aXR5LW9wIiwia2lkIjoiZGlkOmRmb3M6Y25ubmZ0OWY4YTJybjkzOGQ2bmt6MzhyODQ3djJrciNrZXlfcjlldjM0ZnZjMjN6OTk5dmVhYWZ0ODNubjI5enZoZSIsImNpZCI6ImJhZnlyZWliZnVoNjN1djMzaTJpNWVvb2UzYm9pdDJydXlqZWh1YnNyeWVtdXV6Nm1ydGxlajI2cmVpIn0.eyJ2ZXJzaW9uIjoxLCJ0eXBlIjoidXBkYXRlIiwicHJldmlvdXNPcGVyYXRpb25DSUQiOiJiYWZ5cmVpY29naHZqem52bGl1bG94eG1iZjU0dHB6cXdhaG5xcGlsazduY3hlcGppbmVkcGtnYTNuZSIsImF1dGhLZXlzIjpbeyJpZCI6ImtleV9lejlhODc0dGNrcjNkdjkzM2QzY2tkbjd6NnpyY3Q4IiwidHlwZSI6Ik11bHRpa2V5IiwicHVibGljS2V5TXVsdGliYXNlIjoiejZNa2ZVZDY1SnJBaGZkZ0Z1TUNjY1U5VGhRdmpCMmZKQU1VSGt1dWFqRjk5MmdLIn1dLCJhc3NlcnRLZXlzIjpbeyJpZCI6ImtleV9lejlhODc0dGNrcjNkdjkzM2QzY2tkbjd6NnpyY3Q4IiwidHlwZSI6Ik11bHRpa2V5IiwicHVibGljS2V5TXVsdGliYXNlIjoiejZNa2ZVZDY1SnJBaGZkZ0Z1TUNjY1U5VGhRdmpCMmZKQU1VSGt1dWFqRjk5MmdLIn1dLCJjb250cm9sbGVyS2V5cyI6W3siaWQiOiJrZXlfZXo5YTg3NHRja3IzZHY5MzNkM2NrZG43ejZ6cmN0OCIsInR5cGUiOiJNdWx0aWtleSIsInB1YmxpY0tleU11bHRpYmFzZSI6Ino2TWtmVWQ2NUpyQWhmZGdGdU1DY2NVOVRoUXZqQjJmSkFNVUhrdXVhakY5OTJnSyJ9XSwiY3JlYXRlZEF0IjoiMjAyNi0wMy0wN1QwMDowMTowMC4wMDBaIn0.7fqvWGEVYW9atA1uqpp7lIUOWp4dATLpLjOmFWzJN-8gTL-QnXDCeyGcBu5AXhHzO52fauwUavh1KrB6wBYuCw",
-    "eyJhbGciOiJFZERTQSIsInR5cCI6ImRpZDpkZm9zOmlkZW50aXR5LW9wIiwia2lkIjoiZGlkOmRmb3M6Y25ubmZ0OWY4YTJybjkzOGQ2bmt6MzhyODQ3djJrciNrZXlfZXo5YTg3NHRja3IzZHY5MzNkM2NrZG43ejZ6cmN0OCIsImNpZCI6ImJhZnlyZWljbDNhMnQ2dmh6NXZndnM1b2pkdzV3Y3dnb3ozdGF4cXF3ZXhwYnBsdG0yZ2gzcTQyenlpIn0.eyJ2ZXJzaW9uIjoxLCJ0eXBlIjoiZGVsZXRlIiwicHJldmlvdXNPcGVyYXRpb25DSUQiOiJiYWZ5cmVpYmZ1aDYzdXYzM2kyaTVlb29lM2JvaXQycnV5amVodWJzcnllbXV1ejZtcnRsZWoyNnJlaSIsImNyZWF0ZWRBdCI6IjIwMjYtMDMtMDdUMDA6MDI6MDAuMDAwWiJ9.00Dy7qeK7I0hC3P1yvERLJINBLNiEV9LhG8BXdUMIGGLTsxuMcuhn3Yquq96SQa8mzl-BztzD5LMxBohYZxQAg",
-    "eyJhbGciOiJFZERTQSIsInR5cCI6ImRpZDpkZm9zOmlkZW50aXR5LW9wIiwia2lkIjoiZGlkOmRmb3M6Y25ubmZ0OWY4YTJybjkzOGQ2bmt6MzhyODQ3djJrciNrZXlfZXo5YTg3NHRja3IzZHY5MzNkM2NrZG43ejZ6cmN0OCIsImNpZCI6ImJhZnlyZWlleWF2dWU2dnh6dDYzdWxrcXB3ZXRmd3F2Znpka2VxNnQzcTNnd3JqbnFnaG1panJneWJhIn0.eyJ2ZXJzaW9uIjoxLCJ0eXBlIjoicmVzdG9yZSIsInByZXZpb3VzT3BlcmF0aW9uQ0lEIjoiYmFmeXJlaWNsM2EydDZ2aHo1dmd2czVvamR3NXdjd2dvejN0YXhxcXdleHBicGx0bTJnaDNxNDJ6eWkiLCJjcmVhdGVkQXQiOiIyMDI2LTAzLTA3VDAwOjAzOjAwLjAwMFoifQ.lVKZj34IGmyf-0Un7TELSPP3i57gWMe8j5d4d06gFnh8r4hpf5_1VHMUrwwkt7CFnWcd4Ui4CdeXPKS8jpIeAg"
+    "eyJhbGciOiJFZERTQSIsInR5cCI6ImRpZDpkZm9zOmlkZW50aXR5LW9wIiwia2lkIjoiZGlkOmRmb3M6Y25ubmZ0OWY4YTJybjkzOGQ2bmt6MzhyODQ3djJrciNrZXlfcjlldjM0ZnZjMjN6OTk5dmVhYWZ0ODNubjI5enZoZSIsImNpZCI6ImJhZnlyZWlhcmM3bXY2ZnZoYW9lMm1tazR1anBza2dxcGVzdjY2cHpkNWp1cWxnNWJ6bXJpZGlra3F5In0.eyJ2ZXJzaW9uIjoxLCJ0eXBlIjoidXBkYXRlIiwicHJldmlvdXNPcGVyYXRpb25DSUQiOiJiYWZ5cmVpY29naHZqem52bGl1bG94eG1iZjU0dHB6cXdhaG5xcGlsazduY3hlcGppbmVkcGtnYTNuZSIsImF1dGhLZXlzIjpbeyJpZCI6ImtleV9lejlhODc0dGNrcjNkdjkzM2QzY2tkbjd6NnpyY3Q4IiwidHlwZSI6Ik11bHRpa2V5IiwicHVibGljS2V5TXVsdGliYXNlIjoiejZNa2ZVZDY1SnJBaGZkZ0Z1TUNjY1U5VGhRdmpCMmZKQU1VSGt1dWFqRjk5MmdLIn1dLCJhc3NlcnRLZXlzIjpbeyJpZCI6ImtleV9lejlhODc0dGNrcjNkdjkzM2QzY2tkbjd6NnpyY3Q4IiwidHlwZSI6Ik11bHRpa2V5IiwicHVibGljS2V5TXVsdGliYXNlIjoiejZNa2ZVZDY1SnJBaGZkZ0Z1TUNjY1U5VGhRdmpCMmZKQU1VSGt1dWFqRjk5MmdLIn1dLCJjb250cm9sbGVyS2V5cyI6W3siaWQiOiJrZXlfZXo5YTg3NHRja3IzZHY5MzNkM2NrZG43ejZ6cmN0OCIsInR5cGUiOiJNdWx0aWtleSIsInB1YmxpY0tleU11bHRpYmFzZSI6Ino2TWtmVWQ2NUpyQWhmZGdGdU1DY2NVOVRoUXZqQjJmSkFNVUhrdXVhakY5OTJnSyJ9XSwiY3JlYXRlZEF0IjoiMjAyNi0wMy0wN1QwMDowMTowMC4wMDBaIiwia2V5UHJvb2ZzIjpbImV5SmhiR2NpT2lKRlpFUlRRU0lzSW5SNWNDSTZJbVJwWkRwa1ptOXpPbXRsZVMxaFpHUWlmUS5leUp1YjI1alpTSTZJbVJtYjNNdGNISnZkRzlqYjJ3dGNtVm1aWEpsYm1ObExXNXZibU5sTFRFaUxDSmhkV1JwWlc1alpTSTZJbXRsZVhNdVpHWnZjeTVqYjIwaUxDSmthV1FpT2lKa2FXUTZaR1p2Y3pwamJtNXVablE1WmpoaE1uSnVPVE00WkRadWEzb3pPSEk0TkRkMk1tdHlJaXdpY205c1pWTmxkQ0k2SW1GMWRHZ3NZWE56WlhKMExHTnZiblJ5YjJ4c1pYSWlMQ0p3Y21WMlEwbEVJam9pWW1GbWVYSmxhV052WjJoMmFucHVkbXhwZFd4dmVIaHRZbVkxTkhSd2VuRjNZV2h1Y1hCcGJHczNibU40WlhCcWFXNWxaSEJyWjJFemJtVWlMQ0p3ZFdKc2FXTkxaWGxOZFd4MGFXSmhjMlVpT2lKNk5rMXJabFZrTmpWS2NrRm9abVJuUm5WTlEyTmpWVGxVYUZGMmFrSXlaa3BCVFZWSWEzVjFZV3BHT1RreVowc2lMQ0owYVcxbGMzUmhiWEFpT2lJeU1ESTJMVEF6TFRBM1ZEQXdPakF3T2pNd0xqQXdNRm9pZlEuOG5nMTBIYmJzMkJGQ3NZb1NZTkhTMVQwMDIwLUhYbTRhRDEwUXJIbHB5c08xc3FteTFVX2RqOXlFejBDSlNNQ1lOd2hUWk1iVGlhbmhKOENIMUx0QXciXX0.13or_X7zDOezkSFHdWBLwPcNyIaG3XlHAb9mHpgG8zVDldz0wGP0X8WiVIHPLQ-20ZsCOvsh8Y6BbgxdbIvMBA",
+    "eyJhbGciOiJFZERTQSIsInR5cCI6ImRpZDpkZm9zOmlkZW50aXR5LW9wIiwia2lkIjoiZGlkOmRmb3M6Y25ubmZ0OWY4YTJybjkzOGQ2bmt6MzhyODQ3djJrciNrZXlfZXo5YTg3NHRja3IzZHY5MzNkM2NrZG43ejZ6cmN0OCIsImNpZCI6ImJhZnlyZWlhaXk1bTRmaXludGRyeWlremZ3enlub2p3aWdsa3Fyd2llZnVsYjRkbDM2ZXFlZWZicHdtIn0.eyJ2ZXJzaW9uIjoxLCJ0eXBlIjoiZGVsZXRlIiwicHJldmlvdXNPcGVyYXRpb25DSUQiOiJiYWZ5cmVpYXJjN212NmZ2aGFvZTJtbWs0dWpwc2tncXBlc3Y2NnB6ZDVqdXFsZzViem1yaWRpa2txeSIsImNyZWF0ZWRBdCI6IjIwMjYtMDMtMDdUMDA6MDI6MDAuMDAwWiJ9.QIh-HRD-YEV84yg1X3Lwz-tXJEGPCLruTssWC6Igb5j_QG0aGPjJ6sAqFE1VM8KURYlmFkaLgYZV6O2831YBCA",
+    "eyJhbGciOiJFZERTQSIsInR5cCI6ImRpZDpkZm9zOmlkZW50aXR5LW9wIiwia2lkIjoiZGlkOmRmb3M6Y25ubmZ0OWY4YTJybjkzOGQ2bmt6MzhyODQ3djJrciNrZXlfZXo5YTg3NHRja3IzZHY5MzNkM2NrZG43ejZ6cmN0OCIsImNpZCI6ImJhZnlyZWljZnhwNjVtM2pzNHRlbGxiM29wdHduNTRnaW5xdjdwcDRsZGlmY251dnJ5N2dsdW5oN2FxIn0.eyJ2ZXJzaW9uIjoxLCJ0eXBlIjoicmVzdG9yZSIsInByZXZpb3VzT3BlcmF0aW9uQ0lEIjoiYmFmeXJlaWFpeTVtNGZpeW50ZHJ5aWt6Znd6eW5vandpZ2xrcXJ3aWVmdWxiNGRsMzZlcWVlZmJwd20iLCJjcmVhdGVkQXQiOiIyMDI2LTAzLTA3VDAwOjAzOjAwLjAwMFoifQ.JiIAXKZqIZnDpZUrbd4S7F7tEoBEjEeIKcGg3WReYXAFJii960wpZLFfyrc3yAKONsMw9hT5aFRivos4kthuBA"
   ],
   "expected": {
     "did": "did:dfos:cnnnft9f8a2rn938d6nkz38r847v2kr",

package/examples/identity-rotation.json

@@ -3,7 +3,7 @@
   "type": "identity",
   "chain": [
     "eyJhbGciOiJFZERTQSIsInR5cCI6ImRpZDpkZm9zOmlkZW50aXR5LW9wIiwia2lkIjoia2V5X3I5ZXYzNGZ2YzIzejk5OXZlYWFmdDgzbm4yOXp2aGUiLCJjaWQiOiJiYWZ5cmVpY29naHZqem52bGl1bG94eG1iZjU0dHB6cXdhaG5xcGlsazduY3hlcGppbmVkcGtnYTNuZSJ9.eyJ2ZXJzaW9uIjoxLCJ0eXBlIjoiY3JlYXRlIiwiYXV0aEtleXMiOlt7ImlkIjoia2V5X3I5ZXYzNGZ2YzIzejk5OXZlYWFmdDgzbm4yOXp2aGUiLCJ0eXBlIjoiTXVsdGlrZXkiLCJwdWJsaWNLZXlNdWx0aWJhc2UiOiJ6Nk1rcnpMTU53b0pTVjRQM1ljY1djYnRrOHZkOUx0Z01LbkxlYURMVXFMdUFTamIifV0sImFzc2VydEtleXMiOlt7ImlkIjoia2V5X3I5ZXYzNGZ2YzIzejk5OXZlYWFmdDgzbm4yOXp2aGUiLCJ0eXBlIjoiTXVsdGlrZXkiLCJwdWJsaWNLZXlNdWx0aWJhc2UiOiJ6Nk1rcnpMTU53b0pTVjRQM1ljY1djYnRrOHZkOUx0Z01LbkxlYURMVXFMdUFTamIifV0sImNvbnRyb2xsZXJLZXlzIjpbeyJpZCI6ImtleV9yOWV2MzRmdmMyM3o5OTl2ZWFhZnQ4M25uMjl6dmhlIiwidHlwZSI6Ik11bHRpa2V5IiwicHVibGljS2V5TXVsdGliYXNlIjoiejZNa3J6TE1Od29KU1Y0UDNZY2NXY2J0azh2ZDlMdGdNS25MZWFETFVxTHVBU2piIn1dLCJjcmVhdGVkQXQiOiIyMDI2LTAzLTA3VDAwOjAwOjAwLjAwMFoifQ.TeznHnzrtKOGTr0FzkDL2z-luMWnAbKXrmDbi-Exgw_xMPCnYwGHORMjw-BM28f0RoTirIAeD7d20W5RSuGuBg",
-    "eyJhbGciOiJFZERTQSIsInR5cCI6ImRpZDpkZm9zOmlkZW50aXR5LW9wIiwia2lkIjoiZGlkOmRmb3M6Y25ubmZ0OWY4YTJybjkzOGQ2bmt6MzhyODQ3djJrciNrZXlfcjlldjM0ZnZjMjN6OTk5dmVhYWZ0ODNubjI5enZoZSIsImNpZCI6ImJhZnlyZWliZnVoNjN1djMzaTJpNWVvb2UzYm9pdDJydXlqZWh1YnNyeWVtdXV6Nm1ydGxlajI2cmVpIn0.eyJ2ZXJzaW9uIjoxLCJ0eXBlIjoidXBkYXRlIiwicHJldmlvdXNPcGVyYXRpb25DSUQiOiJiYWZ5cmVpY29naHZqem52bGl1bG94eG1iZjU0dHB6cXdhaG5xcGlsazduY3hlcGppbmVkcGtnYTNuZSIsImF1dGhLZXlzIjpbeyJpZCI6ImtleV9lejlhODc0dGNrcjNkdjkzM2QzY2tkbjd6NnpyY3Q4IiwidHlwZSI6Ik11bHRpa2V5IiwicHVibGljS2V5TXVsdGliYXNlIjoiejZNa2ZVZDY1SnJBaGZkZ0Z1TUNjY1U5VGhRdmpCMmZKQU1VSGt1dWFqRjk5MmdLIn1dLCJhc3NlcnRLZXlzIjpbeyJpZCI6ImtleV9lejlhODc0dGNrcjNkdjkzM2QzY2tkbjd6NnpyY3Q4IiwidHlwZSI6Ik11bHRpa2V5IiwicHVibGljS2V5TXVsdGliYXNlIjoiejZNa2ZVZDY1SnJBaGZkZ0Z1TUNjY1U5VGhRdmpCMmZKQU1VSGt1dWFqRjk5MmdLIn1dLCJjb250cm9sbGVyS2V5cyI6W3siaWQiOiJrZXlfZXo5YTg3NHRja3IzZHY5MzNkM2NrZG43ejZ6cmN0OCIsInR5cGUiOiJNdWx0aWtleSIsInB1YmxpY0tleU11bHRpYmFzZSI6Ino2TWtmVWQ2NUpyQWhmZGdGdU1DY2NVOVRoUXZqQjJmSkFNVUhrdXVhakY5OTJnSyJ9XSwiY3JlYXRlZEF0IjoiMjAyNi0wMy0wN1QwMDowMTowMC4wMDBaIn0.7fqvWGEVYW9atA1uqpp7lIUOWp4dATLpLjOmFWzJN-8gTL-QnXDCeyGcBu5AXhHzO52fauwUavh1KrB6wBYuCw"
+    "eyJhbGciOiJFZERTQSIsInR5cCI6ImRpZDpkZm9zOmlkZW50aXR5LW9wIiwia2lkIjoiZGlkOmRmb3M6Y25ubmZ0OWY4YTJybjkzOGQ2bmt6MzhyODQ3djJrciNrZXlfcjlldjM0ZnZjMjN6OTk5dmVhYWZ0ODNubjI5enZoZSIsImNpZCI6ImJhZnlyZWlhcmM3bXY2ZnZoYW9lMm1tazR1anBza2dxcGVzdjY2cHpkNWp1cWxnNWJ6bXJpZGlra3F5In0.eyJ2ZXJzaW9uIjoxLCJ0eXBlIjoidXBkYXRlIiwicHJldmlvdXNPcGVyYXRpb25DSUQiOiJiYWZ5cmVpY29naHZqem52bGl1bG94eG1iZjU0dHB6cXdhaG5xcGlsazduY3hlcGppbmVkcGtnYTNuZSIsImF1dGhLZXlzIjpbeyJpZCI6ImtleV9lejlhODc0dGNrcjNkdjkzM2QzY2tkbjd6NnpyY3Q4IiwidHlwZSI6Ik11bHRpa2V5IiwicHVibGljS2V5TXVsdGliYXNlIjoiejZNa2ZVZDY1SnJBaGZkZ0Z1TUNjY1U5VGhRdmpCMmZKQU1VSGt1dWFqRjk5MmdLIn1dLCJhc3NlcnRLZXlzIjpbeyJpZCI6ImtleV9lejlhODc0dGNrcjNkdjkzM2QzY2tkbjd6NnpyY3Q4IiwidHlwZSI6Ik11bHRpa2V5IiwicHVibGljS2V5TXVsdGliYXNlIjoiejZNa2ZVZDY1SnJBaGZkZ0Z1TUNjY1U5VGhRdmpCMmZKQU1VSGt1dWFqRjk5MmdLIn1dLCJjb250cm9sbGVyS2V5cyI6W3siaWQiOiJrZXlfZXo5YTg3NHRja3IzZHY5MzNkM2NrZG43ejZ6cmN0OCIsInR5cGUiOiJNdWx0aWtleSIsInB1YmxpY0tleU11bHRpYmFzZSI6Ino2TWtmVWQ2NUpyQWhmZGdGdU1DY2NVOVRoUXZqQjJmSkFNVUhrdXVhakY5OTJnSyJ9XSwiY3JlYXRlZEF0IjoiMjAyNi0wMy0wN1QwMDowMTowMC4wMDBaIiwia2V5UHJvb2ZzIjpbImV5SmhiR2NpT2lKRlpFUlRRU0lzSW5SNWNDSTZJbVJwWkRwa1ptOXpPbXRsZVMxaFpHUWlmUS5leUp1YjI1alpTSTZJbVJtYjNNdGNISnZkRzlqYjJ3dGNtVm1aWEpsYm1ObExXNXZibU5sTFRFaUxDSmhkV1JwWlc1alpTSTZJbXRsZVhNdVpHWnZjeTVqYjIwaUxDSmthV1FpT2lKa2FXUTZaR1p2Y3pwamJtNXVablE1WmpoaE1uSnVPVE00WkRadWEzb3pPSEk0TkRkMk1tdHlJaXdpY205c1pWTmxkQ0k2SW1GMWRHZ3NZWE56WlhKMExHTnZiblJ5YjJ4c1pYSWlMQ0p3Y21WMlEwbEVJam9pWW1GbWVYSmxhV052WjJoMmFucHVkbXhwZFd4dmVIaHRZbVkxTkhSd2VuRjNZV2h1Y1hCcGJHczNibU40WlhCcWFXNWxaSEJyWjJFemJtVWlMQ0p3ZFdKc2FXTkxaWGxOZFd4MGFXSmhjMlVpT2lKNk5rMXJabFZrTmpWS2NrRm9abVJuUm5WTlEyTmpWVGxVYUZGMmFrSXlaa3BCVFZWSWEzVjFZV3BHT1RreVowc2lMQ0owYVcxbGMzUmhiWEFpT2lJeU1ESTJMVEF6TFRBM1ZEQXdPakF3T2pNd0xqQXdNRm9pZlEuOG5nMTBIYmJzMkJGQ3NZb1NZTkhTMVQwMDIwLUhYbTRhRDEwUXJIbHB5c08xc3FteTFVX2RqOXlFejBDSlNNQ1lOd2hUWk1iVGlhbmhKOENIMUx0QXciXX0.13or_X7zDOezkSFHdWBLwPcNyIaG3XlHAb9mHpgG8zVDldz0wGP0X8WiVIHPLQ-20ZsCOvsh8Y6BbgxdbIvMBA"
   ],
   "expected": {
     "did": "did:dfos:cnnnft9f8a2rn938d6nkz38r847v2kr",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metalabel/dfos-protocol",
-  "version": "0.44.0",
+  "version": "0.46.0",
   "type": "module",
   "description": "DFOS Protocol — Ed25519 signed chain primitives, services, credentials, and verification",
   "license": "MIT",
@@ -72,13 +72,14 @@
     "ajv-formats": "^3.0.1",
     "tsup": "^8.5.1",
     "tsx": "^4.22.4",
+    "typescript": "^5.9.3",
     "vitest": "^4.1.8",
     "zod": "^4.4.3"
   },
   "scripts": {
     "build": "tsup",
     "clean": "rm -rf dist",
-    "typecheck": "tsc --noEmit",
+    "typecheck": "node ../../node_modules/typescript7/bin/tsc --noEmit",
     "test": "vitest run",
     "generate-examples": "tsx scripts/generate-examples.ts"
   }