@midnight-ntwrk/midnight-did-contract 0.5.0-rc1

package/dist/did.compact

@@ -0,0 +1,375 @@
+// This file is part of midnightntwrk/midnight-did.
+// Copyright (C) 2025 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;
+import "../../jubjub-schnorr/src/schnorr" prefix Schnorr_;
+
+export { Schnorr_SchnorrSignature };
+
+// Ledger state - Full DID Document
+export ledger contractVersion: Uint<32>;
+export ledger controllerPublicKey: Bytes<32>;
+export ledger id: ContractAddress;
+export ledger alsoKnownAs: Set<Opaque<"string">>;
+export ledger version: Counter;
+export ledger created: Uint<64>;
+export ledger updated: Uint<64>;
+export ledger deactivated: Boolean;
+export ledger active: Boolean;
+export ledger operationCount: Counter;
+export ledger verificationMethods: Map<Opaque<"string">, VerificationMethod>;
+export ledger schnorrJubjubVerificationMethods: Map<Opaque<"string">, SchnorrJubjubVerificationMethod>;
+export ledger authenticationRelation: Set<Opaque<"string">>;
+export ledger assertionMethodRelation: Set<Opaque<"string">>;
+export ledger keyAgreementRelation: Set<Opaque<"string">>;
+export ledger capabilityInvocationRelation: Set<Opaque<"string">>;
+export ledger capabilityDelegationRelation: Set<Opaque<"string">>;
+export ledger services: Map<Opaque<"string">, Service>;
+
+// Witnesses
+witness localSecretKey(): Bytes<32>;
+witness currentTimestamp(): Uint<64>;
+
+// Enums and Structs
+export enum VerificationMethodType {
+  Undefined,
+  JsonWebKey
+}
+
+export enum VerificationMethodRelation {
+  Undefined,
+  Authentication,
+  AssertionMethod,
+  KeyAgreement,
+  CapabilityInvocation,
+  CapabilityDelegation
+}
+
+export enum MapMutation {
+  Undefined,
+  Insert,
+  Update
+}
+
+export enum SetMutation {
+  Undefined,
+  Insert,
+  Remove
+}
+
+export enum KeyType {
+  EC, RSA, oct, OKP
+}
+
+export enum CurveType {
+  Ed25519, X25519, Jubjub, P256, Secp256k1, BLS12381G1, BLS12381G2
+}
+
+export struct PublicKeyJwk {
+  kty: KeyType,
+  crv: CurveType,
+  x: Opaque<"string">,
+  y: Opaque<"string">,
+}
+
+export struct VerificationMethod {
+  id: Opaque<"string">,
+  typ: VerificationMethodType,
+  publicKeyJwk: PublicKeyJwk,
+};
+
+export struct SchnorrJubjubVerificationMethod {
+  id: Opaque<"string">,
+  publicKey: JubjubPoint,
+}
+
+export struct Service {
+  id: Opaque<"string">,
+  typ: Opaque<"string">,
+  serviceEndpoint: Opaque<"string">,
+}
+
+circuit verificationMethodExists(id: Opaque<"string">): Boolean {
+  return verificationMethods.member(id) || schnorrJubjubVerificationMethods.member(id);
+}
+
+circuit controllerKey(sk: Bytes<32>): Bytes<32> {
+  return persistentHash<Vector<2, Bytes<32>>>([pad(32, "did:controller:pk"), sk]);
+}
+
+circuit assertController(): [] {
+  assert(controllerKey(localSecretKey()) == controllerPublicKey, "DID controller is allowed to update the DID only");
+}
+
+circuit assertControllerCanUpdate(): [] {
+  assertController();
+  assert(active, "Contract is not active");
+}
+
+circuit recordUpdate(): [] {
+  operationCount.increment(1);
+  version.increment(1);
+  updated = disclose(currentTimestamp());
+}
+
+circuit assertMapMutationDefined(mutation: MapMutation): [] {
+  assert(mutation == MapMutation.Insert || mutation == MapMutation.Update, "Map mutation must be Insert or Update");
+}
+
+circuit assertSetMutationDefined(mutation: SetMutation): [] {
+  assert(mutation == SetMutation.Insert || mutation == SetMutation.Remove, "Set mutation must be Insert or Remove");
+}
+
+circuit assertSupportedVerificationMethod(verificationMethod: VerificationMethod): [] {
+  assert(verificationMethod.typ == VerificationMethodType.JsonWebKey, "Only JsonWebKey verification methods are supported");
+  if (verificationMethod.publicKeyJwk.kty == KeyType.OKP) {
+    assert(verificationMethod.publicKeyJwk.crv == CurveType.Ed25519 || verificationMethod.publicKeyJwk.crv == CurveType.X25519 || verificationMethod.publicKeyJwk.crv == CurveType.BLS12381G1 || verificationMethod.publicKeyJwk.crv == CurveType.BLS12381G2, "OKP keys must use Ed25519, X25519, BLS12381G1, or BLS12381G2");
+  } else if (verificationMethod.publicKeyJwk.kty == KeyType.EC) {
+    assert(verificationMethod.publicKeyJwk.crv == CurveType.P256 || verificationMethod.publicKeyJwk.crv == CurveType.Secp256k1, "EC keys must use P-256 or secp256k1; use SchnorrJubjub methods for Jubjub");
+  } else {
+    assert(false, "Only OKP (Ed25519/X25519/BLS12381G1/BLS12381G2) and EC (P-256/secp256k1) keys are supported");
+  }
+}
+
+circuit verificationMethodRelationMember(
+  relation: VerificationMethodRelation,
+  methodId: Opaque<"string">
+): Boolean {
+  if (relation == VerificationMethodRelation.Authentication) {
+    return authenticationRelation.member(methodId);
+  } else if (relation == VerificationMethodRelation.AssertionMethod) {
+    return assertionMethodRelation.member(methodId);
+  } else if (relation == VerificationMethodRelation.KeyAgreement) {
+    return keyAgreementRelation.member(methodId);
+  } else if (relation == VerificationMethodRelation.CapabilityInvocation) {
+    return capabilityInvocationRelation.member(methodId);
+  } else if (relation == VerificationMethodRelation.CapabilityDelegation) {
+    return capabilityDelegationRelation.member(methodId);
+  }
+  return false;
+}
+
+circuit insertVerificationMethodRelation(
+  relation: VerificationMethodRelation,
+  methodId: Opaque<"string">
+): [] {
+  if (relation == VerificationMethodRelation.Authentication) {
+    authenticationRelation.insert(methodId);
+  } else if (relation == VerificationMethodRelation.AssertionMethod) {
+    assertionMethodRelation.insert(methodId);
+  } else if (relation == VerificationMethodRelation.KeyAgreement) {
+    keyAgreementRelation.insert(methodId);
+  } else if (relation == VerificationMethodRelation.CapabilityInvocation) {
+    capabilityInvocationRelation.insert(methodId);
+  } else if (relation == VerificationMethodRelation.CapabilityDelegation) {
+    capabilityDelegationRelation.insert(methodId);
+  }
+}
+
+circuit removeVerificationMethodRelationFromLedger(
+  relation: VerificationMethodRelation,
+  methodId: Opaque<"string">
+): [] {
+  if (relation == VerificationMethodRelation.Authentication) {
+    authenticationRelation.remove(methodId);
+  } else if (relation == VerificationMethodRelation.AssertionMethod) {
+    assertionMethodRelation.remove(methodId);
+  } else if (relation == VerificationMethodRelation.KeyAgreement) {
+    keyAgreementRelation.remove(methodId);
+  } else if (relation == VerificationMethodRelation.CapabilityInvocation) {
+    capabilityInvocationRelation.remove(methodId);
+  } else if (relation == VerificationMethodRelation.CapabilityDelegation) {
+    capabilityDelegationRelation.remove(methodId);
+  }
+}
+
+circuit assertVerificationMethodIsNotReferenced(id: Opaque<"string">): [] {
+  assert(!authenticationRelation.member(id), "Verification method still referenced in authenticationRelation");
+  assert(!assertionMethodRelation.member(id), "Verification method still referenced in assertionMethodRelation");
+  assert(!keyAgreementRelation.member(id), "Verification method still referenced in keyAgreementRelation");
+  assert(!capabilityInvocationRelation.member(id), "Verification method still referenced in capabilityInvocationRelation");
+  assert(!capabilityDelegationRelation.member(id), "Verification method still referenced in capabilityDelegationRelation");
+}
+
+// Constructor
+constructor() {
+  contractVersion = 1;
+  id = kernel.self();
+  active = true;
+  deactivated = false;
+  controllerPublicKey = disclose(controllerKey(localSecretKey()));
+
+  const timestamp = disclose(currentTimestamp());
+  created = timestamp;
+  updated = timestamp;
+}
+
+export circuit rotateControllerKey(newControllerPublicKey: Bytes<32>): [] {
+  assertControllerCanUpdate();
+  const disclosedNewControllerPublicKey = disclose(newControllerPublicKey);
+  assert(disclosedNewControllerPublicKey != controllerPublicKey, "New controller key matches current controller key");
+  controllerPublicKey = disclosedNewControllerPublicKey;
+
+  recordUpdate();
+}
+
+export circuit setAlsoKnownAs(value: Opaque<"string">, mutation: SetMutation): [] {
+  assertControllerCanUpdate();
+  const disclosedMutation = disclose(mutation);
+  assertSetMutationDefined(disclosedMutation);
+  const alias = disclose(value);
+  if (disclosedMutation == SetMutation.Insert) {
+    assert(!alsoKnownAs.member(alias), "alsoKnownAs value already exists");
+    alsoKnownAs.insert(alias);
+  } else if (disclosedMutation == SetMutation.Remove) {
+    assert(alsoKnownAs.member(alias), "alsoKnownAs value does not exist");
+    alsoKnownAs.remove(alias);
+  }
+
+  recordUpdate();
+}
+
+export circuit setVerificationMethod(
+  verificationMethod: VerificationMethod,
+  mutation: MapMutation
+): [] {
+  assertControllerCanUpdate();
+  const disclosedVerificationMethod = disclose(verificationMethod);
+  const disclosedMutation = disclose(mutation);
+  assertMapMutationDefined(disclosedMutation);
+  assertSupportedVerificationMethod(disclosedVerificationMethod);
+  if (disclosedMutation == MapMutation.Update) {
+    assert(verificationMethods.member(disclosedVerificationMethod.id), "Verification method does not exist");
+    verificationMethods.remove(disclosedVerificationMethod.id);
+  } else if (disclosedMutation == MapMutation.Insert) {
+    assert(!verificationMethodExists(disclosedVerificationMethod.id), "Verification method already exists");
+  }
+  verificationMethods.insert(disclosedVerificationMethod.id, disclosedVerificationMethod);
+
+  recordUpdate();
+}
+
+export circuit removeVerificationMethod(id: Opaque<"string">): [] {
+  assertControllerCanUpdate();
+  const disclosedId = disclose(id);
+  assert(verificationMethods.member(disclosedId), "Verification method does not exist");
+  assertVerificationMethodIsNotReferenced(disclosedId);
+  verificationMethods.remove(disclosedId);
+
+  recordUpdate();
+}
+
+export circuit setSchnorrJubjubVerificationMethod(
+  verificationMethod: SchnorrJubjubVerificationMethod,
+  mutation: MapMutation
+): [] {
+  assertControllerCanUpdate();
+  const disclosedVerificationMethod = disclose(verificationMethod);
+  const disclosedMutation = disclose(mutation);
+  assertMapMutationDefined(disclosedMutation);
+  if (disclosedMutation == MapMutation.Update) {
+    assert(schnorrJubjubVerificationMethods.member(disclosedVerificationMethod.id), "Verification method does not exist");
+    schnorrJubjubVerificationMethods.remove(disclosedVerificationMethod.id);
+  } else if (disclosedMutation == MapMutation.Insert) {
+    assert(!verificationMethodExists(disclosedVerificationMethod.id), "Verification method already exists");
+  }
+  schnorrJubjubVerificationMethods.insert(disclosedVerificationMethod.id, disclosedVerificationMethod);
+
+  recordUpdate();
+}
+
+export circuit removeSchnorrJubjubVerificationMethod(id: Opaque<"string">): [] {
+  assertControllerCanUpdate();
+  const disclosedId = disclose(id);
+  assert(schnorrJubjubVerificationMethods.member(disclosedId), "Verification method does not exist");
+  assertVerificationMethodIsNotReferenced(disclosedId);
+  schnorrJubjubVerificationMethods.remove(disclosedId);
+
+  recordUpdate();
+}
+
+// Intentionally non-mutating but exported as a transaction circuit: it proves a
+// private digest/signature against the current ledger-bound verification method.
+export circuit verifySchnorrJubjubDigestSignature(
+  methodId: Opaque<"string">,
+  digest: Vector<4, Field>,
+  signature: Schnorr_SchnorrSignature
+): [] {
+  assert(active, "Contract is not active");
+  const disclosedMethodId = disclose(methodId);
+  assert(schnorrJubjubVerificationMethods.member(disclosedMethodId), "Verification method does not exist");
+  const verificationMethod = schnorrJubjubVerificationMethods.lookup(disclosedMethodId);
+  Schnorr_schnorrVerifyDigest(digest, signature, verificationMethod.publicKey);
+}
+
+export circuit setVerificationMethodRelation(
+  relation: VerificationMethodRelation,
+  methodId: Opaque<"string">,
+  mutation: SetMutation
+): [] {
+  assertControllerCanUpdate();
+  const disclosedRelation = disclose(relation);
+  const disclosedMethodId = disclose(methodId);
+  const disclosedMutation = disclose(mutation);
+  assertSetMutationDefined(disclosedMutation);
+  assert(verificationMethodExists(disclosedMethodId), "Verification method does not exist");
+  assert(disclosedRelation != VerificationMethodRelation.Undefined, "Verification relation must be defined");
+  const currentPresent = verificationMethodRelationMember(disclosedRelation, disclosedMethodId);
+  if (disclosedMutation == SetMutation.Insert) {
+    assert(!currentPresent, "Verification method relation already exists");
+    insertVerificationMethodRelation(disclosedRelation, disclosedMethodId);
+  } else if (disclosedMutation == SetMutation.Remove) {
+    assert(currentPresent, "Verification method relation does not exist");
+    removeVerificationMethodRelationFromLedger(disclosedRelation, disclosedMethodId);
+  }
+
+  recordUpdate();
+}
+
+export circuit setService(service: Service, mutation: MapMutation): [] {
+  assertControllerCanUpdate();
+  const disclosedService = disclose(service);
+  const disclosedMutation = disclose(mutation);
+  assertMapMutationDefined(disclosedMutation);
+  if (disclosedMutation == MapMutation.Update) {
+    assert(services.member(disclosedService.id), "Service with a given id does not exist");
+    services.remove(disclosedService.id);
+  } else if (disclosedMutation == MapMutation.Insert) {
+    assert(!services.member(disclosedService.id), "Service with a given id already exists");
+  }
+  services.insert(disclosedService.id, disclosedService);
+
+  recordUpdate();
+}
+
+export circuit removeService(id: Opaque<"string">): [] {
+  assertControllerCanUpdate();
+  const disclosedId = disclose(id);
+  assert(services.member(disclosedId), "Service with a given id does not exist");
+  services.remove(disclosedId);
+
+  recordUpdate();
+}
+
+export circuit deactivate(): [] {
+  assertController();
+  assert(active, "DID is already inactive");
+  active = false;
+  deactivated = true;
+
+  recordUpdate();
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./controller-key.js";
+export * as DIDContract from "./managed/did/contract/index.js";
+export * from "./witnesses.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":"AAeA,cAAc,qBAAqB,CAAC;AACpC,OAAO,KAAK,WAAW,MAAM,iCAAiC,CAAC;AAC/D,cAAc,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,18 @@
+// This file is part of midnightntwrk/midnight-did.
+// Copyright (C) 2025 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.
+export * from "./controller-key.js";
+export * as DIDContract from "./managed/did/contract/index.js";
+export * from "./witnesses.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,mDAAmD;AACnD,yCAAyC;AACzC,sCAAsC;AACtC,kEAAkE;AAClE,mEAAmE;AACnE,0CAA0C;AAC1C,EAAE;AACF,6CAA6C;AAC7C,EAAE;AACF,sEAAsE;AACtE,oEAAoE;AACpE,2EAA2E;AAC3E,sEAAsE;AACtE,iCAAiC;AAEjC,cAAc,qBAAqB,CAAC;AACpC,OAAO,KAAK,WAAW,MAAM,iCAAiC,CAAC;AAC/D,cAAc,gBAAgB,CAAC","sourcesContent":["// This file is part of midnightntwrk/midnight-did.\n// Copyright (C) 2025 Midnight Foundation\n// SPDX-License-Identifier: Apache-2.0\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// You may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\nexport * from \"./controller-key.js\";\nexport * as DIDContract from \"./managed/did/contract/index.js\";\nexport * from \"./witnesses.js\";\n"]}