@metalabel/dfos-protocol 0.43.0 → 0.45.0

package/dist/{chunk-4YBXPYEU.js → chunk-ZRA7FRBE.js}

@@ -5,6 +5,12 @@ import {
   verifyDFOSCredential,
   verifyDelegationChain
 } from "./chunk-D4IZXFPM.js";
+import {
+  KEY_ADD_JWS_TYP,
+  KEY_ROLES,
+  unsafeKeyProofSubject,
+  verifyChainKeyProof
+} from "./chunk-JVSC67DC.js";
 import {
   decodeMultikey
 } from "./chunk-IDVYITX7.js";
@@ -22,6 +28,7 @@ import {
 // src/chain/schemas.ts
 import { z } from "zod";
 var MAX_KEYS_PER_ROLE = 256;
+var MAX_KEY_PROOFS = 256;
 var MAX_RELATION = 64;
 var MAX_SERVICES_ENTRIES = 256;
 var MAX_SERVICES_PAYLOAD_SIZE = 32768;
@@ -90,7 +97,28 @@ var IdentityUpdate = z.looseObject({
   controllerKeys: z.array(MultikeyPublicKey).min(1, "update must have at least one controller key").max(MAX_KEYS_PER_ROLE),
   // Full-state: an update REPLACES the entire services set (omit to clear).
   services: ServicesArray.optional(),
-  createdAt: Iso8601
+  createdAt: Iso8601,
+  /**
+   * POSSESSION PROOFS FOR THE KEYS THIS OPERATION INTRODUCES — compact key-proof
+   * JWS strings (specs/KEY-PROOF.md), each signed by the key it speaks for.
+   *
+   * Optional, and optional in the CID-neutral sense: omitting it encodes
+   * identically to an operation that never had it (undefined strips under
+   * canonical CBOR), so the overwhelming majority of updates — the ones that
+   * merely replay keys already in effective state — carry nothing. Proofs are
+   * never replayed forward with the keys; full-state carriage applies to key
+   * ARRAYS, not to the evidence that admitted them.
+   *
+   * PRESENT ON `update` ONLY. A `create` needs none (its single genesis key is
+   * proved by signing genesis) and `delete`/`restore` introduce nothing, so an
+   * envelope on any of the three is a rejected operation, not an ignored member
+   * — see the carriage gate in identity-chain.ts.
+   *
+   * A MISSING OR BAD PROOF DOES NOT INVALIDATE THE OPERATION. It voids the
+   * key-role membership it would have admitted: the operation stands, the chain
+   * stands, and the key is simply absent from EFFECTIVE state for that role.
+   */
+  keyProofs: z.array(z.string()).max(MAX_KEY_PROOFS).optional()
 });
 var IdentityDelete = z.looseObject({
   version: z.literal(1),
@@ -110,6 +138,19 @@ var IdentityOperation = z.discriminatedUnion("type", [
   IdentityDelete,
   IdentityRestore
 ]);
+var DeclaredKeyState = z.strictObject({
+  authKeys: z.array(MultikeyPublicKey).max(MAX_KEYS_PER_ROLE),
+  assertKeys: z.array(MultikeyPublicKey).max(MAX_KEYS_PER_ROLE),
+  controllerKeys: z.array(MultikeyPublicKey).max(MAX_KEYS_PER_ROLE)
+});
+var VoidKeyMembership = z.strictObject({
+  /** The key as declared. */
+  key: MultikeyPublicKey,
+  /** The role it was declared into but is not effective for. */
+  role: z.enum(KEY_ROLES),
+  /** The CID of the operation whose declaration is currently unproved. */
+  operationCID: z.string()
+});
 var VerifiedIdentity = z.strictObject({
   did: z.string(),
   isDeleted: z.boolean(),
@@ -117,7 +158,35 @@ var VerifiedIdentity = z.strictObject({
   assertKeys: z.array(MultikeyPublicKey).max(MAX_KEYS_PER_ROLE),
   controllerKeys: z.array(MultikeyPublicKey).max(MAX_KEYS_PER_ROLE),
   /** Resolved discovery vocabulary — projection of the winning head's services */
-  services: ServicesArray
+  services: ServicesArray,
+  /** What the chain declares, void memberships included. */
+  declared: DeclaredKeyState.optional(),
+  /** Declared memberships no proof admitted. Empty on a fully-proved chain. */
+  voidKeys: z.array(VoidKeyMembership).optional(),
+  /**
+   * HAS-EVER-PROVED: the union of every effective key state this chain has held,
+   * across its whole history. Monotonic — a key that was proved into a role and
+   * later removed stays here forever, because the fact it names is that the
+   * holder once demonstrated possession, and that does not become untrue.
+   *
+   * TWO SURFACES NEED EXACTLY THIS, and both are wrong without it:
+   *
+   *  - THE `key=` REVERSE INDEX, which is the one-key-one-DID oracle. A holder
+   *    asks it before signing a key proof, and refuses when some chain already
+   *    proved the key — because proving one key into two chains publishes an
+   *    irreversible public link between them. A DECLARATION publishes no such
+   *    link: anyone can write anyone's public key into their own chain, so
+   *    indexing declarations would let a stranger burn a key they do not hold,
+   *    by writing it into a chain and making every future ceremony refuse it.
+   *  - HISTORICAL KEY RESOLUTION, which verifies long-lived artifacts across
+   *    rotations. A credential signed by a key that was proved and later rotated
+   *    out must still verify; one signed by a key no chain ever proved must not.
+   *
+   * Computed during the walk, where the fold already runs, so consumers stop
+   * re-deriving it from the raw log under a declared-state rule that quietly
+   * disagrees with this one.
+   */
+  provedKeys: DeclaredKeyState.optional()
 });
 var ContentCreate = z.looseObject({
   version: z.literal(1),
@@ -230,6 +299,99 @@ var anchorsByLabel = (services, label) => services.filter(
 );
 
 // src/chain/identity-chain.ts
+var ROLE_ARRAY = {
+  auth: "authKeys",
+  assert: "assertKeys",
+  controller: "controllerKeys"
+};
+var emptyKeyState = () => ({
+  authKeys: [],
+  assertKeys: [],
+  controllerKeys: []
+});
+var keyStateOf = (op) => ({
+  authKeys: op.authKeys,
+  assertKeys: op.assertKeys,
+  controllerKeys: op.controllerKeys
+});
+var fullyProved = (state) => ({
+  authKeys: [...state.authKeys],
+  assertKeys: [...state.assertKeys],
+  controllerKeys: [...state.controllerKeys]
+});
+var unionProved = (into, next) => {
+  const merged = emptyKeyState();
+  for (const role of KEY_ROLES) {
+    const seen = /* @__PURE__ */ new Map();
+    for (const key of [...into[ROLE_ARRAY[role]], ...next[ROLE_ARRAY[role]]]) {
+      if (!seen.has(key.id)) seen.set(key.id, key);
+    }
+    merged[ROLE_ARRAY[role]] = [...seen.values()];
+  }
+  return merged;
+};
+var foldEffectiveKeyState = (input) => {
+  const carried = (role, key) => input.priorEffective[ROLE_ARRAY[role]].some((prior) => prior.id === key.id);
+  const introduced = /* @__PURE__ */ new Map();
+  for (const role of KEY_ROLES) {
+    for (const key of input.declared[ROLE_ARRAY[role]]) {
+      if (carried(role, key)) continue;
+      const entry = introduced.get(key.publicKeyMultibase) ?? { key, roles: /* @__PURE__ */ new Set() };
+      entry.roles.add(role);
+      introduced.set(key.publicKeyMultibase, entry);
+    }
+  }
+  const proved = /* @__PURE__ */ new Map();
+  for (const jws of input.keyProofs) {
+    const subject = unsafeKeyProofSubject(jws);
+    if (subject === null) continue;
+    const candidate = introduced.get(subject);
+    if (candidate === void 0) continue;
+    for (const role of candidate.roles) {
+      try {
+        verifyChainKeyProof(jws, {
+          expectedTyp: KEY_ADD_JWS_TYP,
+          did: input.did,
+          prevCID: input.previousOperationCID,
+          publicKeyMultibase: candidate.key.publicKeyMultibase,
+          role
+        });
+      } catch {
+        continue;
+      }
+      const covered = proved.get(subject) ?? /* @__PURE__ */ new Set();
+      covered.add(role);
+      proved.set(subject, covered);
+    }
+  }
+  const effective = emptyKeyState();
+  const voidKeys = [];
+  for (const role of KEY_ROLES) {
+    for (const key of input.declared[ROLE_ARRAY[role]]) {
+      if (carried(role, key) || proved.get(key.publicKeyMultibase)?.has(role) === true) {
+        effective[ROLE_ARRAY[role]].push(key);
+      } else {
+        voidKeys.push({ key, role, operationCID: input.operationCID });
+      }
+    }
+  }
+  return { effective, voidKeys };
+};
+var assertSingleKeyGenesis = (op) => {
+  if (op.authKeys.length !== 1 || op.assertKeys.length !== 1 || op.controllerKeys.length !== 1) {
+    throw new Error("create must declare exactly one key in each of auth, assert and controller");
+  }
+  const [auth, assert, controller] = [op.authKeys[0], op.assertKeys[0], op.controllerKeys[0]];
+  const same = (a, b) => a.id === b.id && a.type === b.type && a.publicKeyMultibase === b.publicKeyMultibase;
+  if (!same(auth, assert) || !same(auth, controller)) {
+    throw new Error("create must declare the SAME key in auth, assert and controller");
+  }
+};
+var assertKeyProofCarriage = (op) => {
+  if (op.type !== "update" && "keyProofs" in op) {
+    throw new Error(`keyProofs is valid on update only, not on ${op.type}`);
+  }
+};
 var signIdentityOperation = async (input) => {
   const kid = input.identityDID ? `${input.identityDID}#${input.keyId}` : input.keyId;
   const encoded = await dagCborCanonicalEncode(input.operation);
@@ -248,9 +410,13 @@ var verifyIdentityChain = async (input) => {
     isDeleted: false,
     previousOperationCID: null,
     lastCreatedAt: null,
-    authKeys: [],
-    assertKeys: [],
-    controllerKeys: [],
+    /** What the chain SAYS — the arbiter of signer validity. */
+    declared: emptyKeyState(),
+    /** What possession PROVED — what consumers get. */
+    effective: emptyKeyState(),
+    /** Every membership possession has EVER proved. Monotonic. */
+    provedKeys: emptyKeyState(),
+    voidKeys: [],
     services: [],
     seenKeys: /* @__PURE__ */ new Map()
   };
@@ -278,13 +444,20 @@ var verifyIdentityChain = async (input) => {
     if (idx > 0 && op.type === "create") {
       throw new Error(`log[${idx}]: create can only be the first operation`);
     }
+    try {
+      assertKeyProofCarriage(op);
+    } catch (e) {
+      throw new Error(`log[${idx}]: ${e.message}`);
+    }
     if (op.type === "create") {
-      if (op.controllerKeys.length === 0) {
-        throw new Error(`log[${idx}]: create must have at least one controller key`);
+      try {
+        assertSingleKeyGenesis(op);
+      } catch (e) {
+        throw new Error(`log[${idx}]: ${e.message}`);
       }
-      state.authKeys = op.authKeys;
-      state.assertKeys = op.assertKeys;
-      state.controllerKeys = op.controllerKeys;
+      state.declared = keyStateOf(op);
+      state.effective = fullyProved(state.declared);
+      state.provedKeys = fullyProved(state.declared);
       state.services = op.services ?? [];
     }
     if (op.type !== "create") {
@@ -298,7 +471,11 @@ var verifyIdentityChain = async (input) => {
     }
     if (op.type === "create" || op.type === "update") {
       const incomingKeys = [...op.authKeys, ...op.assertKeys, ...op.controllerKeys];
-      const currentKeys = [...state.authKeys, ...state.assertKeys, ...state.controllerKeys];
+      const currentKeys = [
+        ...state.declared.authKeys,
+        ...state.declared.assertKeys,
+        ...state.declared.controllerKeys
+      ];
       for (const k of [...currentKeys, ...incomingKeys]) {
         const existing = state.seenKeys.get(k.id);
         if (!existing) {
@@ -348,7 +525,7 @@ var verifyIdentityChain = async (input) => {
         throw new Error(`log[${idx}]: non-genesis op kid must be DID URL, got bare key ID`);
       }
     }
-    const signingKey = state.controllerKeys.find((k) => k.id === signingKeyId);
+    const signingKey = state.declared.controllerKeys.find((k) => k.id === signingKeyId);
     if (!signingKey) {
       throw new Error(`log[${idx}]: kid references unknown key: ${signingKeyId}`);
     }
@@ -361,6 +538,7 @@ var verifyIdentityChain = async (input) => {
     if (state.did === void 0) {
       state.did = deriveChainIdentifier(encoded.cid.bytes, input.didPrefix);
     }
+    const did = state.did;
     if (idx > 0 && kid.includes("#")) {
       const didFromKid = kid.substring(0, kid.indexOf("#"));
       if (didFromKid !== state.did) {
@@ -372,15 +550,25 @@ var verifyIdentityChain = async (input) => {
     switch (op.type) {
       case "create":
         break;
-      case "update":
+      case "update": {
         if (op.controllerKeys.length === 0) {
           throw new Error(`log[${idx}]: update must have at least one controller key`);
         }
-        state.authKeys = op.authKeys;
-        state.assertKeys = op.assertKeys;
-        state.controllerKeys = op.controllerKeys;
+        const folded = foldEffectiveKeyState({
+          did,
+          declared: keyStateOf(op),
+          priorEffective: state.effective,
+          previousOperationCID: op.previousOperationCID,
+          operationCID,
+          keyProofs: op.keyProofs ?? []
+        });
+        state.declared = keyStateOf(op);
+        state.effective = folded.effective;
+        state.provedKeys = unionProved(state.provedKeys, folded.effective);
+        state.voidKeys = folded.voidKeys;
         state.services = op.services ?? [];
         break;
+      }
       case "delete":
         state.isDeleted = true;
         break;
@@ -393,14 +581,21 @@ var verifyIdentityChain = async (input) => {
   return {
     did: state.did,
     isDeleted: state.isDeleted,
-    authKeys: state.authKeys,
-    assertKeys: state.assertKeys,
-    controllerKeys: state.controllerKeys,
-    services: state.services
+    // EFFECTIVE state is what a consumer gets. A void key never resolves.
+    authKeys: state.effective.authKeys,
+    assertKeys: state.effective.assertKeys,
+    controllerKeys: state.effective.controllerKeys,
+    services: state.services,
+    declared: state.declared,
+    voidKeys: state.voidKeys,
+    provedKeys: state.provedKeys
   };
 };
 var verifyIdentityExtensionFromTrustedState = async (input) => {
   const { currentState, headCID, lastCreatedAt, newOp } = input;
+  const priorEffective = keyStateOf(currentState);
+  const priorDeclared = currentState.declared ?? priorEffective;
+  const priorProved = currentState.provedKeys ?? priorEffective;
   const decoded = decodeJwsUnsafe(newOp);
   if (!decoded) throw new Error("failed to decode JWS");
   const result = IdentityOperation.safeParse(decoded.payload);
@@ -409,6 +604,7 @@ var verifyIdentityExtensionFromTrustedState = async (input) => {
     throw new Error(messages);
   }
   const op = result.data;
+  assertKeyProofCarriage(op);
   if (currentState.isDeleted && op.type !== "restore") {
     throw new Error("cannot extend a deleted identity");
   }
@@ -444,7 +640,7 @@ var verifyIdentityExtensionFromTrustedState = async (input) => {
   if (kidDid !== currentState.did) {
     throw new Error("kid DID does not match identity DID");
   }
-  const signingKey = currentState.controllerKeys.find((k) => k.id === signingKeyId);
+  const signingKey = priorDeclared.controllerKeys.find((k) => k.id === signingKeyId);
   if (!signingKey) {
     throw new Error(`kid references unknown key: ${signingKeyId}`);
   }
@@ -465,15 +661,30 @@ var verifyIdentityExtensionFromTrustedState = async (input) => {
   }
   const newState = (() => {
     switch (op.type) {
-      case "update":
+      case "update": {
+        const declared = keyStateOf(op);
+        const folded = foldEffectiveKeyState({
+          did: currentState.did,
+          declared,
+          priorEffective,
+          previousOperationCID: op.previousOperationCID,
+          operationCID,
+          keyProofs: op.keyProofs ?? []
+        });
         return {
           did: currentState.did,
           isDeleted: false,
-          authKeys: op.authKeys,
-          assertKeys: op.assertKeys,
-          controllerKeys: op.controllerKeys,
-          services: op.services ?? []
+          authKeys: folded.effective.authKeys,
+          assertKeys: folded.effective.assertKeys,
+          controllerKeys: folded.effective.controllerKeys,
+          services: op.services ?? [],
+          declared,
+          voidKeys: folded.voidKeys,
+          provedKeys: unionProved(priorProved, folded.effective)
         };
+      }
+      // delete and restore introduce nothing, so both key states — and the void
+      // list — travel forward untouched.
       case "delete":
         return {
           did: currentState.did,
@@ -481,7 +692,10 @@ var verifyIdentityExtensionFromTrustedState = async (input) => {
           authKeys: currentState.authKeys,
           assertKeys: currentState.assertKeys,
           controllerKeys: currentState.controllerKeys,
-          services: currentState.services
+          services: currentState.services,
+          declared: priorDeclared,
+          voidKeys: currentState.voidKeys ?? [],
+          provedKeys: priorProved
         };
       case "restore":
         return {
@@ -490,7 +704,10 @@ var verifyIdentityExtensionFromTrustedState = async (input) => {
           authKeys: currentState.authKeys,
           assertKeys: currentState.assertKeys,
           controllerKeys: currentState.controllerKeys,
-          services: currentState.services
+          services: currentState.services,
+          declared: priorDeclared,
+          voidKeys: currentState.voidKeys ?? [],
+          provedKeys: priorProved
         };
     }
   })();
@@ -1339,6 +1556,7 @@ var assertCanonicalSignRequestPayload = (payloadTyp, payloadBytes, context) => {
 };
 
 export {
+  MAX_KEY_PROOFS,
   MAX_SERVICES_ENTRIES,
   MAX_SERVICES_PAYLOAD_SIZE,
   MAX_OPERATION_SIZE,
@@ -1350,6 +1568,8 @@ export {
   Iso8601,
   parseProtocolTimestampUnix,
   IdentityOperation,
+  DeclaredKeyState,
+  VoidKeyMembership,
   VerifiedIdentity,
   ContentOperation,
   MAX_ARTIFACT_PAYLOAD_SIZE,

package/dist/credentials/index.d.ts

@@ -1,4 +1,4 @@
-export { b as Attenuation, e as CredentialVerificationError, D as DFOSCredentialPayload, h as MAX_CREDENTIAL_SIZE, R as RevocationChecker, V as VerifiedDFOSCredential, t as VerifiedDelegationChain, v as createDFOSCredential, w as decodeDFOSCredentialUnsafe, x as isAttenuated, y as matchesResource, B as verifyDFOSCredential, E as verifyDelegationChain } from '../dfos-credential-X6uvPIth.js';
+export { b as Attenuation, e as CredentialVerificationError, D as DFOSCredentialPayload, i as MAX_CREDENTIAL_SIZE, R as RevocationChecker, V as VerifiedDFOSCredential, v as VerifiedDelegationChain, y as createDFOSCredential, z as decodeDFOSCredentialUnsafe, B as isAttenuated, E as matchesResource, G as verifyDFOSCredential, H as verifyDelegationChain } from '../dfos-credential-BtiYPqBT.js';
 import 'zod';
 
 /**

package/dist/{dfos-credential-X6uvPIth.d.ts → dfos-credential-BtiYPqBT.d.ts}

@@ -2,6 +2,15 @@ import { z } from 'zod';
 
 /** Function that signs a byte array and returns a signature */
 type Signer = (message: Uint8Array) => Promise<Uint8Array>;
+/**
+ * Max number of key-proof envelopes an update may carry — a cardinality ceiling
+ * matching MAX_KEYS_PER_ROLE, since an operation never needs more envelopes than
+ * it introduces keys. The operation-size cap is still the real byte arbiter; this
+ * bounds the walk's per-operation verification work so a single 64 KiB operation
+ * cannot ask a verifier for an unbounded number of signature checks.
+ * VALIDITY-determining: MUST match maxKeyProofs in the Go reference.
+ */
+declare const MAX_KEY_PROOFS = 256;
 /**
  * Max number of service entries in an identity's services state — a generous
  * cardinality ceiling on resolution fan-out. Individual entry fields are NOT
@@ -143,6 +152,7 @@ declare const IdentityOperation: z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodString;
     }, z.core.$catchall<z.ZodUnknown>>>>;
     createdAt: z.ZodISODateTime;
+    keyProofs: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$loose>, z.ZodObject<{
     version: z.ZodLiteral<1>;
     type: z.ZodLiteral<"delete">;
@@ -155,6 +165,66 @@ declare const IdentityOperation: z.ZodDiscriminatedUnion<[z.ZodObject<{
     createdAt: z.ZodISODateTime;
 }, z.core.$loose>], "type">;
 type IdentityOperation = z.infer<typeof IdentityOperation>;
+/**
+ * The key arrays exactly as the chain's operations DECLARE them, before any
+ * question of possession. Structural state: what the controller wrote.
+ */
+declare const DeclaredKeyState: z.ZodObject<{
+    authKeys: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"Multikey">;
+        publicKeyMultibase: z.ZodString;
+    }, z.core.$loose>>;
+    assertKeys: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"Multikey">;
+        publicKeyMultibase: z.ZodString;
+    }, z.core.$loose>>;
+    controllerKeys: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"Multikey">;
+        publicKeyMultibase: z.ZodString;
+    }, z.core.$loose>>;
+}, z.core.$strict>;
+type DeclaredKeyState = z.infer<typeof DeclaredKeyState>;
+/**
+ * ONE DECLARED-BUT-UNPROVED KEY-ROLE MEMBERSHIP. The chain says this key holds
+ * this role; no possession proof ever admitted it, so consumers do not see it.
+ *
+ * VOID IS NOT INVALID. The operation that declared it is valid, the chain is
+ * valid, and the membership is simply absent from effective state. Enumerating
+ * these loudly is the point: a controller who introduced a key without a proof
+ * has a chain that verifies and a key that does not resolve, and the only way
+ * they learn that is if tooling can see the list.
+ */
+declare const VoidKeyMembership: z.ZodObject<{
+    key: z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"Multikey">;
+        publicKeyMultibase: z.ZodString;
+    }, z.core.$loose>;
+    role: z.ZodEnum<{
+        auth: "auth";
+        assert: "assert";
+        controller: "controller";
+    }>;
+    operationCID: z.ZodString;
+}, z.core.$strict>;
+type VoidKeyMembership = z.infer<typeof VoidKeyMembership>;
+/**
+ * THE VERIFIED IDENTITY. `authKeys`/`assertKeys`/`controllerKeys` are EFFECTIVE
+ * state — the memberships a possession proof actually admitted — because
+ * effective state is what every consumer wants: a void key must never resolve,
+ * never index, and never enter a has-ever surface.
+ *
+ * `declared` and `voidKeys` carry the structural half alongside it, so the
+ * surfaces that genuinely need "what does the chain SAY" can ask. There is
+ * exactly one such surface in the protocol: SIGNER VALIDITY, which stays
+ * declared-state-based on purpose (see identity-chain.ts). Both are optional
+ * because a caller may hand a hand-built state to the extension verifier;
+ * absent `declared` is read as "the arrays are also the declared arrays", which
+ * is exactly true for any chain with no void memberships.
+ */
 declare const VerifiedIdentity: z.ZodObject<{
     did: z.ZodString;
     isDeleted: z.ZodBoolean;
@@ -177,6 +247,53 @@ declare const VerifiedIdentity: z.ZodObject<{
         id: z.ZodString;
         type: z.ZodString;
     }, z.core.$catchall<z.ZodUnknown>>>;
+    declared: z.ZodOptional<z.ZodObject<{
+        authKeys: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodLiteral<"Multikey">;
+            publicKeyMultibase: z.ZodString;
+        }, z.core.$loose>>;
+        assertKeys: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodLiteral<"Multikey">;
+            publicKeyMultibase: z.ZodString;
+        }, z.core.$loose>>;
+        controllerKeys: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodLiteral<"Multikey">;
+            publicKeyMultibase: z.ZodString;
+        }, z.core.$loose>>;
+    }, z.core.$strict>>;
+    voidKeys: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodLiteral<"Multikey">;
+            publicKeyMultibase: z.ZodString;
+        }, z.core.$loose>;
+        role: z.ZodEnum<{
+            auth: "auth";
+            assert: "assert";
+            controller: "controller";
+        }>;
+        operationCID: z.ZodString;
+    }, z.core.$strict>>>;
+    provedKeys: z.ZodOptional<z.ZodObject<{
+        authKeys: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodLiteral<"Multikey">;
+            publicKeyMultibase: z.ZodString;
+        }, z.core.$loose>>;
+        assertKeys: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodLiteral<"Multikey">;
+            publicKeyMultibase: z.ZodString;
+        }, z.core.$loose>>;
+        controllerKeys: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodLiteral<"Multikey">;
+            publicKeyMultibase: z.ZodString;
+        }, z.core.$loose>>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 type VerifiedIdentity = z.infer<typeof VerifiedIdentity>;
 declare const ContentOperation: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -522,4 +639,4 @@ declare class CredentialVerificationError extends Error {
     constructor(message: string);
 }
 
-export { ARTIFACT_CID_ANCHOR_RE as A, verifyDFOSCredential as B, CONTENT_ID_ANCHOR_RE as C, DFOSCredentialPayload as D, verifyDelegationChain as E, IdentityOperation as I, MAX_ARTIFACT_PAYLOAD_SIZE as M, type RevocationChecker as R, ServiceEntry as S, type VerifiedDFOSCredential as V, ArtifactPayload as a, Attenuation as b, ContentOperation as c, CountersignPayload as d, CredentialVerificationError as e, CreditClaimPayload as f, Iso8601 as g, MAX_CREDENTIAL_SIZE as h, MAX_CREDIT_CLAIM_SIZE as i, MAX_OPERATION_SIZE as j, MAX_SERVICES_ENTRIES as k, MAX_SERVICES_PAYLOAD_SIZE as l, MAX_SIGN_REQUEST_PAYLOAD_SIZE as m, MAX_SIGN_REQUEST_SIZE as n, MultikeyPublicKey as o, RevocationPayload as p, ServicesArray as q, SignRequestPayload as r, type Signer as s, type VerifiedDelegationChain as t, VerifiedIdentity as u, createDFOSCredential as v, decodeDFOSCredentialUnsafe as w, isAttenuated as x, matchesResource as y, parseProtocolTimestampUnix as z };
+export { ARTIFACT_CID_ANCHOR_RE as A, isAttenuated as B, CONTENT_ID_ANCHOR_RE as C, DFOSCredentialPayload as D, matchesResource as E, parseProtocolTimestampUnix as F, verifyDFOSCredential as G, verifyDelegationChain as H, IdentityOperation as I, MAX_ARTIFACT_PAYLOAD_SIZE as M, type RevocationChecker as R, ServiceEntry as S, type VerifiedDFOSCredential as V, ArtifactPayload as a, Attenuation as b, ContentOperation as c, CountersignPayload as d, CredentialVerificationError as e, CreditClaimPayload as f, DeclaredKeyState as g, Iso8601 as h, MAX_CREDENTIAL_SIZE as i, MAX_CREDIT_CLAIM_SIZE as j, MAX_KEY_PROOFS as k, MAX_OPERATION_SIZE as l, MAX_SERVICES_ENTRIES as m, MAX_SERVICES_PAYLOAD_SIZE as n, MAX_SIGN_REQUEST_PAYLOAD_SIZE as o, MAX_SIGN_REQUEST_SIZE as p, MultikeyPublicKey as q, RevocationPayload as r, ServicesArray as s, SignRequestPayload as t, type Signer as u, type VerifiedDelegationChain as v, VerifiedIdentity as w, VoidKeyMembership as x, createDFOSCredential as y, decodeDFOSCredentialUnsafe as z };

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 export { JwsHeader, JwsVerificationError, JwtClaims, JwtCreateOptions, JwtHeader, JwtVerificationError, JwtVerifyOptions, PrefixedID, assertJwsProfile, base64urlDecode, base64urlEncode, createJws, createJwt, createNewEd25519Keypair, dagCborCanonicalEncode, decodeJwsUnsafe, decodeJwtUnsafe, generateId, generateIdNoPrefix, importEd25519Keypair, isCanonicallyEqual, isValidEd25519Signature, isValidId, normalizedId, parseDagCborCID, sha256, signPayloadEd25519, verifyJws, verifyJwt } from './crypto/index.js';
-export { A as ARTIFACT_CID_ANCHOR_RE, a as ArtifactPayload, b as Attenuation, C as CONTENT_ID_ANCHOR_RE, c as ContentOperation, d as CountersignPayload, e as CredentialVerificationError, f as CreditClaimPayload, D as DFOSCredentialPayload, I as IdentityOperation, g as Iso8601, M as MAX_ARTIFACT_PAYLOAD_SIZE, h as MAX_CREDENTIAL_SIZE, i as MAX_CREDIT_CLAIM_SIZE, j as MAX_OPERATION_SIZE, k as MAX_SERVICES_ENTRIES, l as MAX_SERVICES_PAYLOAD_SIZE, m as MAX_SIGN_REQUEST_PAYLOAD_SIZE, n as MAX_SIGN_REQUEST_SIZE, o as MultikeyPublicKey, R as RevocationChecker, p as RevocationPayload, S as ServiceEntry, q as ServicesArray, r as SignRequestPayload, s as Signer, V as VerifiedDFOSCredential, t as VerifiedDelegationChain, u as VerifiedIdentity, v as createDFOSCredential, w as decodeDFOSCredentialUnsafe, x as isAttenuated, y as matchesResource, z as parseProtocolTimestampUnix, B as verifyDFOSCredential, E as verifyDelegationChain } from './dfos-credential-X6uvPIth.js';
+export { A as ARTIFACT_CID_ANCHOR_RE, a as ArtifactPayload, b as Attenuation, C as CONTENT_ID_ANCHOR_RE, c as ContentOperation, d as CountersignPayload, e as CredentialVerificationError, f as CreditClaimPayload, D as DFOSCredentialPayload, g as DeclaredKeyState, I as IdentityOperation, h as Iso8601, M as MAX_ARTIFACT_PAYLOAD_SIZE, i as MAX_CREDENTIAL_SIZE, j as MAX_CREDIT_CLAIM_SIZE, k as MAX_KEY_PROOFS, l as MAX_OPERATION_SIZE, m as MAX_SERVICES_ENTRIES, n as MAX_SERVICES_PAYLOAD_SIZE, o as MAX_SIGN_REQUEST_PAYLOAD_SIZE, p as MAX_SIGN_REQUEST_SIZE, q as MultikeyPublicKey, R as RevocationChecker, r as RevocationPayload, S as ServiceEntry, s as ServicesArray, t as SignRequestPayload, u as Signer, V as VerifiedDFOSCredential, v as VerifiedDelegationChain, w as VerifiedIdentity, x as VoidKeyMembership, y as createDFOSCredential, z as decodeDFOSCredentialUnsafe, B as isAttenuated, E as matchesResource, F as parseProtocolTimestampUnix, G as verifyDFOSCredential, H as verifyDelegationChain } from './dfos-credential-BtiYPqBT.js';
 export { AnchorKind, CreditClaimFailureReason, CreditClaimVerifyError, CreditEntry, CreditEntryState, ED25519_PRIV_MULTICODEC, ED25519_PUB_MULTICODEC, RECOGNIZED_SERVICE_TYPES, SignRequestFailureReason, SignRequestVerifyError, VerifiedArtifact, VerifiedContentChain, VerifiedCountersignature, VerifiedCreditClaim, VerifiedCreditEntry, VerifiedRevocation, VerifiedSignRequest, anchorsByLabel, assertCanonicalSignRequestPayload, assertServicesWithinCap, buildSignRequest, classifyAnchor, decodeMultikey, deriveChainIdentifier, deriveContentId, encodeEd25519Multikey, isRecognizedServiceType, relayEndpoints, signArtifact, signContentOperation, signCountersignature, signCreditClaim, signIdentityOperation, signRevocation, verifyArtifact, verifyContentChain, verifyContentExtensionFromTrustedState, verifyCountersignature, verifyCreditClaim, verifyCreditEntry, verifyIdentityChain, verifyIdentityExtensionFromTrustedState, verifyRevocation, verifySignRequest } from './chain/index.js';
 export { ApiRequestVerifyError, DEFAULT_PROOF_SKEW_SECONDS, DEFAULT_PROOF_WINDOW_SECONDS, DFOS_AUTH_SCHEME, EMPTY_BODY_SHA256, IDENTITY_PROOF_JWS_TYP, IdentityProofPayload, MAX_BODY_BYTES, MAX_PROOF_FRESHNESS_SPAN_SECONDS, MAX_REQUEST_PROOF_SIZE, ParsedProofPayload, ProofEnvelopeInput, ProofExtraMembers, ProofPresenterState, REQUEST_PROOF_JWS_TYP, RequestProofFailurePhase, RequestProofFailureReason, RequestProofPayload, ResolveProofPresenter, SignApiIdentityRequestInput, SignApiRequestInput, VerifiedProofEnvelope, apiIdentitySigningInput, apiRequestSigningInput, assertProofVerifierConfig, buildApiAuthHeaders, buildApiIdentityHeaders, canonicalExtraMembers, invalidProof, misconfiguredProof, parseDfosAuthorization, sha256BodyHash, signApiIdentityRequest, signApiRequest, unverifiableProof, verifyIdentityProofEnvelope, verifyRequestProofEnvelope } from './credentials/index.js';
-export { DEFAULT_KEY_PROOF_SKEW_SECONDS, KEY_ADD_JWS_TYP, KeyProofFailureReason, KeyProofPayload, KeyProofVerifyError, MAX_KEY_PROOF_SIZE, SignKeyProofInput, VerifiedKeyProof, VerifyKeyProofOptions, keyProofSigningInput, signKeyProof, verifyKeyProof } from './key-proof/index.js';
+export { DEFAULT_KEY_PROOF_SKEW_SECONDS, KEY_ADD_JWS_TYP, KEY_ROLES, KeyProofFailureReason, KeyProofPayload, KeyProofVerifyError, KeyRole, MAX_KEY_PROOF_SIZE, SignKeyProofInput, VerifiedKeyProof, VerifyChainKeyProofOptions, VerifyKeyProofOptions, isCanonicalRoleSet, keyProofSigningInput, keyWordFingerprint, parseRoleSet, roleSetCovers, serializeRoleSet, signKeyProof, unsafeKeyProofSubject, verifyChainKeyProof, verifyKeyProof } from './key-proof/index.js';
 export { FoldOperation, INDEX_V1_SCHEMA, IndexDelta, IndexDocument, IndexEntry, LwwDelta, OrderKey, byteCompare, compareHeadPreference, compareLinear, foldIndexV1, foldLwwMap, linearize } from './fold/index.js';
 import 'multiformats';
 import 'multiformats/cid';