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

package/dist/credentials/status-bindings.compact

@@ -8,19 +8,11 @@ export struct StatusRegistryRef {
 
 export struct NoStatusBinding {}
 
-export enum StatusType {
-  revocationRegistry
-}
-
 export struct RegistryBoundStatusBinding {
-  statusType: StatusType,
   registryRef: StatusRegistryRef,
   statusHandleCommitment: Bytes<32>,
 }
 
-// NOTE: `StatusType` is explicit even though the current repo only supports the
-// revocation-registry binding mode. Keeping it in the binding preserves an
-// extension seam without overloading registry ids or handle commitment shapes.
 export pure circuit assertValidStatusRegistryRef(
   registryRef: StatusRegistryRef
 ): [] {
@@ -31,20 +23,9 @@ export pure circuit assertValidStatusRegistryRef(
   assertValidVerificationMethodRef(registryRef.authorityVerificationMethodRef);
 }
 
-export pure circuit assertValidNoStatusBinding(
-  binding: NoStatusBinding
-): [] {
-  // NOTE: NoStatusBinding is intentionally empty; this validator stays as a
-  // symmetry point with the real binding variants.
-}
-
 export pure circuit assertValidRegistryBoundStatusBinding(
   binding: RegistryBoundStatusBinding
 ): [] {
-  assert(
-    binding.statusType == StatusType.revocationRegistry,
-    "Registry-bound status type must be revocationRegistry"
-  );
   assertValidStatusRegistryRef(binding.registryRef);
   assert(
     binding.statusHandleCommitment != pad(32, ""),

package/dist/credentials/types.compact

@@ -5,83 +5,43 @@ export struct SchemaRef {
   minorVersion: Uint<16>,
 }
 
-export struct SchemaCapabilities {
-  supportsSelectiveDisclosure: Boolean,
-  supportsPredicateProofs: Boolean,
-  supportsVerifierScopedPseudonym: Boolean,
-  supportsSameHolderProof: Boolean,
-}
-
-export struct SchemaFamilyResolutionHint {
-  hasResolverHint: Boolean,
-  resolverHint: Bytes<32>,
-}
-
-export struct SchemaDescriptor {
-  schema: SchemaRef,
-  capabilities: SchemaCapabilities,
-  familyResolutionHint: SchemaFamilyResolutionHint,
-}
-
-export pure circuit noSchemaFamilyResolverHint(): Bytes<32> {
-  return pad(32, "midnight:vc:schema:no-hint");
-}
-
 export pure circuit assertValidSchemaRef(schema: SchemaRef): [] {
   assert(schema.packageId != pad(32, ""), "Schema package id must be set");
   assert(schema.schemaId != pad(32, ""), "Schema id must be set");
   assert(schema.majorVersion > 0, "Schema major version must be positive");
 }
 
-export pure circuit assertValidSchemaCapabilities(
-  capabilities: SchemaCapabilities
+export pure circuit assertMatchingSchemaRefs(
+  expected: SchemaRef,
+  actual: SchemaRef
 ): [] {
-  // Boolean-only capabilities have no invalid values today. Keep this helper so
-  // future non-boolean capability fields get one validation entry point.
-}
-
-export pure circuit assertValidSchemaFamilyResolutionHint(
-  hint: SchemaFamilyResolutionHint
-): [] {
-  const noHint = noSchemaFamilyResolverHint();
-  if (hint.hasResolverHint) {
-    assert(hint.resolverHint != noHint, "Schema resolver hint must be set");
-    assert(
-      hint.resolverHint != pad(32, ""),
-      "Schema resolver hint must not be empty"
-    );
-  } else {
-    assert(
-      hint.resolverHint == noHint,
-      "Absent schema resolver hint must use the no-hint sentinel"
-    );
-  }
+  assertValidSchemaRef(expected);
+  assertValidSchemaRef(actual);
+  assert(
+    expected.packageId == actual.packageId
+      && expected.schemaId == actual.schemaId
+      && expected.majorVersion == actual.majorVersion
+      && expected.minorVersion == actual.minorVersion,
+    "Schema reference mismatch"
+  );
 }
 
-export pure circuit assertValidSchemaDescriptor(
-  descriptor: SchemaDescriptor
-): [] {
-  assertValidSchemaRef(descriptor.schema);
-  assertValidSchemaCapabilities(descriptor.capabilities);
-  assertValidSchemaFamilyResolutionHint(descriptor.familyResolutionHint);
+export struct VerificationMethodRef {
+  controllerAddress: ContractAddress,
+  methodId: Bytes<32>,
 }
 
-export pure circuit assertMatchingSchemaCapabilities(
-  expected: SchemaCapabilities,
-  actual: SchemaCapabilities
+export pure circuit assertValidVerificationMethodRef(
+  verificationMethodRef: VerificationMethodRef
 ): [] {
   assert(
-    expected.supportsSelectiveDisclosure == actual.supportsSelectiveDisclosure
-      && expected.supportsPredicateProofs == actual.supportsPredicateProofs
-      && expected.supportsVerifierScopedPseudonym == actual.supportsVerifierScopedPseudonym
-      && expected.supportsSameHolderProof == actual.supportsSameHolderProof,
-    "Schema capabilities mismatch"
+    verificationMethodRef.controllerAddress.bytes != pad(32, ""),
+    "Verification method controller address must be set"
+  );
+  assert(
+    verificationMethodRef.methodId != pad(32, ""),
+    "Verification method reference must be set"
   );
-}
-
-export struct VerificationMethodRef {
-  didContractAddress: ContractAddress,
-  methodId: Bytes<32>,
 }
 
 export struct NoPublicClaims {
@@ -99,36 +59,6 @@ export struct ExplicitHolderBinding {
   holderVerificationMethodRef: VerificationMethodRef,
 }
 
-export struct JubjubHolderBinding {
-  // Legacy compatibility/minimal holder binding.
-  // This binds the VC/VP to a specific Jubjub public key, but it is not the
-  // recommended public profile for new DID-shaped flows.
-  // Proof-of-possession still depends on validating the presentation Proof
-  // alongside this binding.
-  holderPublicKey: JubjubPoint,
-}
-
-export struct OffchainMidnightHolderBinding {
-  // Preferred lightweight DID-shaped binding for offchain/prototype flows.
-  // This adds DID-shaped metadata for prototype offchain Midnight DID flows.
-  // It does not by itself prove that holderPublicKey is the key published in
-  // the offchain DID state; callers still need the surrounding DID semantics.
-  holderDidStateHash: Bytes<32>,
-  holderMethodId: Bytes<32>,
-  holderPublicKey: JubjubPoint,
-}
-
-export struct SecretHolderBinding {
-  holderSecretCommitment: Bytes<32>,
-  requestChallengeResponse: Bytes<32>,
-}
-
-export struct BlindedSecretHolderBinding {
-  blindedHolderSecretCommitment: Bytes<32>,
-  issuerNonce: Bytes<32>,
-  requestChallengeResponse: Bytes<32>,
-}
-
 // Proof is kept separate from the VC/VP body on purpose.
 // The body is the semantic payload; the proof is the cryptographic artifact
 // over that payload plus interaction context.

package/dist/credentials/vc.compact

@@ -38,7 +38,7 @@ module VC<TPublicClaims, TClaimCommitments, THolderBinding, TStatusBinding> {
     proof: Proof
   ): [] {
     const bodyRoot: Bytes<32> = credentialBodyRoot(credential);
-    assertValidCredentialProofForBodyRoot(credential, proof, bodyRoot);
+    assertValidCredentialProofForCanonicalBodyRoot(credential, proof, bodyRoot);
   }
 
   export pure circuit assertValidCredentialProofForBodyRoot(
@@ -47,8 +47,20 @@ module VC<TPublicClaims, TClaimCommitments, THolderBinding, TStatusBinding> {
     bodyRoot: Bytes<32>
   ): [] {
     assert(
-      credential.issuerVerificationMethodRef.didContractAddress == proof.signerVerificationMethodRef.didContractAddress,
-      "Issuer proof contract address does not match issuer verification method"
+      bodyRoot == credentialBodyRoot(credential),
+      "Credential body root does not match credential"
+    );
+    assertValidCredentialProofForCanonicalBodyRoot(credential, proof, bodyRoot);
+  }
+
+  pure circuit assertValidCredentialProofForCanonicalBodyRoot(
+    credential: Credential,
+    proof: Proof,
+    bodyRoot: Bytes<32>
+  ): [] {
+    assert(
+      credential.issuerVerificationMethodRef.controllerAddress == proof.signerVerificationMethodRef.controllerAddress,
+      "Issuer proof controller address does not match issuer verification method"
     );
     assert(
       credential.issuerVerificationMethodRef.methodId == proof.signerVerificationMethodRef.methodId,
@@ -56,4 +68,13 @@ module VC<TPublicClaims, TClaimCommitments, THolderBinding, TStatusBinding> {
     );
     assertValidIssuanceContextProof(bodyRoot, proof);
   }
+
+  export pure circuit assertAuthorizedIssuerProof(
+    credential: Credential,
+    proof: Proof,
+    descriptor: AuthorizedSignerDescriptor
+  ): [] {
+    assertAuthorizedIssuerDescriptor(credential.schema, proof, descriptor);
+    assertValidCredentialProof(credential, proof);
+  }
 }

package/dist/credentials.compact

@@ -1,4 +1,3 @@
-// This file is part of midnightntwrk/midnight-did.
 // Copyright (C) 2026 Midnight Foundation
 // SPDX-License-Identifier: Apache-2.0
 // Licensed under the Apache License, Version 2.0 (the "License");

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./jubjub.js";
+export * from "./compact-value-codec.js";
 export * from "./managed/credentials/contract/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,yCAAyC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,yCAAyC,CAAC"}

package/dist/index.js

@@ -1,3 +1,3 @@
-export * from "./jubjub.js";
+export * from "./compact-value-codec.js";
 export * from "./managed/credentials/contract/index.js";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,yCAAyC,CAAC","sourcesContent":["export * from \"./jubjub.js\";\nexport * from \"./managed/credentials/contract/index.js\";\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,yCAAyC,CAAC","sourcesContent":["export * from \"./compact-value-codec.js\";\nexport * from \"./managed/credentials/contract/index.js\";\n"]}

package/dist/managed/credentials/contract/index.d.ts

@@ -6,22 +6,7 @@ export type SchemaRef = { packageId: Uint8Array;
                           minorVersion: bigint
                         };
 
-export type SchemaCapabilities = { supportsSelectiveDisclosure: boolean;
-                                   supportsPredicateProofs: boolean;
-                                   supportsVerifierScopedPseudonym: boolean;
-                                   supportsSameHolderProof: boolean
-                                 };
-
-export type SchemaFamilyResolutionHint = { hasResolverHint: boolean;
-                                           resolverHint: Uint8Array
-                                         };
-
-export type SchemaDescriptor = { schema: SchemaRef;
-                                 capabilities: SchemaCapabilities;
-                                 familyResolutionHint: SchemaFamilyResolutionHint
-                               };
-
-export type VerificationMethodRef = { didContractAddress: { bytes: Uint8Array };
+export type VerificationMethodRef = { controllerAddress: { bytes: Uint8Array };
                                       methodId: Uint8Array
                                     };
 
@@ -34,23 +19,6 @@ export type Signature = { r: __compactRuntime.JubjubPoint; s: bigint };
 export type ExplicitHolderBinding = { holderVerificationMethodRef: VerificationMethodRef
                                     };
 
-export type JubjubHolderBinding = { holderPublicKey: __compactRuntime.JubjubPoint
-                                  };
-
-export type OffchainMidnightHolderBinding = { holderDidStateHash: Uint8Array;
-                                              holderMethodId: Uint8Array;
-                                              holderPublicKey: __compactRuntime.JubjubPoint
-                                            };
-
-export type SecretHolderBinding = { holderSecretCommitment: Uint8Array;
-                                    requestChallengeResponse: Uint8Array
-                                  };
-
-export type BlindedSecretHolderBinding = { blindedHolderSecretCommitment: Uint8Array;
-                                           issuerNonce: Uint8Array;
-                                           requestChallengeResponse: Uint8Array
-                                         };
-
 export type Proof = { signerVerificationMethodRef: VerificationMethodRef;
                       createdAt: bigint;
                       challengeHash: Uint8Array;
@@ -58,26 +26,32 @@ export type Proof = { signerVerificationMethodRef: VerificationMethodRef;
                       signature: Signature
                     };
 
-export enum HolderBindingProfile { explicitDid = 0,
-                                   secretHolder = 1,
-                                   blindedSecretHolder = 2
+export enum SignerRole { issuer = 0, verifier = 1 }
+
+export enum AuthorizationState { active = 0, suspended = 1, revoked = 2 }
+
+export enum VerificationRelationship { assertionMethod = 0,
+                                       authentication = 1,
+                                       capabilityInvocation = 2
 }
 
-export type CredentialProtocolFeatures = { supportsSelectiveDisclosure: boolean;
-                                           supportsPredicateProofs: boolean;
-                                           supportsVerifierScopedPseudonym: boolean;
-                                           supportsSameHolderProof: boolean
+export type AuthorizedSignerDescriptor = { version: bigint;
+                                           authorizationId: Uint8Array;
+                                           decisionSequence: bigint;
+                                           state: AuthorizationState;
+                                           role: SignerRole;
+                                           signerVerificationMethodRef: VerificationMethodRef;
+                                           signerPublicKey: __compactRuntime.JubjubPoint;
+                                           didStateVersion: bigint;
+                                           verificationRelationship: VerificationRelationship;
+                                           scopeCommitment: Uint8Array;
+                                           policyCommitment: Uint8Array
                                          };
 
-export type ProtocolMessageEnvelope = { version: bigint;
-                                        messageId: Uint8Array;
-                                        threadId: Uint8Array;
-                                        initialMessage: boolean;
-                                        respondsToMessageId: Uint8Array;
-                                        createdAt: bigint;
-                                        hasExpiresAt: boolean;
-                                        expiresAt: bigint
-                                      };
+export type SignerAuthorizationAuthority = { domainCommitment: Uint8Array;
+                                             verificationMethodRef: VerificationMethodRef;
+                                             publicKey: __compactRuntime.JubjubPoint
+                                           };
 
 export type StatusRegistryRef = { registryId: Uint8Array;
                                   authorityVerificationMethodRef: VerificationMethodRef
@@ -85,10 +59,7 @@ export type StatusRegistryRef = { registryId: Uint8Array;
 
 export type NoStatusBinding = {  };
 
-export enum StatusType { revocationRegistry = 0 }
-
-export type RegistryBoundStatusBinding = { statusType: StatusType;
-                                           registryRef: StatusRegistryRef;
+export type RegistryBoundStatusBinding = { registryRef: StatusRegistryRef;
                                            statusHandleCommitment: Uint8Array
                                          };
 
@@ -102,103 +73,74 @@ export type ProvableCircuits<PS> = {
 }
 
 export type PureCircuits = {
-  noSchemaFamilyResolverHint(): Uint8Array;
   assertValidSchemaRef(schema_0: SchemaRef): [];
-  assertValidSchemaCapabilities(capabilities_0: SchemaCapabilities): [];
-  assertValidSchemaFamilyResolutionHint(hint_0: SchemaFamilyResolutionHint): [];
-  assertValidSchemaDescriptor(descriptor_0: SchemaDescriptor): [];
-  assertMatchingSchemaCapabilities(expected_0: SchemaCapabilities,
-                                   actual_0: SchemaCapabilities): [];
+  assertMatchingSchemaRefs(expected_0: SchemaRef, actual_0: SchemaRef): [];
+  assertValidVerificationMethodRef(verificationMethodRef_0: VerificationMethodRef): [];
   verifySignature(pk_0: __compactRuntime.JubjubPoint,
                   signature_0: Signature,
                   challenge_0: bigint): boolean;
   issuanceContextTag(): Uint8Array;
   presentationContextTag(): Uint8Array;
+  signerAuthorizationContextTag(): Uint8Array;
+  verifierRequestContextTag(): Uint8Array;
   issuanceProofPayloadRoot(bodyRoot_0: Uint8Array, proof_0: Proof): Uint8Array;
   presentationProofPayloadRoot(bodyRoot_0: Uint8Array, proof_0: Proof): Uint8Array;
   issuanceProofChallenge(bodyRoot_0: Uint8Array, proof_0: Proof): bigint;
   presentationProofChallenge(bodyRoot_0: Uint8Array, proof_0: Proof): bigint;
+  signerAuthorizationProofChallenge(bodyRoot_0: Uint8Array, proof_0: Proof): bigint;
+  verifierRequestProofChallenge(requestScopeCommitment_0: Uint8Array,
+                                proof_0: Proof): bigint;
   assertValidIssuanceContextProof(bodyRoot_0: Uint8Array, proof_0: Proof): [];
   assertValidPresentationContextProof(bodyRoot_0: Uint8Array, proof_0: Proof): [];
+  assertValidSignerAuthorizationContextProof(bodyRoot_0: Uint8Array,
+                                             proof_0: Proof): [];
+  assertValidVerifierRequestContextProof(requestScopeCommitment_0: Uint8Array,
+                                         proof_0: Proof): [];
+  assertValidAuthorizedSignerDescriptor(descriptor_0: AuthorizedSignerDescriptor): [];
+  authorizedSignerDescriptorRoot(descriptor_0: AuthorizedSignerDescriptor): Uint8Array;
+  issuerScopeCommitment(schema_0: SchemaRef): Uint8Array;
+  assertProofSignerMatchesAuthorization(proof_0: Proof,
+                                        descriptor_0: AuthorizedSignerDescriptor): [];
+  assertAuthorizedIssuerDescriptor(schema_0: SchemaRef,
+                                   proof_0: Proof,
+                                   descriptor_0: AuthorizedSignerDescriptor): [];
+  assertAuthorizedVerifierProof(requestScopeCommitment_0: Uint8Array,
+                                proof_0: Proof,
+                                descriptor_0: AuthorizedSignerDescriptor): [];
+  assertValidSignerAuthorizationAuthority(authority_0: SignerAuthorizationAuthority): [];
+  signerAuthorizationDecisionRoot(descriptor_0: AuthorizedSignerDescriptor,
+                                  domainCommitment_0: Uint8Array): Uint8Array;
+  assertValidSignerAuthorizationProof(descriptor_0: AuthorizedSignerDescriptor,
+                                      authorizationProof_0: Proof,
+                                      authority_0: SignerAuthorizationAuthority): [];
+  assertValidSignerAuthorizationUpdate(previous_0: AuthorizedSignerDescriptor,
+                                       next_0: AuthorizedSignerDescriptor): [];
   assertValidExplicitHolderBinding(binding_0: ExplicitHolderBinding): [];
   assertMatchingExplicitHolderBindings(credentialBinding_0: ExplicitHolderBinding,
                                        presentationBinding_0: ExplicitHolderBinding): [];
   assertProofMatchesExplicitHolderBinding(binding_0: ExplicitHolderBinding,
                                           presentationProof_0: Proof): [];
-  assertValidJubjubHolderBinding(binding_0: JubjubHolderBinding): [];
-  assertMatchingJubjubHolderBindings(credentialBinding_0: JubjubHolderBinding,
-                                     presentationBinding_0: JubjubHolderBinding): [];
-  assertProofMatchesJubjubHolderBinding(binding_0: JubjubHolderBinding,
-                                        presentationProof_0: Proof): [];
-  assertValidOffchainMidnightHolderBinding(binding_0: OffchainMidnightHolderBinding): [];
-  assertMatchingOffchainMidnightHolderBindings(credentialBinding_0: OffchainMidnightHolderBinding,
-                                               presentationBinding_0: OffchainMidnightHolderBinding): [];
-  assertProofMatchesOffchainMidnightHolderBinding(binding_0: OffchainMidnightHolderBinding,
-                                                  presentationProof_0: Proof): [];
-  noSecretHolderChallengeResponse(): Uint8Array;
-  secretHolderBindingCommitment(holderSecret_0: Uint8Array,
-                                opening_0: Uint8Array): Uint8Array;
-  secretHolderBindingChallengeResponse(holderSecret_0: Uint8Array,
-                                       verifierChallengeHash_0: Uint8Array): Uint8Array;
-  verifierScopedPseudonym(holderSecret_0: Uint8Array,
-                          verifierDomainHash_0: Uint8Array): Uint8Array;
-  assertVerifierScopedPseudonym(pseudonym_0: Uint8Array,
-                                holderSecret_0: Uint8Array,
-                                verifierDomainHash_0: Uint8Array): [];
-  blindedSecretHolderCommitment(holderSecretCommitment_0: Uint8Array,
-                                issuerNonce_0: Uint8Array,
-                                blindingFactor_0: Uint8Array): Uint8Array;
-  assertValidSecretHolderCredentialBinding(binding_0: SecretHolderBinding): [];
-  assertValidSecretHolderPresentationBinding(binding_0: SecretHolderBinding): [];
-  assertMatchingSecretHolderBindings(credentialBinding_0: SecretHolderBinding,
-                                     presentationBinding_0: SecretHolderBinding): [];
-  assertValidBlindedSecretHolderCredentialBinding(binding_0: BlindedSecretHolderBinding): [];
-  assertValidBlindedSecretHolderPresentationBinding(binding_0: BlindedSecretHolderBinding): [];
-  assertMatchingBlindedSecretHolderBindings(credentialBinding_0: BlindedSecretHolderBinding,
-                                            presentationBinding_0: BlindedSecretHolderBinding): [];
-  assertSecretHolderBindingWitness(binding_0: SecretHolderBinding,
-                                   verifierChallengeHash_0: Uint8Array,
-                                   holderSecret_0: Uint8Array,
-                                   opening_0: Uint8Array): [];
-  assertBlindedSecretHolderBindingWitness(binding_0: BlindedSecretHolderBinding,
-                                          verifierChallengeHash_0: Uint8Array,
-                                          holderSecret_0: Uint8Array,
-                                          opening_0: Uint8Array,
-                                          blindingFactor_0: Uint8Array): [];
-  protocolFeaturesAsSchemaCapabilities(features_0: CredentialProtocolFeatures): SchemaCapabilities;
-  assertProtocolFeaturesMatchSchemaCapabilities(features_0: CredentialProtocolFeatures,
-                                                capabilities_0: SchemaCapabilities): [];
-  noProtocolResponseReference(): Uint8Array;
-  assertValidVerificationMethodRef(verificationMethodRef_0: VerificationMethodRef): [];
-  assertMatchingSchemaRefs(expected_0: SchemaRef, actual_0: SchemaRef): [];
-  assertValidProtocolMessageEnvelope(envelope_0: ProtocolMessageEnvelope): [];
-  assertProtocolResponseEnvelope(requestEnvelope_0: ProtocolMessageEnvelope,
-                                 responseEnvelope_0: ProtocolMessageEnvelope): [];
   assertValidStatusRegistryRef(registryRef_0: StatusRegistryRef): [];
-  assertValidNoStatusBinding(binding_0: NoStatusBinding): [];
   assertValidRegistryBoundStatusBinding(binding_0: RegistryBoundStatusBinding): [];
   registryBoundStatusBindingRoot(binding_0: RegistryBoundStatusBinding): Uint8Array;
 }
 
 export type Circuits<PS> = {
-  noSchemaFamilyResolverHint(context: __compactRuntime.CircuitContext<PS>): __compactRuntime.CircuitResults<PS, Uint8Array>;
   assertValidSchemaRef(context: __compactRuntime.CircuitContext<PS>,
                        schema_0: SchemaRef): __compactRuntime.CircuitResults<PS, []>;
-  assertValidSchemaCapabilities(context: __compactRuntime.CircuitContext<PS>,
-                                capabilities_0: SchemaCapabilities): __compactRuntime.CircuitResults<PS, []>;
-  assertValidSchemaFamilyResolutionHint(context: __compactRuntime.CircuitContext<PS>,
-                                        hint_0: SchemaFamilyResolutionHint): __compactRuntime.CircuitResults<PS, []>;
-  assertValidSchemaDescriptor(context: __compactRuntime.CircuitContext<PS>,
-                              descriptor_0: SchemaDescriptor): __compactRuntime.CircuitResults<PS, []>;
-  assertMatchingSchemaCapabilities(context: __compactRuntime.CircuitContext<PS>,
-                                   expected_0: SchemaCapabilities,
-                                   actual_0: SchemaCapabilities): __compactRuntime.CircuitResults<PS, []>;
+  assertMatchingSchemaRefs(context: __compactRuntime.CircuitContext<PS>,
+                           expected_0: SchemaRef,
+                           actual_0: SchemaRef): __compactRuntime.CircuitResults<PS, []>;
+  assertValidVerificationMethodRef(context: __compactRuntime.CircuitContext<PS>,
+                                   verificationMethodRef_0: VerificationMethodRef): __compactRuntime.CircuitResults<PS, []>;
   verifySignature(context: __compactRuntime.CircuitContext<PS>,
                   pk_0: __compactRuntime.JubjubPoint,
                   signature_0: Signature,
                   challenge_0: bigint): __compactRuntime.CircuitResults<PS, boolean>;
   issuanceContextTag(context: __compactRuntime.CircuitContext<PS>): __compactRuntime.CircuitResults<PS, Uint8Array>;
   presentationContextTag(context: __compactRuntime.CircuitContext<PS>): __compactRuntime.CircuitResults<PS, Uint8Array>;
+  signerAuthorizationContextTag(context: __compactRuntime.CircuitContext<PS>): __compactRuntime.CircuitResults<PS, Uint8Array>;
+  verifierRequestContextTag(context: __compactRuntime.CircuitContext<PS>): __compactRuntime.CircuitResults<PS, Uint8Array>;
   issuanceProofPayloadRoot(context: __compactRuntime.CircuitContext<PS>,
                            bodyRoot_0: Uint8Array,
                            proof_0: Proof): __compactRuntime.CircuitResults<PS, Uint8Array>;
@@ -211,12 +153,53 @@ export type Circuits<PS> = {
   presentationProofChallenge(context: __compactRuntime.CircuitContext<PS>,
                              bodyRoot_0: Uint8Array,
                              proof_0: Proof): __compactRuntime.CircuitResults<PS, bigint>;
+  signerAuthorizationProofChallenge(context: __compactRuntime.CircuitContext<PS>,
+                                    bodyRoot_0: Uint8Array,
+                                    proof_0: Proof): __compactRuntime.CircuitResults<PS, bigint>;
+  verifierRequestProofChallenge(context: __compactRuntime.CircuitContext<PS>,
+                                requestScopeCommitment_0: Uint8Array,
+                                proof_0: Proof): __compactRuntime.CircuitResults<PS, bigint>;
   assertValidIssuanceContextProof(context: __compactRuntime.CircuitContext<PS>,
                                   bodyRoot_0: Uint8Array,
                                   proof_0: Proof): __compactRuntime.CircuitResults<PS, []>;
   assertValidPresentationContextProof(context: __compactRuntime.CircuitContext<PS>,
                                       bodyRoot_0: Uint8Array,
                                       proof_0: Proof): __compactRuntime.CircuitResults<PS, []>;
+  assertValidSignerAuthorizationContextProof(context: __compactRuntime.CircuitContext<PS>,
+                                             bodyRoot_0: Uint8Array,
+                                             proof_0: Proof): __compactRuntime.CircuitResults<PS, []>;
+  assertValidVerifierRequestContextProof(context: __compactRuntime.CircuitContext<PS>,
+                                         requestScopeCommitment_0: Uint8Array,
+                                         proof_0: Proof): __compactRuntime.CircuitResults<PS, []>;
+  assertValidAuthorizedSignerDescriptor(context: __compactRuntime.CircuitContext<PS>,
+                                        descriptor_0: AuthorizedSignerDescriptor): __compactRuntime.CircuitResults<PS, []>;
+  authorizedSignerDescriptorRoot(context: __compactRuntime.CircuitContext<PS>,
+                                 descriptor_0: AuthorizedSignerDescriptor): __compactRuntime.CircuitResults<PS, Uint8Array>;
+  issuerScopeCommitment(context: __compactRuntime.CircuitContext<PS>,
+                        schema_0: SchemaRef): __compactRuntime.CircuitResults<PS, Uint8Array>;
+  assertProofSignerMatchesAuthorization(context: __compactRuntime.CircuitContext<PS>,
+                                        proof_0: Proof,
+                                        descriptor_0: AuthorizedSignerDescriptor): __compactRuntime.CircuitResults<PS, []>;
+  assertAuthorizedIssuerDescriptor(context: __compactRuntime.CircuitContext<PS>,
+                                   schema_0: SchemaRef,
+                                   proof_0: Proof,
+                                   descriptor_0: AuthorizedSignerDescriptor): __compactRuntime.CircuitResults<PS, []>;
+  assertAuthorizedVerifierProof(context: __compactRuntime.CircuitContext<PS>,
+                                requestScopeCommitment_0: Uint8Array,
+                                proof_0: Proof,
+                                descriptor_0: AuthorizedSignerDescriptor): __compactRuntime.CircuitResults<PS, []>;
+  assertValidSignerAuthorizationAuthority(context: __compactRuntime.CircuitContext<PS>,
+                                          authority_0: SignerAuthorizationAuthority): __compactRuntime.CircuitResults<PS, []>;
+  signerAuthorizationDecisionRoot(context: __compactRuntime.CircuitContext<PS>,
+                                  descriptor_0: AuthorizedSignerDescriptor,
+                                  domainCommitment_0: Uint8Array): __compactRuntime.CircuitResults<PS, Uint8Array>;
+  assertValidSignerAuthorizationProof(context: __compactRuntime.CircuitContext<PS>,
+                                      descriptor_0: AuthorizedSignerDescriptor,
+                                      authorizationProof_0: Proof,
+                                      authority_0: SignerAuthorizationAuthority): __compactRuntime.CircuitResults<PS, []>;
+  assertValidSignerAuthorizationUpdate(context: __compactRuntime.CircuitContext<PS>,
+                                       previous_0: AuthorizedSignerDescriptor,
+                                       next_0: AuthorizedSignerDescriptor): __compactRuntime.CircuitResults<PS, []>;
   assertValidExplicitHolderBinding(context: __compactRuntime.CircuitContext<PS>,
                                    binding_0: ExplicitHolderBinding): __compactRuntime.CircuitResults<PS, []>;
   assertMatchingExplicitHolderBindings(context: __compactRuntime.CircuitContext<PS>,
@@ -225,85 +208,8 @@ export type Circuits<PS> = {
   assertProofMatchesExplicitHolderBinding(context: __compactRuntime.CircuitContext<PS>,
                                           binding_0: ExplicitHolderBinding,
                                           presentationProof_0: Proof): __compactRuntime.CircuitResults<PS, []>;
-  assertValidJubjubHolderBinding(context: __compactRuntime.CircuitContext<PS>,
-                                 binding_0: JubjubHolderBinding): __compactRuntime.CircuitResults<PS, []>;
-  assertMatchingJubjubHolderBindings(context: __compactRuntime.CircuitContext<PS>,
-                                     credentialBinding_0: JubjubHolderBinding,
-                                     presentationBinding_0: JubjubHolderBinding): __compactRuntime.CircuitResults<PS, []>;
-  assertProofMatchesJubjubHolderBinding(context: __compactRuntime.CircuitContext<PS>,
-                                        binding_0: JubjubHolderBinding,
-                                        presentationProof_0: Proof): __compactRuntime.CircuitResults<PS, []>;
-  assertValidOffchainMidnightHolderBinding(context: __compactRuntime.CircuitContext<PS>,
-                                           binding_0: OffchainMidnightHolderBinding): __compactRuntime.CircuitResults<PS, []>;
-  assertMatchingOffchainMidnightHolderBindings(context: __compactRuntime.CircuitContext<PS>,
-                                               credentialBinding_0: OffchainMidnightHolderBinding,
-                                               presentationBinding_0: OffchainMidnightHolderBinding): __compactRuntime.CircuitResults<PS, []>;
-  assertProofMatchesOffchainMidnightHolderBinding(context: __compactRuntime.CircuitContext<PS>,
-                                                  binding_0: OffchainMidnightHolderBinding,
-                                                  presentationProof_0: Proof): __compactRuntime.CircuitResults<PS, []>;
-  noSecretHolderChallengeResponse(context: __compactRuntime.CircuitContext<PS>): __compactRuntime.CircuitResults<PS, Uint8Array>;
-  secretHolderBindingCommitment(context: __compactRuntime.CircuitContext<PS>,
-                                holderSecret_0: Uint8Array,
-                                opening_0: Uint8Array): __compactRuntime.CircuitResults<PS, Uint8Array>;
-  secretHolderBindingChallengeResponse(context: __compactRuntime.CircuitContext<PS>,
-                                       holderSecret_0: Uint8Array,
-                                       verifierChallengeHash_0: Uint8Array): __compactRuntime.CircuitResults<PS, Uint8Array>;
-  verifierScopedPseudonym(context: __compactRuntime.CircuitContext<PS>,
-                          holderSecret_0: Uint8Array,
-                          verifierDomainHash_0: Uint8Array): __compactRuntime.CircuitResults<PS, Uint8Array>;
-  assertVerifierScopedPseudonym(context: __compactRuntime.CircuitContext<PS>,
-                                pseudonym_0: Uint8Array,
-                                holderSecret_0: Uint8Array,
-                                verifierDomainHash_0: Uint8Array): __compactRuntime.CircuitResults<PS, []>;
-  blindedSecretHolderCommitment(context: __compactRuntime.CircuitContext<PS>,
-                                holderSecretCommitment_0: Uint8Array,
-                                issuerNonce_0: Uint8Array,
-                                blindingFactor_0: Uint8Array): __compactRuntime.CircuitResults<PS, Uint8Array>;
-  assertValidSecretHolderCredentialBinding(context: __compactRuntime.CircuitContext<PS>,
-                                           binding_0: SecretHolderBinding): __compactRuntime.CircuitResults<PS, []>;
-  assertValidSecretHolderPresentationBinding(context: __compactRuntime.CircuitContext<PS>,
-                                             binding_0: SecretHolderBinding): __compactRuntime.CircuitResults<PS, []>;
-  assertMatchingSecretHolderBindings(context: __compactRuntime.CircuitContext<PS>,
-                                     credentialBinding_0: SecretHolderBinding,
-                                     presentationBinding_0: SecretHolderBinding): __compactRuntime.CircuitResults<PS, []>;
-  assertValidBlindedSecretHolderCredentialBinding(context: __compactRuntime.CircuitContext<PS>,
-                                                  binding_0: BlindedSecretHolderBinding): __compactRuntime.CircuitResults<PS, []>;
-  assertValidBlindedSecretHolderPresentationBinding(context: __compactRuntime.CircuitContext<PS>,
-                                                    binding_0: BlindedSecretHolderBinding): __compactRuntime.CircuitResults<PS, []>;
-  assertMatchingBlindedSecretHolderBindings(context: __compactRuntime.CircuitContext<PS>,
-                                            credentialBinding_0: BlindedSecretHolderBinding,
-                                            presentationBinding_0: BlindedSecretHolderBinding): __compactRuntime.CircuitResults<PS, []>;
-  assertSecretHolderBindingWitness(context: __compactRuntime.CircuitContext<PS>,
-                                   binding_0: SecretHolderBinding,
-                                   verifierChallengeHash_0: Uint8Array,
-                                   holderSecret_0: Uint8Array,
-                                   opening_0: Uint8Array): __compactRuntime.CircuitResults<PS, []>;
-  assertBlindedSecretHolderBindingWitness(context: __compactRuntime.CircuitContext<PS>,
-                                          binding_0: BlindedSecretHolderBinding,
-                                          verifierChallengeHash_0: Uint8Array,
-                                          holderSecret_0: Uint8Array,
-                                          opening_0: Uint8Array,
-                                          blindingFactor_0: Uint8Array): __compactRuntime.CircuitResults<PS, []>;
-  protocolFeaturesAsSchemaCapabilities(context: __compactRuntime.CircuitContext<PS>,
-                                       features_0: CredentialProtocolFeatures): __compactRuntime.CircuitResults<PS, SchemaCapabilities>;
-  assertProtocolFeaturesMatchSchemaCapabilities(context: __compactRuntime.CircuitContext<PS>,
-                                                features_0: CredentialProtocolFeatures,
-                                                capabilities_0: SchemaCapabilities): __compactRuntime.CircuitResults<PS, []>;
-  noProtocolResponseReference(context: __compactRuntime.CircuitContext<PS>): __compactRuntime.CircuitResults<PS, Uint8Array>;
-  assertValidVerificationMethodRef(context: __compactRuntime.CircuitContext<PS>,
-                                   verificationMethodRef_0: VerificationMethodRef): __compactRuntime.CircuitResults<PS, []>;
-  assertMatchingSchemaRefs(context: __compactRuntime.CircuitContext<PS>,
-                           expected_0: SchemaRef,
-                           actual_0: SchemaRef): __compactRuntime.CircuitResults<PS, []>;
-  assertValidProtocolMessageEnvelope(context: __compactRuntime.CircuitContext<PS>,
-                                     envelope_0: ProtocolMessageEnvelope): __compactRuntime.CircuitResults<PS, []>;
-  assertProtocolResponseEnvelope(context: __compactRuntime.CircuitContext<PS>,
-                                 requestEnvelope_0: ProtocolMessageEnvelope,
-                                 responseEnvelope_0: ProtocolMessageEnvelope): __compactRuntime.CircuitResults<PS, []>;
   assertValidStatusRegistryRef(context: __compactRuntime.CircuitContext<PS>,
                                registryRef_0: StatusRegistryRef): __compactRuntime.CircuitResults<PS, []>;
-  assertValidNoStatusBinding(context: __compactRuntime.CircuitContext<PS>,
-                             binding_0: NoStatusBinding): __compactRuntime.CircuitResults<PS, []>;
   assertValidRegistryBoundStatusBinding(context: __compactRuntime.CircuitContext<PS>,
                                         binding_0: RegistryBoundStatusBinding): __compactRuntime.CircuitResults<PS, []>;
   registryBoundStatusBindingRoot(context: __compactRuntime.CircuitContext<PS>,