@midnight-ntwrk/credential-compact 0.1.0-rc2

package/dist/credentials/vc.compact

@@ -0,0 +1,59 @@
+// Thin VC envelope surface.
+// Owns credential-local structure, body-root derivation, and issuer-proof
+// verification. Family-specific claim validation stays outside this module.
+module VC<TPublicClaims, TClaimCommitments, THolderBinding, TStatusBinding> {
+  export struct Credential {
+    version: Uint<16>,
+    schema: SchemaRef,
+    issuerVerificationMethodRef: VerificationMethodRef,
+    holderBinding: THolderBinding,
+    statusBinding: TStatusBinding,
+    issuedAt: Uint<64>,
+    hasExpiration: Boolean,
+    expiresAt: Uint<64>,
+    // Direct values intentionally carried in the signed credential body.
+    claims: TPublicClaims,
+    // Commitment digests for private and predicate-only claim values.
+    claimCommitments: TClaimCommitments,
+    claimRoot: Bytes<32>,
+  }
+
+  export pure circuit credentialBodyRoot(credential: Credential): Bytes<32> {
+    return persistentHash<Credential>(credential);
+  }
+
+  export pure circuit assertValidCredentialEnvelope(
+    credential: Credential,
+    expectedClaimRoot: Bytes<32>
+  ): [] {
+    assert(credential.version == 1, "Credential version mismatch");
+    assert(credential.claimRoot == expectedClaimRoot, "Credential claim root mismatch");
+    if (credential.hasExpiration) {
+      assert(credential.expiresAt >= credential.issuedAt, "Expiration must not precede issuance");
+    }
+  }
+
+  export pure circuit assertValidCredentialProof(
+    credential: Credential,
+    proof: Proof
+  ): [] {
+    const bodyRoot: Bytes<32> = credentialBodyRoot(credential);
+    assertValidCredentialProofForBodyRoot(credential, proof, bodyRoot);
+  }
+
+  export pure circuit assertValidCredentialProofForBodyRoot(
+    credential: Credential,
+    proof: Proof,
+    bodyRoot: Bytes<32>
+  ): [] {
+    assert(
+      credential.issuerVerificationMethodRef.didContractAddress == proof.signerVerificationMethodRef.didContractAddress,
+      "Issuer proof contract address does not match issuer verification method"
+    );
+    assert(
+      credential.issuerVerificationMethodRef.methodId == proof.signerVerificationMethodRef.methodId,
+      "Issuer proof method reference does not match issuer verification method"
+    );
+    assertValidIssuanceContextProof(bodyRoot, proof);
+  }
+}

package/dist/credentials/vp.compact

@@ -0,0 +1,25 @@
+// Thin VP envelope surface.
+// Owns presentation-local structure and body-root derivation. VC↔VP linkage
+// and holder-binding equality stay outside this module.
+module VP<TDisclosures, THolderBinding> {
+  export struct Presentation {
+    version: Uint<16>,
+    schema: SchemaRef,
+    credentialClaimRoot: Bytes<32>,
+    issuerVerificationMethodRef: VerificationMethodRef,
+    holderBinding: THolderBinding,
+    disclosed: TDisclosures,
+  }
+
+  export pure circuit presentationBodyRoot(presentation: Presentation): Bytes<32> {
+    return persistentHash<Presentation>(presentation);
+  }
+
+  export pure circuit assertValidPresentationEnvelope(
+    presentation: Presentation
+  ): [] {
+    // VC/VP linkage now lives in `relations.compact`; the thin VP surface only
+    // owns presentation-local envelope invariants.
+    assert(presentation.version == 1, "Presentation version mismatch");
+  }
+}

package/dist/credentials.compact

@@ -0,0 +1,20 @@
+// 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");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+pragma language_version >= 0.20;
+
+import CompactStandardLibrary;
+
+include "./credentials/composable";

package/dist/holder-binding/same-holder/composable.compact

@@ -0,0 +1,179 @@
+// 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");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Composition-safe entry point for Layer 3 contracts. The importing contract
+// must include `credentials/bindings` or
+// `credentials/composable` before including this file.
+
+
+// Capability package: prove that multiple holder bindings are satisfied by the
+// same hidden holder secret witness under one verifier session challenge.
+
+export pure circuit assertSameSecretHolderBindingWitnesses(
+  firstBinding: SecretHolderBinding,
+  secondBinding: SecretHolderBinding,
+  verifierChallengeHash: Bytes<32>,
+  holderSecret: Bytes<32>,
+  firstOpening: Bytes<32>,
+  secondOpening: Bytes<32>
+): [] {
+  assert(
+    firstBinding.holderSecretCommitment != secondBinding.holderSecretCommitment,
+    "Same-holder proof requires two distinct credential bindings"
+  );
+  assertSecretHolderBindingWitness(
+    firstBinding,
+    verifierChallengeHash,
+    holderSecret,
+    firstOpening
+  );
+  assertSecretHolderBindingWitness(
+    secondBinding,
+    verifierChallengeHash,
+    holderSecret,
+    secondOpening
+  );
+}
+
+// Three-credential same-holder composition for plain secret bindings.
+// This keeps the reusable capability explicit and bounded instead of
+// prematurely introducing a generic "bundle" abstraction.
+export pure circuit assertSameSecretHolderBindingWitnesses3(
+  firstBinding: SecretHolderBinding,
+  secondBinding: SecretHolderBinding,
+  thirdBinding: SecretHolderBinding,
+  verifierChallengeHash: Bytes<32>,
+  holderSecret: Bytes<32>,
+  firstOpening: Bytes<32>,
+  secondOpening: Bytes<32>,
+  thirdOpening: Bytes<32>
+): [] {
+  assert(
+    firstBinding.holderSecretCommitment != secondBinding.holderSecretCommitment,
+    "Same-holder proof requires distinct first and second credential bindings"
+  );
+  assert(
+    firstBinding.holderSecretCommitment != thirdBinding.holderSecretCommitment,
+    "Same-holder proof requires distinct first and third credential bindings"
+  );
+  assert(
+    secondBinding.holderSecretCommitment != thirdBinding.holderSecretCommitment,
+    "Same-holder proof requires distinct second and third credential bindings"
+  );
+
+  assertSecretHolderBindingWitness(
+    firstBinding,
+    verifierChallengeHash,
+    holderSecret,
+    firstOpening
+  );
+  assertSecretHolderBindingWitness(
+    secondBinding,
+    verifierChallengeHash,
+    holderSecret,
+    secondOpening
+  );
+  assertSecretHolderBindingWitness(
+    thirdBinding,
+    verifierChallengeHash,
+    holderSecret,
+    thirdOpening
+  );
+}
+
+// Same-holder composition for blinded bindings. The caller supplies the same
+// hidden holder witness together with the binding-specific opening and blinding
+// factor for each independently issued credential.
+export pure circuit assertSameBlindedSecretHolderBindingWitnesses(
+  firstBinding: BlindedSecretHolderBinding,
+  secondBinding: BlindedSecretHolderBinding,
+  verifierChallengeHash: Bytes<32>,
+  holderSecret: Bytes<32>,
+  firstOpening: Bytes<32>,
+  firstBlindingFactor: Bytes<32>,
+  secondOpening: Bytes<32>,
+  secondBlindingFactor: Bytes<32>
+): [] {
+  assert(
+    firstBinding.blindedHolderSecretCommitment != secondBinding.blindedHolderSecretCommitment,
+    "Same-holder proof requires two distinct credential bindings"
+  );
+  assertBlindedSecretHolderBindingWitness(
+    firstBinding,
+    verifierChallengeHash,
+    holderSecret,
+    firstOpening,
+    firstBlindingFactor
+  );
+  assertBlindedSecretHolderBindingWitness(
+    secondBinding,
+    verifierChallengeHash,
+    holderSecret,
+    secondOpening,
+    secondBlindingFactor
+  );
+}
+
+// Three-credential same-holder composition for blinded bindings. This is the
+// next bounded step after the two-credential primitive and is sufficient for
+// staged business flows such as travel or onboarding checks.
+export pure circuit assertSameBlindedSecretHolderBindingWitnesses3(
+  firstBinding: BlindedSecretHolderBinding,
+  secondBinding: BlindedSecretHolderBinding,
+  thirdBinding: BlindedSecretHolderBinding,
+  verifierChallengeHash: Bytes<32>,
+  holderSecret: Bytes<32>,
+  firstOpening: Bytes<32>,
+  firstBlindingFactor: Bytes<32>,
+  secondOpening: Bytes<32>,
+  secondBlindingFactor: Bytes<32>,
+  thirdOpening: Bytes<32>,
+  thirdBlindingFactor: Bytes<32>
+): [] {
+  assert(
+    firstBinding.blindedHolderSecretCommitment != secondBinding.blindedHolderSecretCommitment,
+    "Same-holder proof requires distinct first and second credential bindings"
+  );
+  assert(
+    firstBinding.blindedHolderSecretCommitment != thirdBinding.blindedHolderSecretCommitment,
+    "Same-holder proof requires distinct first and third credential bindings"
+  );
+  assert(
+    secondBinding.blindedHolderSecretCommitment != thirdBinding.blindedHolderSecretCommitment,
+    "Same-holder proof requires distinct second and third credential bindings"
+  );
+
+  assertBlindedSecretHolderBindingWitness(
+    firstBinding,
+    verifierChallengeHash,
+    holderSecret,
+    firstOpening,
+    firstBlindingFactor
+  );
+  assertBlindedSecretHolderBindingWitness(
+    secondBinding,
+    verifierChallengeHash,
+    holderSecret,
+    secondOpening,
+    secondBlindingFactor
+  );
+  assertBlindedSecretHolderBindingWitness(
+    thirdBinding,
+    verifierChallengeHash,
+    holderSecret,
+    thirdOpening,
+    thirdBlindingFactor
+  );
+}

package/dist/holder-binding/same-holder.compact

@@ -0,0 +1,180 @@
+// 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");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+pragma language_version >= 0.20;
+
+import CompactStandardLibrary;
+
+include "../credentials";
+
+// Capability package: prove that multiple holder bindings are satisfied by the
+// same hidden holder secret witness under one verifier session challenge.
+
+export pure circuit assertSameSecretHolderBindingWitnesses(
+  firstBinding: SecretHolderBinding,
+  secondBinding: SecretHolderBinding,
+  verifierChallengeHash: Bytes<32>,
+  holderSecret: Bytes<32>,
+  firstOpening: Bytes<32>,
+  secondOpening: Bytes<32>
+): [] {
+  assert(
+    firstBinding.holderSecretCommitment != secondBinding.holderSecretCommitment,
+    "Same-holder proof requires two distinct credential bindings"
+  );
+  assertSecretHolderBindingWitness(
+    firstBinding,
+    verifierChallengeHash,
+    holderSecret,
+    firstOpening
+  );
+  assertSecretHolderBindingWitness(
+    secondBinding,
+    verifierChallengeHash,
+    holderSecret,
+    secondOpening
+  );
+}
+
+// Three-credential same-holder composition for plain secret bindings.
+// This keeps the reusable capability explicit and bounded instead of
+// prematurely introducing a generic "bundle" abstraction.
+export pure circuit assertSameSecretHolderBindingWitnesses3(
+  firstBinding: SecretHolderBinding,
+  secondBinding: SecretHolderBinding,
+  thirdBinding: SecretHolderBinding,
+  verifierChallengeHash: Bytes<32>,
+  holderSecret: Bytes<32>,
+  firstOpening: Bytes<32>,
+  secondOpening: Bytes<32>,
+  thirdOpening: Bytes<32>
+): [] {
+  assert(
+    firstBinding.holderSecretCommitment != secondBinding.holderSecretCommitment,
+    "Same-holder proof requires distinct first and second credential bindings"
+  );
+  assert(
+    firstBinding.holderSecretCommitment != thirdBinding.holderSecretCommitment,
+    "Same-holder proof requires distinct first and third credential bindings"
+  );
+  assert(
+    secondBinding.holderSecretCommitment != thirdBinding.holderSecretCommitment,
+    "Same-holder proof requires distinct second and third credential bindings"
+  );
+
+  assertSecretHolderBindingWitness(
+    firstBinding,
+    verifierChallengeHash,
+    holderSecret,
+    firstOpening
+  );
+  assertSecretHolderBindingWitness(
+    secondBinding,
+    verifierChallengeHash,
+    holderSecret,
+    secondOpening
+  );
+  assertSecretHolderBindingWitness(
+    thirdBinding,
+    verifierChallengeHash,
+    holderSecret,
+    thirdOpening
+  );
+}
+
+// Same-holder composition for blinded bindings. The caller supplies the same
+// hidden holder witness together with the binding-specific opening and blinding
+// factor for each independently issued credential.
+export pure circuit assertSameBlindedSecretHolderBindingWitnesses(
+  firstBinding: BlindedSecretHolderBinding,
+  secondBinding: BlindedSecretHolderBinding,
+  verifierChallengeHash: Bytes<32>,
+  holderSecret: Bytes<32>,
+  firstOpening: Bytes<32>,
+  firstBlindingFactor: Bytes<32>,
+  secondOpening: Bytes<32>,
+  secondBlindingFactor: Bytes<32>
+): [] {
+  assert(
+    firstBinding.blindedHolderSecretCommitment != secondBinding.blindedHolderSecretCommitment,
+    "Same-holder proof requires two distinct credential bindings"
+  );
+  assertBlindedSecretHolderBindingWitness(
+    firstBinding,
+    verifierChallengeHash,
+    holderSecret,
+    firstOpening,
+    firstBlindingFactor
+  );
+  assertBlindedSecretHolderBindingWitness(
+    secondBinding,
+    verifierChallengeHash,
+    holderSecret,
+    secondOpening,
+    secondBlindingFactor
+  );
+}
+
+// Three-credential same-holder composition for blinded bindings. This is the
+// next bounded step after the two-credential primitive and is sufficient for
+// staged business flows such as travel or onboarding checks.
+export pure circuit assertSameBlindedSecretHolderBindingWitnesses3(
+  firstBinding: BlindedSecretHolderBinding,
+  secondBinding: BlindedSecretHolderBinding,
+  thirdBinding: BlindedSecretHolderBinding,
+  verifierChallengeHash: Bytes<32>,
+  holderSecret: Bytes<32>,
+  firstOpening: Bytes<32>,
+  firstBlindingFactor: Bytes<32>,
+  secondOpening: Bytes<32>,
+  secondBlindingFactor: Bytes<32>,
+  thirdOpening: Bytes<32>,
+  thirdBlindingFactor: Bytes<32>
+): [] {
+  assert(
+    firstBinding.blindedHolderSecretCommitment != secondBinding.blindedHolderSecretCommitment,
+    "Same-holder proof requires distinct first and second credential bindings"
+  );
+  assert(
+    firstBinding.blindedHolderSecretCommitment != thirdBinding.blindedHolderSecretCommitment,
+    "Same-holder proof requires distinct first and third credential bindings"
+  );
+  assert(
+    secondBinding.blindedHolderSecretCommitment != thirdBinding.blindedHolderSecretCommitment,
+    "Same-holder proof requires distinct second and third credential bindings"
+  );
+
+  assertBlindedSecretHolderBindingWitness(
+    firstBinding,
+    verifierChallengeHash,
+    holderSecret,
+    firstOpening,
+    firstBlindingFactor
+  );
+  assertBlindedSecretHolderBindingWitness(
+    secondBinding,
+    verifierChallengeHash,
+    holderSecret,
+    secondOpening,
+    secondBlindingFactor
+  );
+  assertBlindedSecretHolderBindingWitness(
+    thirdBinding,
+    verifierChallengeHash,
+    holderSecret,
+    thirdOpening,
+    thirdBlindingFactor
+  );
+}

package/dist/holder-binding/same-holder.d.ts

@@ -0,0 +1,2 @@
+export * from "../managed/same-holder/contract/index.js";
+//# sourceMappingURL=same-holder.d.ts.map

package/dist/holder-binding/same-holder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"same-holder.d.ts","sourceRoot":"","sources":["../../src/holder-binding/same-holder.ts"],"names":[],"mappings":"AAAA,cAAc,0CAA0C,CAAC"}

package/dist/holder-binding/same-holder.js

@@ -0,0 +1,2 @@
+export * from "../managed/same-holder/contract/index.js";
+//# sourceMappingURL=same-holder.js.map

package/dist/holder-binding/same-holder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"same-holder.js","sourceRoot":"","sources":["../../src/holder-binding/same-holder.ts"],"names":[],"mappings":"AAAA,cAAc,0CAA0C,CAAC","sourcesContent":["export * from \"../managed/same-holder/contract/index.js\";\n"]}

package/dist/index.d.ts

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

package/dist/index.d.ts.map

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

package/dist/index.js

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

package/dist/index.js.map

@@ -0,0 +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"]}

package/dist/jubjub.d.ts

@@ -0,0 +1,3 @@
+export declare const JUBJUB_SUBGROUP_ORDER = 6554484396890773809930967563523245729705921265872317281365359162392183254199n;
+export declare const modJubjubSubgroupOrder: (value: bigint) => bigint;
+//# sourceMappingURL=jubjub.d.ts.map

package/dist/jubjub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jubjub.d.ts","sourceRoot":"","sources":["../src/jubjub.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB,gFAC6C,CAAC;AAEhF,eAAO,MAAM,sBAAsB,GAAI,OAAO,MAAM,KAAG,MAGtD,CAAC"}

package/dist/jubjub.js

@@ -0,0 +1,6 @@
+export const JUBJUB_SUBGROUP_ORDER = 6554484396890773809930967563523245729705921265872317281365359162392183254199n;
+export const modJubjubSubgroupOrder = (value) => {
+    const reduced = value % JUBJUB_SUBGROUP_ORDER;
+    return reduced >= 0n ? reduced : reduced + JUBJUB_SUBGROUP_ORDER;
+};
+//# sourceMappingURL=jubjub.js.map

package/dist/jubjub.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jubjub.js","sourceRoot":"","sources":["../src/jubjub.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,qBAAqB,GAChC,6EAA6E,CAAC;AAEhF,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,KAAa,EAAU,EAAE;IAC9D,MAAM,OAAO,GAAG,KAAK,GAAG,qBAAqB,CAAC;IAC9C,OAAO,OAAO,IAAI,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,GAAG,qBAAqB,CAAC;AACnE,CAAC,CAAC","sourcesContent":["export const JUBJUB_SUBGROUP_ORDER =\n  6554484396890773809930967563523245729705921265872317281365359162392183254199n;\n\nexport const modJubjubSubgroupOrder = (value: bigint): bigint => {\n  const reduced = value % JUBJUB_SUBGROUP_ORDER;\n  return reduced >= 0n ? reduced : reduced + JUBJUB_SUBGROUP_ORDER;\n};\n"]}