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

package/dist/managed/same-holder/contract/index.js.map

@@ -1,8 +0,0 @@
-{
-  "version": 3,
-  "file": "index.js",
-  "sourceRoot": "../../../../",
-  "sources": ["src/holder-binding/same-holder.compact", "src/holder-binding/.././credentials/./types.compact", "src/holder-binding/.././credentials/./proofs.compact", "src/holder-binding/.././credentials/./holder-bindings.compact", "src/holder-binding/.././credentials/./protocols.compact", "src/holder-binding/.././credentials/./status-bindings.compact", "compiler/standard-library.compact"],
-  "names": [],
-  "mappings": "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"
-}

package/src/credentials/bindings.compact

@@ -1,5 +0,0 @@
-// Shared binding surface for capability packages that only need holder-binding
-// types and witness-validation helpers.
-
-include "./types";
-include "./holder-bindings";

package/src/credentials/composable.compact

@@ -1,14 +0,0 @@
-// Composition-safe shared root for Layer 3 contracts and credential-family
-// entrypoints. This file includes the leaf modules directly because Compact
-// does not deduplicate repeated includes across intermediate entry points.
-
-include "./types";
-include "./proofs";
-include "./vc";
-include "./vp";
-include "./relations";
-include "./holder-bindings";
-include "./protocols";
-include "./issue";
-include "./present";
-include "./status-bindings";

package/src/credentials/holder-bindings.compact

@@ -1,320 +0,0 @@
-// 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
-// =====================
-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"
-  );
-}
-
-export pure circuit assertMatchingExplicitHolderBindings(
-  credentialBinding: ExplicitHolderBinding,
-  presentationBinding: ExplicitHolderBinding
-): [] {
-  assert(
-    presentationBinding.holderVerificationMethodRef.didContractAddress
-      == credentialBinding.holderVerificationMethodRef.didContractAddress,
-    "Presentation holder contract does not match credential holder binding"
-  );
-  assert(
-    presentationBinding.holderVerificationMethodRef.methodId
-      == credentialBinding.holderVerificationMethodRef.methodId,
-    "Presentation holder method reference does not match credential holder binding"
-  );
-}
-
-export pure circuit assertProofMatchesExplicitHolderBinding(
-  binding: ExplicitHolderBinding,
-  presentationProof: Proof
-): [] {
-  assert(
-    binding.holderVerificationMethodRef.didContractAddress
-      == presentationProof.signerVerificationMethodRef.didContractAddress,
-    "Presentation proof signer must match holder binding"
-  );
-  assert(
-    binding.holderVerificationMethodRef.methodId
-      == presentationProof.signerVerificationMethodRef.methodId,
-    "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/src/credentials/issue.compact

@@ -1,91 +0,0 @@
-// Generic issuance message choreography.
-// Owns offer/request/result envelope alignment only; issuer- and holder-side
-// claim semantics stay in the family layer.
-module Issue<TOfferBody, TRequestBody, TResultBody> {
-  export struct OfferMessage {
-    envelope: ProtocolMessageEnvelope,
-    schema: SchemaRef,
-    issuerVerificationMethodRef: VerificationMethodRef,
-    holderBindingProfile: HolderBindingProfile,
-    features: CredentialProtocolFeatures,
-    body: TOfferBody,
-  }
-
-  export struct RequestMessage {
-    envelope: ProtocolMessageEnvelope,
-    schema: SchemaRef,
-    issuerVerificationMethodRef: VerificationMethodRef,
-    holderBindingProfile: HolderBindingProfile,
-    body: TRequestBody,
-  }
-
-  export struct ResultMessage {
-    envelope: ProtocolMessageEnvelope,
-    schema: SchemaRef,
-    issuerVerificationMethodRef: VerificationMethodRef,
-    holderBindingProfile: HolderBindingProfile,
-    body: TResultBody,
-  }
-
-  export pure circuit assertValidOfferMessage(
-    offer: OfferMessage
-  ): [] {
-    assertValidProtocolMessageEnvelope(offer.envelope);
-    assert(offer.envelope.initialMessage, "Issuance offer must be the initial message");
-    assertValidVerificationMethodRef(offer.issuerVerificationMethodRef);
-  }
-
-  export pure circuit assertValidRequestMessage(
-    request: RequestMessage
-  ): [] {
-    assertValidProtocolMessageEnvelope(request.envelope);
-    assert(!request.envelope.initialMessage, "Issuance request must be a response message");
-    assertValidVerificationMethodRef(request.issuerVerificationMethodRef);
-  }
-
-  export pure circuit assertOfferRequestAlignment(
-    offer: OfferMessage,
-    request: RequestMessage
-  ): [] {
-    assertValidOfferMessage(offer);
-    assertValidRequestMessage(request);
-    assertProtocolResponseEnvelope(offer.envelope, request.envelope);
-    assertMatchingSchemaRefs(offer.schema, request.schema);
-    assert(
-      offer.issuerVerificationMethodRef.didContractAddress == request.issuerVerificationMethodRef.didContractAddress
-        && offer.issuerVerificationMethodRef.methodId == request.issuerVerificationMethodRef.methodId,
-      "Issuance request issuer verification method does not match the offer"
-    );
-    assert(
-      offer.holderBindingProfile == request.holderBindingProfile,
-      "Issuance request holder binding profile does not match the offer"
-    );
-  }
-
-  export pure circuit assertValidResultMessage(
-    result: ResultMessage
-  ): [] {
-    assertValidProtocolMessageEnvelope(result.envelope);
-    assert(!result.envelope.initialMessage, "Issuance result must be a response message");
-    assertValidVerificationMethodRef(result.issuerVerificationMethodRef);
-  }
-
-  export pure circuit assertRequestResultAlignment(
-    request: RequestMessage,
-    result: ResultMessage
-  ): [] {
-    assertValidRequestMessage(request);
-    assertValidResultMessage(result);
-    assertProtocolResponseEnvelope(request.envelope, result.envelope);
-    assertMatchingSchemaRefs(request.schema, result.schema);
-    assert(
-      request.issuerVerificationMethodRef.didContractAddress == result.issuerVerificationMethodRef.didContractAddress
-        && request.issuerVerificationMethodRef.methodId == result.issuerVerificationMethodRef.methodId,
-      "Issuance result issuer verification method does not match the request"
-    );
-    assert(
-      request.holderBindingProfile == result.holderBindingProfile,
-      "Issuance result holder binding profile does not match the request"
-    );
-  }
-}

package/src/credentials/present.compact

@@ -1,84 +0,0 @@
-// Generic presentation message choreography.
-// Owns request/submission/result envelope alignment; the family layer decides
-// what a verifier asked for and what a holder actually proved or disclosed.
-module Present<TRequestBody, TSubmissionBody, TResultBody> {
-  export struct RequestMessage {
-    envelope: ProtocolMessageEnvelope,
-    schema: SchemaRef,
-    issuerVerificationMethodRef: VerificationMethodRef,
-    holderBindingProfile: HolderBindingProfile,
-    features: CredentialProtocolFeatures,
-    verifierChallengeHash: Bytes<32>,
-    body: TRequestBody,
-  }
-
-  export struct SubmissionMessage {
-    envelope: ProtocolMessageEnvelope,
-    schema: SchemaRef,
-    issuerVerificationMethodRef: VerificationMethodRef,
-    holderBindingProfile: HolderBindingProfile,
-    challengeHash: Bytes<32>,
-    body: TSubmissionBody,
-  }
-
-  export struct ResultMessage {
-    envelope: ProtocolMessageEnvelope,
-    approved: Boolean,
-    body: TResultBody,
-  }
-
-  export pure circuit assertValidRequestMessage(
-    request: RequestMessage
-  ): [] {
-    assertValidProtocolMessageEnvelope(request.envelope);
-    assert(request.envelope.initialMessage, "Presentation request must be the initial message");
-    assertValidVerificationMethodRef(request.issuerVerificationMethodRef);
-  }
-
-  export pure circuit assertValidSubmissionMessage(
-    submission: SubmissionMessage
-  ): [] {
-    assertValidProtocolMessageEnvelope(submission.envelope);
-    assert(!submission.envelope.initialMessage, "Presentation submission must be a response message");
-    assertValidVerificationMethodRef(submission.issuerVerificationMethodRef);
-  }
-
-  export pure circuit assertRequestSubmissionAlignment(
-    request: RequestMessage,
-    submission: SubmissionMessage
-  ): [] {
-    assertValidRequestMessage(request);
-    assertValidSubmissionMessage(submission);
-    assertProtocolResponseEnvelope(request.envelope, submission.envelope);
-    assertMatchingSchemaRefs(request.schema, submission.schema);
-    assert(
-      request.issuerVerificationMethodRef.didContractAddress == submission.issuerVerificationMethodRef.didContractAddress
-        && request.issuerVerificationMethodRef.methodId == submission.issuerVerificationMethodRef.methodId,
-      "Presentation submission issuer verification method does not match the request"
-    );
-    assert(
-      request.holderBindingProfile == submission.holderBindingProfile,
-      "Presentation submission holder binding profile does not match the request"
-    );
-    assert(
-      request.verifierChallengeHash == submission.challengeHash,
-      "Presentation submission challenge does not match the request challenge"
-    );
-  }
-
-  export pure circuit assertValidResultMessage(
-    result: ResultMessage
-  ): [] {
-    assertValidProtocolMessageEnvelope(result.envelope);
-    assert(!result.envelope.initialMessage, "Presentation result must be a response message");
-  }
-
-  export pure circuit assertSubmissionResultAlignment(
-    submission: SubmissionMessage,
-    result: ResultMessage
-  ): [] {
-    assertValidSubmissionMessage(submission);
-    assertValidResultMessage(result);
-    assertProtocolResponseEnvelope(submission.envelope, result.envelope);
-  }
-}

package/src/credentials/proofs.compact

@@ -1,122 +0,0 @@
-// Context-tagged proof primitives.
-// This file owns signature verification plus the shared proof payload/challenge
-// derivation rules for generic issuance and presentation flows.
-export pure circuit verifySignature(
-  pk: JubjubPoint,
-  signature: Signature,
-  challenge: Field
-): Boolean {
-  const leftSide: JubjubPoint = ecMulGenerator(signature.s);
-  const cPk: JubjubPoint = ecMul(pk, challenge);
-  const rightSide: JubjubPoint = ecAdd(signature.r, cPk);
-  const xMatches: Boolean = jubjubPointX(leftSide) == jubjubPointX(rightSide);
-  const yMatches: Boolean = jubjubPointY(leftSide) == jubjubPointY(rightSide);
-  assert(xMatches && yMatches, "Signature verification failed");
-  return xMatches && yMatches;
-}
-
-// NOTE: The proof object does not carry a purpose field. Instead, the verifier
-// chooses the context-specific challenge derivation helper, which gives us
-// explicit domain separation without asking callers to populate a mutable enum.
-// =====================
-// Context tags
-// =====================
-export pure circuit issuanceContextTag(): Bytes<32> {
-  return pad(32, "midnight:vc:issuance");
-}
-
-export pure circuit presentationContextTag(): Bytes<32> {
-  return pad(32, "midnight:vc:presentation");
-}
-
-// =====================
-// Internal payload and challenge derivation
-// =====================
-pure circuit proofPayloadRootForContext(
-  bodyRoot: Bytes<32>,
-  contextTag: Bytes<32>,
-  proof: Proof
-): Bytes<32> {
-  return persistentHash<Vector<5, Bytes<32>>>([
-    bodyRoot,
-    contextTag,
-    persistentHash<VerificationMethodRef>(proof.signerVerificationMethodRef),
-    upgradeFromTransient(transientHash<Uint<64>>(proof.createdAt)),
-    proof.challengeHash
-  ]);
-}
-
-pure circuit proofChallengeForContext(
-  bodyRoot: Bytes<32>,
-  contextTag: Bytes<32>,
-  proof: Proof
-): Field {
-  return degradeToTransient(persistentHash<Vector<3, Bytes<32>>>([
-    proofPayloadRootForContext(bodyRoot, contextTag, proof),
-    upgradeFromTransient(transientHash<JubjubPoint>(proof.publicKey)),
-    upgradeFromTransient(transientHash<JubjubPoint>(proof.signature.r))
-  ]));
-}
-
-pure circuit assertValidProofForContext(
-  bodyRoot: Bytes<32>,
-  contextTag: Bytes<32>,
-  proof: Proof
-): [] {
-  assert(
-    verifySignature(
-      proof.publicKey,
-      proof.signature,
-      proofChallengeForContext(bodyRoot, contextTag, proof)
-    ),
-    "Proof verification failed"
-  );
-}
-
-export pure circuit issuanceProofPayloadRoot(
-  bodyRoot: Bytes<32>,
-  proof: Proof
-): Bytes<32> {
-  return proofPayloadRootForContext(bodyRoot, issuanceContextTag(), proof);
-}
-
-export pure circuit presentationProofPayloadRoot(
-  bodyRoot: Bytes<32>,
-  proof: Proof
-): Bytes<32> {
-  return proofPayloadRootForContext(bodyRoot, presentationContextTag(), proof);
-}
-
-export pure circuit issuanceProofChallenge(
-  bodyRoot: Bytes<32>,
-  proof: Proof
-): Field {
-  return proofChallengeForContext(bodyRoot, issuanceContextTag(), proof);
-}
-
-export pure circuit presentationProofChallenge(
-  bodyRoot: Bytes<32>,
-  proof: Proof
-): Field {
-  return proofChallengeForContext(bodyRoot, presentationContextTag(), proof);
-}
-
-// =====================
-// Public context-specific proof entrypoints
-// =====================
-// NOTE: The proof container is generic, but the verification context is
-// explicit. Callers choose the context helper rather than mutating the proof
-// payload itself.
-export pure circuit assertValidIssuanceContextProof(
-  bodyRoot: Bytes<32>,
-  proof: Proof
-): [] {
-  assertValidProofForContext(bodyRoot, issuanceContextTag(), proof);
-}
-
-export pure circuit assertValidPresentationContextProof(
-  bodyRoot: Bytes<32>,
-  proof: Proof
-): [] {
-  assertValidProofForContext(bodyRoot, presentationContextTag(), proof);
-}

package/src/credentials/protocol-support.compact

@@ -1,7 +0,0 @@
-// Shared protocol surface for credential families that model issuance and
-// presentation exchanges over the generic protocol modules.
-
-include "./types";
-include "./protocols";
-include "./issue";
-include "./present";