@midnight-ntwrk/credential-compact 0.1.0-rc2 → 0.2.0-rc1

package/dist/credentials/holder-bindings.compact

@@ -1,30 +1,20 @@
-// Holder-binding and holder-witness primitives.
-// This file groups the reusable binding checks for explicit DID, Jubjub,
-// offchain DID, secret-holder, and blinded-secret-holder profiles.
-// =====================
-// Explicit and Jubjub-backed holder bindings
-// =====================
+// Explicit holder-binding primitives.
 export pure circuit assertValidExplicitHolderBinding(
   binding: ExplicitHolderBinding
 ): [] {
-  assert(
-    binding.holderVerificationMethodRef.didContractAddress.bytes != pad(32, ""),
-    "Explicit holder binding DID contract address must be set"
-  );
-  assert(
-    binding.holderVerificationMethodRef.methodId != pad(32, ""),
-    "Explicit holder binding method reference must be set"
-  );
+  assertValidVerificationMethodRef(binding.holderVerificationMethodRef);
 }
 
 export pure circuit assertMatchingExplicitHolderBindings(
   credentialBinding: ExplicitHolderBinding,
   presentationBinding: ExplicitHolderBinding
 ): [] {
+  assertValidExplicitHolderBinding(credentialBinding);
+  assertValidExplicitHolderBinding(presentationBinding);
   assert(
-    presentationBinding.holderVerificationMethodRef.didContractAddress
-      == credentialBinding.holderVerificationMethodRef.didContractAddress,
-    "Presentation holder contract does not match credential holder binding"
+    presentationBinding.holderVerificationMethodRef.controllerAddress
+      == credentialBinding.holderVerificationMethodRef.controllerAddress,
+    "Presentation holder controller does not match credential holder binding"
   );
   assert(
     presentationBinding.holderVerificationMethodRef.methodId
@@ -37,9 +27,11 @@ export pure circuit assertProofMatchesExplicitHolderBinding(
   binding: ExplicitHolderBinding,
   presentationProof: Proof
 ): [] {
+  assertValidExplicitHolderBinding(binding);
+  assertValidVerificationMethodRef(presentationProof.signerVerificationMethodRef);
   assert(
-    binding.holderVerificationMethodRef.didContractAddress
-      == presentationProof.signerVerificationMethodRef.didContractAddress,
+    binding.holderVerificationMethodRef.controllerAddress
+      == presentationProof.signerVerificationMethodRef.controllerAddress,
     "Presentation proof signer must match holder binding"
   );
   assert(
@@ -48,273 +40,3 @@ export pure circuit assertProofMatchesExplicitHolderBinding(
     "Presentation proof signer method reference must match holder binding"
   );
 }
-
-export pure circuit assertValidJubjubHolderBinding(
-  binding: JubjubHolderBinding
-): [] {
-  // This is only a sentinel check that the binding is populated.
-  // The helper remains useful for the legacy compatibility profile and as a
-  // building block inside richer DID-shaped bindings.
-  // Callers still need assertValidPresentationContextProof(...) or an
-  // equivalent proof verification path to establish proof-of-possession.
-  assert(
-    jubjubPointX(binding.holderPublicKey) != 0 as Field ||
-      jubjubPointY(binding.holderPublicKey) != 0 as Field,
-    "Jubjub holder binding public key must be set"
-  );
-}
-
-export pure circuit assertMatchingJubjubHolderBindings(
-  credentialBinding: JubjubHolderBinding,
-  presentationBinding: JubjubHolderBinding
-): [] {
-  assert(
-    jubjubPointX(presentationBinding.holderPublicKey)
-      == jubjubPointX(credentialBinding.holderPublicKey) &&
-      jubjubPointY(presentationBinding.holderPublicKey)
-        == jubjubPointY(credentialBinding.holderPublicKey),
-    "Presentation Jubjub holder key does not match the credential holder binding"
-  );
-}
-
-export pure circuit assertProofMatchesJubjubHolderBinding(
-  binding: JubjubHolderBinding,
-  presentationProof: Proof
-): [] {
-  assert(
-    jubjubPointX(binding.holderPublicKey)
-      == jubjubPointX(presentationProof.publicKey) &&
-      jubjubPointY(binding.holderPublicKey)
-        == jubjubPointY(presentationProof.publicKey),
-    "Presentation proof public key must match the Jubjub holder binding"
-  );
-}
-
-export pure circuit assertValidOffchainMidnightHolderBinding(
-  binding: OffchainMidnightHolderBinding
-): [] {
-  // This validates presence and consistency only for the preferred lightweight
-  // DID-shaped offchain profile.
-  // It does not prove that holderPublicKey is the verification method
-  // published under holderMethodId in the referenced offchain DID state.
-  assert(
-    binding.holderDidStateHash != pad(32, ""),
-    "Offchain Midnight holder state hash must be set"
-  );
-  assert(
-    binding.holderMethodId != pad(32, ""),
-    "Offchain Midnight holder method id must be set"
-  );
-  const jubjubBinding: JubjubHolderBinding = JubjubHolderBinding {
-    holderPublicKey: binding.holderPublicKey
-  };
-  assertValidJubjubHolderBinding(jubjubBinding);
-}
-
-export pure circuit assertMatchingOffchainMidnightHolderBindings(
-  credentialBinding: OffchainMidnightHolderBinding,
-  presentationBinding: OffchainMidnightHolderBinding
-): [] {
-  assert(
-    presentationBinding.holderDidStateHash
-      == credentialBinding.holderDidStateHash,
-    "Offchain Midnight holder state hash does not match the credential holder binding"
-  );
-  assert(
-    presentationBinding.holderMethodId
-      == credentialBinding.holderMethodId,
-    "Offchain Midnight holder method id does not match the credential holder binding"
-  );
-  const credentialJubjubBinding: JubjubHolderBinding = JubjubHolderBinding {
-    holderPublicKey: credentialBinding.holderPublicKey
-  };
-  const presentationJubjubBinding: JubjubHolderBinding = JubjubHolderBinding {
-    holderPublicKey: presentationBinding.holderPublicKey
-  };
-  assertMatchingJubjubHolderBindings(
-    credentialJubjubBinding,
-    presentationJubjubBinding
-  );
-}
-
-export pure circuit assertProofMatchesOffchainMidnightHolderBinding(
-  binding: OffchainMidnightHolderBinding,
-  presentationProof: Proof
-): [] {
-  const jubjubBinding: JubjubHolderBinding = JubjubHolderBinding {
-    holderPublicKey: binding.holderPublicKey
-  };
-  assertProofMatchesJubjubHolderBinding(jubjubBinding, presentationProof);
-}
-
-// =====================
-// Secret-holder bindings and derived pseudonyms
-// =====================
-export pure circuit noSecretHolderChallengeResponse(): Bytes<32> {
-  return pad(32, "midnight:vc:no-holder-response");
-}
-
-export pure circuit secretHolderBindingCommitment(
-  holderSecret: Bytes<32>,
-  opening: Bytes<32>
-): Bytes<32> {
-  return persistentCommit<Bytes<32>>(holderSecret, opening);
-}
-
-export pure circuit secretHolderBindingChallengeResponse(
-  holderSecret: Bytes<32>,
-  verifierChallengeHash: Bytes<32>
-): Bytes<32> {
-  return persistentHash<Vector<3, Bytes<32>>>([
-    pad(32, "midnight:vc:holder-chall"),
-    holderSecret,
-    verifierChallengeHash
-  ]);
-}
-
-export pure circuit verifierScopedPseudonym(
-  holderSecret: Bytes<32>,
-  verifierDomainHash: Bytes<32>
-): Bytes<32> {
-  return persistentHash<Vector<3, Bytes<32>>>([
-    pad(32, "midnight:vc:holder-pseudonym"),
-    holderSecret,
-    verifierDomainHash
-  ]);
-}
-
-export pure circuit assertVerifierScopedPseudonym(
-  pseudonym: Bytes<32>,
-  holderSecret: Bytes<32>,
-  verifierDomainHash: Bytes<32>
-): [] {
-  assert(
-    pseudonym == verifierScopedPseudonym(holderSecret, verifierDomainHash),
-    "Verifier-scoped pseudonym does not match the holder secret and verifier domain"
-  );
-}
-
-export pure circuit blindedSecretHolderCommitment(
-  holderSecretCommitment: Bytes<32>,
-  issuerNonce: Bytes<32>,
-  blindingFactor: Bytes<32>
-): Bytes<32> {
-  // NOTE: This remains a hash-based compatibility commitment today. The
-  // breaking `persistentCommit` migration is tracked separately and should not
-  // be rolled in silently with source-style or purity cleanups.
-  return persistentHash<Vector<4, Bytes<32>>>([
-    pad(32, "midnight:vc:blind-holder"),
-    holderSecretCommitment,
-    issuerNonce,
-    blindingFactor
-  ]);
-}
-
-export pure circuit assertValidSecretHolderCredentialBinding(
-  binding: SecretHolderBinding
-): [] {
-  assert(
-    binding.requestChallengeResponse == noSecretHolderChallengeResponse(),
-    "Credential secret holder binding must not embed a request challenge response"
-  );
-}
-
-export pure circuit assertValidSecretHolderPresentationBinding(
-  binding: SecretHolderBinding
-): [] {
-  assert(
-    binding.requestChallengeResponse != noSecretHolderChallengeResponse(),
-    "Presentation secret holder binding must include a request challenge response"
-  );
-}
-
-export pure circuit assertMatchingSecretHolderBindings(
-  credentialBinding: SecretHolderBinding,
-  presentationBinding: SecretHolderBinding
-): [] {
-  assert(
-    credentialBinding.holderSecretCommitment == presentationBinding.holderSecretCommitment,
-    "Presentation holder secret commitment does not match the credential holder binding"
-  );
-}
-
-export pure circuit assertValidBlindedSecretHolderCredentialBinding(
-  binding: BlindedSecretHolderBinding
-): [] {
-  assert(
-    binding.requestChallengeResponse == noSecretHolderChallengeResponse(),
-    "Credential blinded holder binding must not embed a request challenge response"
-  );
-}
-
-export pure circuit assertValidBlindedSecretHolderPresentationBinding(
-  binding: BlindedSecretHolderBinding
-): [] {
-  assert(
-    binding.requestChallengeResponse != noSecretHolderChallengeResponse(),
-    "Presentation blinded holder binding must include a request challenge response"
-  );
-}
-
-export pure circuit assertMatchingBlindedSecretHolderBindings(
-  credentialBinding: BlindedSecretHolderBinding,
-  presentationBinding: BlindedSecretHolderBinding
-): [] {
-  assert(
-    credentialBinding.blindedHolderSecretCommitment
-      == presentationBinding.blindedHolderSecretCommitment,
-    "Presentation blinded holder commitment does not match the credential holder binding"
-  );
-  assert(
-    credentialBinding.issuerNonce == presentationBinding.issuerNonce,
-    "Presentation issuer nonce does not match the credential holder binding"
-  );
-}
-
-// =====================
-// Witness validation and recomputation helpers
-// =====================
-// NOTE: these helpers validate caller-supplied witness material passed as
-// ordinary parameters. They do not perform Compact `witness` reads themselves.
-export pure circuit assertSecretHolderBindingWitness(
-  binding: SecretHolderBinding,
-  verifierChallengeHash: Bytes<32>,
-  holderSecret: Bytes<32>,
-  opening: Bytes<32>
-): [] {
-  assert(
-    secretHolderBindingCommitment(holderSecret, opening) == binding.holderSecretCommitment,
-    "Holder secret witness does not match the holder-binding commitment"
-  );
-  assert(
-    secretHolderBindingChallengeResponse(holderSecret, verifierChallengeHash)
-      == binding.requestChallengeResponse,
-    "Holder secret challenge response does not match the verifier challenge"
-  );
-}
-
-export pure circuit assertBlindedSecretHolderBindingWitness(
-  binding: BlindedSecretHolderBinding,
-  verifierChallengeHash: Bytes<32>,
-  holderSecret: Bytes<32>,
-  opening: Bytes<32>,
-  blindingFactor: Bytes<32>
-): [] {
-  const holderCommitment: Bytes<32> = secretHolderBindingCommitment(
-    holderSecret,
-    opening
-  );
-  assert(
-    blindedSecretHolderCommitment(
-      holderCommitment,
-      binding.issuerNonce,
-      blindingFactor
-    ) == binding.blindedHolderSecretCommitment,
-    "Blinded holder commitment does not match the hidden holder secret witness"
-  );
-  assert(
-    secretHolderBindingChallengeResponse(holderSecret, verifierChallengeHash)
-      == binding.requestChallengeResponse,
-    "Blinded holder challenge response does not match the verifier challenge"
-  );
-}

package/dist/credentials/proofs.compact

@@ -1,11 +1,43 @@
 // Context-tagged proof primitives.
 // This file owns signature verification plus the shared proof payload/challenge
 // derivation rules for generic issuance and presentation flows.
+pure circuit assertMatchingJubjubPoints(
+  expected: JubjubPoint,
+  actual: JubjubPoint
+): [] {
+  assert(
+    jubjubPointX(expected) == jubjubPointX(actual)
+      && jubjubPointY(expected) == jubjubPointY(actual),
+    "Jubjub points do not match"
+  );
+}
+
+pure circuit assertUsableJubjubPoint(point: JubjubPoint): [] {
+  assert(
+    jubjubPointX(point) != 0 || jubjubPointY(point) != 1,
+    "Jubjub point must not be the identity point"
+  );
+
+  // (q + 1) / 8 followed by the cofactor projects onto the prime-order
+  // subgroup. Equality rejects a torsion component; ecMul constrains the input
+  // to the curve.
+  const subgroupProjection: JubjubPoint = ecMul(
+    ecMul(
+      point,
+      819310549611346726241370945440405716213240158234039660170669895299022906775 as Field
+    ),
+    8
+  );
+  assertMatchingJubjubPoints(point, subgroupProjection);
+}
+
 export pure circuit verifySignature(
   pk: JubjubPoint,
   signature: Signature,
   challenge: Field
 ): Boolean {
+  assertUsableJubjubPoint(pk);
+  assertUsableJubjubPoint(signature.r);
   const leftSide: JubjubPoint = ecMulGenerator(signature.s);
   const cPk: JubjubPoint = ecMul(pk, challenge);
   const rightSide: JubjubPoint = ecAdd(signature.r, cPk);
@@ -29,6 +61,14 @@ export pure circuit presentationContextTag(): Bytes<32> {
   return pad(32, "midnight:vc:presentation");
 }
 
+export pure circuit signerAuthorizationContextTag(): Bytes<32> {
+  return pad(32, "midnight:vc:signer-auth:v1");
+}
+
+export pure circuit verifierRequestContextTag(): Bytes<32> {
+  return pad(32, "midnight:vc:verifier-req:v1");
+}
+
 // =====================
 // Internal payload and challenge derivation
 // =====================
@@ -63,6 +103,7 @@ pure circuit assertValidProofForContext(
   contextTag: Bytes<32>,
   proof: Proof
 ): [] {
+  assertValidVerificationMethodRef(proof.signerVerificationMethodRef);
   assert(
     verifySignature(
       proof.publicKey,
@@ -101,6 +142,28 @@ export pure circuit presentationProofChallenge(
   return proofChallengeForContext(bodyRoot, presentationContextTag(), proof);
 }
 
+export pure circuit signerAuthorizationProofChallenge(
+  bodyRoot: Bytes<32>,
+  proof: Proof
+): Field {
+  return proofChallengeForContext(
+    bodyRoot,
+    signerAuthorizationContextTag(),
+    proof
+  );
+}
+
+export pure circuit verifierRequestProofChallenge(
+  requestScopeCommitment: Bytes<32>,
+  proof: Proof
+): Field {
+  return proofChallengeForContext(
+    requestScopeCommitment,
+    verifierRequestContextTag(),
+    proof
+  );
+}
+
 // =====================
 // Public context-specific proof entrypoints
 // =====================
@@ -120,3 +183,25 @@ export pure circuit assertValidPresentationContextProof(
 ): [] {
   assertValidProofForContext(bodyRoot, presentationContextTag(), proof);
 }
+
+export pure circuit assertValidSignerAuthorizationContextProof(
+  bodyRoot: Bytes<32>,
+  proof: Proof
+): [] {
+  assertValidProofForContext(
+    bodyRoot,
+    signerAuthorizationContextTag(),
+    proof
+  );
+}
+
+export pure circuit assertValidVerifierRequestContextProof(
+  requestScopeCommitment: Bytes<32>,
+  proof: Proof
+): [] {
+  assertValidProofForContext(
+    requestScopeCommitment,
+    verifierRequestContextTag(),
+    proof
+  );
+}

package/dist/credentials/relations.compact

@@ -20,13 +20,14 @@ module CredentialPresentationRelations<
   ): [] {
     // Holder-binding equality is intentionally left to the family layer because
     // different holder-binding profiles require different witness semantics.
+    assertMatchingSchemaRefs(credential.schema, presentation.schema);
     assert(
       presentation.credentialClaimRoot == credential.claimRoot,
       "Presentation must reference the credential claim root"
     );
     assert(
-      presentation.issuerVerificationMethodRef.didContractAddress == credential.issuerVerificationMethodRef.didContractAddress,
-      "Presentation issuer contract does not match credential issuer"
+      presentation.issuerVerificationMethodRef.controllerAddress == credential.issuerVerificationMethodRef.controllerAddress,
+      "Presentation issuer controller does not match credential issuer"
     );
     assert(
       presentation.issuerVerificationMethodRef.methodId == credential.issuerVerificationMethodRef.methodId,

package/dist/credentials/signer-authorization.compact

@@ -0,0 +1,246 @@
+// Source-neutral signer authorization primitives.
+// Applications may install descriptors through local governance or verify a
+// domain-separated authority proof before materializing the same descriptor.
+
+export enum SignerRole {
+  issuer,
+  verifier
+}
+
+export enum AuthorizationState {
+  active,
+  suspended,
+  revoked
+}
+
+export enum VerificationRelationship {
+  assertionMethod,
+  authentication,
+  capabilityInvocation
+}
+
+export struct AuthorizedSignerDescriptor {
+  version: Uint<16>,
+  authorizationId: Bytes<32>,
+  decisionSequence: Uint<64>,
+  state: AuthorizationState,
+  role: SignerRole,
+  signerVerificationMethodRef: VerificationMethodRef,
+  signerPublicKey: JubjubPoint,
+  didStateVersion: Uint<64>,
+  verificationRelationship: VerificationRelationship,
+  scopeCommitment: Bytes<32>,
+  policyCommitment: Bytes<32>,
+}
+
+export struct SignerAuthorizationAuthority {
+  domainCommitment: Bytes<32>,
+  verificationMethodRef: VerificationMethodRef,
+  publicKey: JubjubPoint,
+}
+
+export pure circuit assertValidAuthorizedSignerDescriptor(
+  descriptor: AuthorizedSignerDescriptor
+): [] {
+  assert(descriptor.version == 1, "Signer authorization version mismatch");
+  assert(
+    descriptor.authorizationId != pad(32, ""),
+    "Signer authorization id must be set"
+  );
+  assert(
+    descriptor.decisionSequence > 0,
+    "Signer authorization decision sequence must be positive"
+  );
+  assertValidVerificationMethodRef(descriptor.signerVerificationMethodRef);
+  assertUsableJubjubPoint(descriptor.signerPublicKey);
+  assert(
+    descriptor.didStateVersion > 0,
+    "Signer authorization DID state version must be positive"
+  );
+  assert(
+    descriptor.scopeCommitment != pad(32, ""),
+    "Signer authorization scope commitment must be set"
+  );
+  assert(
+    descriptor.policyCommitment != pad(32, ""),
+    "Signer authorization policy commitment must be set"
+  );
+
+  if (descriptor.role == SignerRole.issuer) {
+    assert(
+      descriptor.verificationRelationship
+        == VerificationRelationship.assertionMethod,
+      "Issuer authorization requires assertionMethod"
+    );
+  } else {
+    assert(
+      descriptor.verificationRelationship
+          == VerificationRelationship.authentication
+        || descriptor.verificationRelationship
+          == VerificationRelationship.capabilityInvocation,
+      "Verifier authorization requires authentication or capabilityInvocation"
+    );
+  }
+}
+
+export pure circuit authorizedSignerDescriptorRoot(
+  descriptor: AuthorizedSignerDescriptor
+): Bytes<32> {
+  assertValidAuthorizedSignerDescriptor(descriptor);
+  return authorizedSignerDescriptorHash(descriptor);
+}
+
+pure circuit authorizedSignerDescriptorHash(
+  descriptor: AuthorizedSignerDescriptor
+): Bytes<32> {
+  return persistentHash<AuthorizedSignerDescriptor>(descriptor);
+}
+
+export pure circuit issuerScopeCommitment(schema: SchemaRef): Bytes<32> {
+  assertValidSchemaRef(schema);
+  return persistentHash<SchemaRef>(schema);
+}
+
+export pure circuit assertProofSignerMatchesAuthorization(
+  proof: Proof,
+  descriptor: AuthorizedSignerDescriptor
+): [] {
+  assertValidAuthorizedSignerDescriptor(descriptor);
+  assert(
+    descriptor.state == AuthorizationState.active,
+    "Signer authorization must be active"
+  );
+  assert(
+    proof.signerVerificationMethodRef.controllerAddress
+      == descriptor.signerVerificationMethodRef.controllerAddress,
+    "Proof signer controller does not match authorization"
+  );
+  assert(
+    proof.signerVerificationMethodRef.methodId
+      == descriptor.signerVerificationMethodRef.methodId,
+    "Proof signer method does not match authorization"
+  );
+  assertMatchingJubjubPoints(
+    descriptor.signerPublicKey,
+    proof.publicKey
+  );
+}
+
+export pure circuit assertAuthorizedIssuerDescriptor(
+  schema: SchemaRef,
+  proof: Proof,
+  descriptor: AuthorizedSignerDescriptor
+): [] {
+  assertProofSignerMatchesAuthorization(proof, descriptor);
+  assert(
+    descriptor.role == SignerRole.issuer,
+    "Signer authorization role must be issuer"
+  );
+  assert(
+    descriptor.scopeCommitment == issuerScopeCommitment(schema),
+    "Issuer authorization scope does not match schema"
+  );
+}
+
+export pure circuit assertAuthorizedVerifierProof(
+  requestScopeCommitment: Bytes<32>,
+  proof: Proof,
+  descriptor: AuthorizedSignerDescriptor
+): [] {
+  assert(
+    requestScopeCommitment != pad(32, ""),
+    "Verifier request scope commitment must be set"
+  );
+  assertProofSignerMatchesAuthorization(proof, descriptor);
+  assert(
+    descriptor.role == SignerRole.verifier,
+    "Signer authorization role must be verifier"
+  );
+  assert(
+    descriptor.scopeCommitment == requestScopeCommitment,
+    "Verifier authorization scope does not match request"
+  );
+  assertValidVerifierRequestContextProof(requestScopeCommitment, proof);
+}
+
+export pure circuit assertValidSignerAuthorizationAuthority(
+  authority: SignerAuthorizationAuthority
+): [] {
+  assert(
+    authority.domainCommitment != pad(32, ""),
+    "Signer authorization authority domain must be set"
+  );
+  assertValidVerificationMethodRef(authority.verificationMethodRef);
+  assertUsableJubjubPoint(authority.publicKey);
+}
+
+export pure circuit signerAuthorizationDecisionRoot(
+  descriptor: AuthorizedSignerDescriptor,
+  domainCommitment: Bytes<32>
+): Bytes<32> {
+  assertValidAuthorizedSignerDescriptor(descriptor);
+  assert(
+    domainCommitment != pad(32, ""),
+    "Signer authorization authority domain must be set"
+  );
+  return persistentHash<Vector<2, Bytes<32>>>([
+    domainCommitment,
+    authorizedSignerDescriptorHash(descriptor)
+  ]);
+}
+
+export pure circuit assertValidSignerAuthorizationProof(
+  descriptor: AuthorizedSignerDescriptor,
+  authorizationProof: Proof,
+  authority: SignerAuthorizationAuthority
+): [] {
+  assertValidAuthorizedSignerDescriptor(descriptor);
+  assertValidSignerAuthorizationAuthority(authority);
+  assert(
+    authorizationProof.createdAt == descriptor.decisionSequence,
+    "Authorization proof sequence does not match descriptor"
+  );
+  assert(
+    authorizationProof.signerVerificationMethodRef.controllerAddress
+      == authority.verificationMethodRef.controllerAddress,
+    "Authorization proof controller does not match authority"
+  );
+  assert(
+    authorizationProof.signerVerificationMethodRef.methodId
+      == authority.verificationMethodRef.methodId,
+    "Authorization proof method does not match authority"
+  );
+  assertMatchingJubjubPoints(
+    authority.publicKey,
+    authorizationProof.publicKey
+  );
+  assertValidSignerAuthorizationContextProof(
+    signerAuthorizationDecisionRoot(descriptor, authority.domainCommitment),
+    authorizationProof
+  );
+}
+
+export pure circuit assertValidSignerAuthorizationUpdate(
+  previous: AuthorizedSignerDescriptor,
+  next: AuthorizedSignerDescriptor
+): [] {
+  assertValidAuthorizedSignerDescriptor(previous);
+  assertValidAuthorizedSignerDescriptor(next);
+  assert(
+    previous.authorizationId == next.authorizationId,
+    "Signer authorization update id mismatch"
+  );
+  assert(
+    next.decisionSequence > previous.decisionSequence,
+    "Signer authorization update sequence must increase"
+  );
+  assert(
+    next.didStateVersion >= previous.didStateVersion,
+    "Signer authorization DID state version must not decrease"
+  );
+  assert(
+    previous.state != AuthorizationState.revoked
+      || next.state == AuthorizationState.revoked,
+    "Revoked signer authorization must remain revoked"
+  );
+}