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

package/README.md

@@ -28,8 +28,8 @@ sequenceDiagram
   participant Circuit as setVerificationMethod
   participant Ledger
 
-  Caller->>Circuit: VerificationMethod input + MapMutation
-  Circuit->>Circuit: controller auth check
+  Caller->>Circuit: VerificationMethod input + MapMutation + controller signature
+  Circuit->>Circuit: verify controller signature over contract id + version + operation + args
   Circuit->>Circuit: key type/curve constraints
   Circuit->>Circuit: duplicate/non-existence checks
   Circuit->>Ledger: insert/update state
@@ -57,7 +57,8 @@ stateDiagram-v2
 
 - Contract-level checks focus on enforceable on-chain invariants.
 - Some full DID conformance checks are intentionally handled at SDK/domain layers.
-- Controller public keys can be derived locally with `deriveControllerPublicKey(secretKey)`, matching the contract's `persistentHash<Vector<2, Bytes<32>>>` access-control commitment.
+- Controller public keys can be derived locally with `deriveControllerPublicKey(secretKey)` as Jubjub points. Controller-gated circuits verify wallet-local signatures over a domain-separated digest containing the DID contract id, current version, operation name, and operation arguments.
 - Set/update circuits use explicit `MapMutation` and `SetMutation` enums so the exported circuit surface stays small without boolean intent flags.
 - Jubjub signing helpers and reusable Schnorr transcript logic live in `@midnight-ntwrk/midnight-did-jubjub-schnorr`.
 - The DID contract exposes one ledger-bound SchnorrJubjub verification circuit. It accepts a verification method id, looks up the native `JubjubPoint` stored in `schnorrJubjubVerificationMethods`, and verifies against that ledger key rather than a caller-supplied public key.
+- Circuit `k`, rows, and managed artifact byte sizes are documented in `docs-site/compact/index.md`.

package/dist/controller-key.d.ts

@@ -1,2 +1,5 @@
-export declare const deriveControllerPublicKey: (secretKey: Uint8Array) => Uint8Array;
+import type { JubjubPoint } from "@midnight-ntwrk/compact-runtime";
+import { type JubjubDigest, type JubjubSchnorrSignature } from "@midnight-ntwrk/midnight-did-jubjub-schnorr";
+export declare const deriveControllerPublicKey: (secretKey: Uint8Array) => JubjubPoint;
+export declare const signControllerAuthorization: (secretKey: Uint8Array, digest: JubjubDigest) => JubjubSchnorrSignature;
 //# sourceMappingURL=controller-key.d.ts.map

package/dist/controller-key.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"controller-key.d.ts","sourceRoot":"","sources":["../src/controller-key.ts"],"names":[],"mappings":"AAiCA,eAAO,MAAM,yBAAyB,GACpC,WAAW,UAAU,KACpB,UAMF,CAAC"}
+{"version":3,"file":"controller-key.d.ts","sourceRoot":"","sources":["../src/controller-key.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,sBAAsB,EAE5B,MAAM,6CAA6C,CAAC;AAErD,eAAO,MAAM,yBAAyB,GACpC,WAAW,UAAU,KACpB,WAMF,CAAC;AAEF,eAAO,MAAM,2BAA2B,GACtC,WAAW,UAAU,EACrB,QAAQ,YAAY,KACnB,sBAAqE,CAAC"}

package/dist/controller-key.js

@@ -1,30 +1,12 @@
 // This file is part of midnightntwrk/midnight-did.
 // Copyright (C) 2025 Midnight Foundation
 // SPDX-License-Identifier: Apache-2.0
-import { CompactTypeBytes, CompactTypeVector, persistentHash } from "@midnight-ntwrk/compact-runtime";
-const bytes32 = new CompactTypeBytes(32);
-const controllerKeyInput = new CompactTypeVector(2, bytes32);
-const controllerKeyDomainLabel = "did:controller:pk";
-const padAscii32 = (value) => {
-    if (value.length > 32) {
-        throw new Error("DID controller key domain label exceeds 32 bytes");
-    }
-    const padded = new Uint8Array(32);
-    for (let index = 0; index < value.length; index += 1) {
-        const codePoint = value.charCodeAt(index);
-        if (codePoint > 0x7f) {
-            throw new Error("DID controller key domain label must be ASCII");
-        }
-        padded[index] = codePoint;
-    }
-    return padded;
-};
-// Mirrors the Compact `pad(32, "did:controller:pk")` controller-key domain.
-const controllerKeyDomain = padAscii32(controllerKeyDomainLabel);
+import { deriveJubjubPublicKeyFromSeed, signJubjubDigestFromSeed } from "@midnight-ntwrk/midnight-did-jubjub-schnorr";
 export const deriveControllerPublicKey = (secretKey) => {
     if (!(secretKey instanceof Uint8Array) || secretKey.length !== 32) {
         throw new Error("DID controller secret key must be 32 bytes");
     }
-    return persistentHash(controllerKeyInput, [controllerKeyDomain, secretKey]);
+    return deriveJubjubPublicKeyFromSeed(secretKey);
 };
+export const signControllerAuthorization = (secretKey, digest) => signJubjubDigestFromSeed(secretKey, digest);
 //# sourceMappingURL=controller-key.js.map

package/dist/controller-key.js.map

@@ -1 +1 @@
-{"version":3,"file":"controller-key.js","sourceRoot":"","sources":["../src/controller-key.ts"],"names":[],"mappings":"AAAA,mDAAmD;AACnD,yCAAyC;AACzC,sCAAsC;AAEtC,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,cAAc,EACf,MAAM,iCAAiC,CAAC;AAEzC,MAAM,OAAO,GAAG,IAAI,gBAAgB,CAAC,EAAE,CAAC,CAAC;AACzC,MAAM,kBAAkB,GAAG,IAAI,iBAAiB,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;AAC7D,MAAM,wBAAwB,GAAG,mBAAmB,CAAC;AAErD,MAAM,UAAU,GAAG,CAAC,KAAa,EAAc,EAAE;IAC/C,IAAI,KAAK,CAAC,MAAM,GAAG,EAAE,EAAE,CAAC;QACtB,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;IACtE,CAAC;IAED,MAAM,MAAM,GAAG,IAAI,UAAU,CAAC,EAAE,CAAC,CAAC;IAClC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;QACrD,MAAM,SAAS,GAAG,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QAC1C,IAAI,SAAS,GAAG,IAAI,EAAE,CAAC;YACrB,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;QACnE,CAAC;QACD,MAAM,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC;IAC5B,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AAEF,4EAA4E;AAC5E,MAAM,mBAAmB,GAAG,UAAU,CAAC,wBAAwB,CAAC,CAAC;AAEjE,MAAM,CAAC,MAAM,yBAAyB,GAAG,CACvC,SAAqB,EACT,EAAE;IACd,IAAI,CAAC,CAAC,SAAS,YAAY,UAAU,CAAC,IAAI,SAAS,CAAC,MAAM,KAAK,EAAE,EAAE,CAAC;QAClE,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;IAChE,CAAC;IAED,OAAO,cAAc,CAAC,kBAAkB,EAAE,CAAC,mBAAmB,EAAE,SAAS,CAAC,CAAC,CAAC;AAC9E,CAAC,CAAC","sourcesContent":["// This file is part of midnightntwrk/midnight-did.\n// Copyright (C) 2025 Midnight Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport {\n  CompactTypeBytes,\n  CompactTypeVector,\n  persistentHash\n} from \"@midnight-ntwrk/compact-runtime\";\n\nconst bytes32 = new CompactTypeBytes(32);\nconst controllerKeyInput = new CompactTypeVector(2, bytes32);\nconst controllerKeyDomainLabel = \"did:controller:pk\";\n\nconst padAscii32 = (value: string): Uint8Array => {\n  if (value.length > 32) {\n    throw new Error(\"DID controller key domain label exceeds 32 bytes\");\n  }\n\n  const padded = new Uint8Array(32);\n  for (let index = 0; index < value.length; index += 1) {\n    const codePoint = value.charCodeAt(index);\n    if (codePoint > 0x7f) {\n      throw new Error(\"DID controller key domain label must be ASCII\");\n    }\n    padded[index] = codePoint;\n  }\n  return padded;\n};\n\n// Mirrors the Compact `pad(32, \"did:controller:pk\")` controller-key domain.\nconst controllerKeyDomain = padAscii32(controllerKeyDomainLabel);\n\nexport const deriveControllerPublicKey = (\n  secretKey: Uint8Array\n): Uint8Array => {\n  if (!(secretKey instanceof Uint8Array) || secretKey.length !== 32) {\n    throw new Error(\"DID controller secret key must be 32 bytes\");\n  }\n\n  return persistentHash(controllerKeyInput, [controllerKeyDomain, secretKey]);\n};\n"]}
+{"version":3,"file":"controller-key.js","sourceRoot":"","sources":["../src/controller-key.ts"],"names":[],"mappings":"AAAA,mDAAmD;AACnD,yCAAyC;AACzC,sCAAsC;AAGtC,OAAO,EACL,6BAA6B,EAG7B,wBAAwB,EACzB,MAAM,6CAA6C,CAAC;AAErD,MAAM,CAAC,MAAM,yBAAyB,GAAG,CACvC,SAAqB,EACR,EAAE;IACf,IAAI,CAAC,CAAC,SAAS,YAAY,UAAU,CAAC,IAAI,SAAS,CAAC,MAAM,KAAK,EAAE,EAAE,CAAC;QAClE,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;IAChE,CAAC;IAED,OAAO,6BAA6B,CAAC,SAAS,CAAC,CAAC;AAClD,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,2BAA2B,GAAG,CACzC,SAAqB,EACrB,MAAoB,EACI,EAAE,CAAC,wBAAwB,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC","sourcesContent":["// This file is part of midnightntwrk/midnight-did.\n// Copyright (C) 2025 Midnight Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { JubjubPoint } from \"@midnight-ntwrk/compact-runtime\";\nimport {\n  deriveJubjubPublicKeyFromSeed,\n  type JubjubDigest,\n  type JubjubSchnorrSignature,\n  signJubjubDigestFromSeed\n} from \"@midnight-ntwrk/midnight-did-jubjub-schnorr\";\n\nexport const deriveControllerPublicKey = (\n  secretKey: Uint8Array\n): JubjubPoint => {\n  if (!(secretKey instanceof Uint8Array) || secretKey.length !== 32) {\n    throw new Error(\"DID controller secret key must be 32 bytes\");\n  }\n\n  return deriveJubjubPublicKeyFromSeed(secretKey);\n};\n\nexport const signControllerAuthorization = (\n  secretKey: Uint8Array,\n  digest: JubjubDigest\n): JubjubSchnorrSignature => signJubjubDigestFromSeed(secretKey, digest);\n"]}

package/dist/did.compact

@@ -22,7 +22,7 @@ export { Schnorr_SchnorrSignature };
 
 // Ledger state - Full DID Document
 export ledger contractVersion: Uint<32>;
-export ledger controllerPublicKey: Bytes<32>;
+export ledger controllerPublicKey: JubjubPoint;
 export ledger id: ContractAddress;
 export ledger alsoKnownAs: Set<Opaque<"string">>;
 export ledger version: Counter;
@@ -41,7 +41,7 @@ export ledger capabilityDelegationRelation: Set<Opaque<"string">>;
 export ledger services: Map<Opaque<"string">, Service>;
 
 // Witnesses
-witness localSecretKey(): Bytes<32>;
+witness localControllerPublicKey(): JubjubPoint;
 witness currentTimestamp(): Uint<64>;
 
 // Enums and Structs
@@ -107,16 +107,282 @@ 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]);
+struct ControllerAuthorizationDomain {
+  domain: Bytes<32>,
 }
 
-circuit assertController(): [] {
-  assert(controllerKey(localSecretKey()) == controllerPublicKey, "DID controller is allowed to update the DID only");
+struct ControllerAuthorizationState {
+  contractId: ContractAddress,
+  version: Uint<64>,
 }
 
-circuit assertControllerCanUpdate(): [] {
-  assertController();
+struct ControllerAuthorizationOperation {
+  name: Bytes<32>,
+}
+
+struct ControllerAuthorizationNoArgs {
+  domain: Bytes<32>,
+}
+
+struct RotateControllerKeyArgs {
+  publicKeyX: Field,
+  publicKeyY: Field,
+}
+
+struct SetAlsoKnownAsArgs {
+  value: Opaque<"string">,
+  mutation: SetMutation,
+}
+
+struct SetVerificationMethodArgs {
+  verificationMethod: VerificationMethod,
+  mutation: MapMutation,
+}
+
+struct RemoveVerificationMethodArgs {
+  id: Opaque<"string">,
+}
+
+struct SetSchnorrJubjubVerificationMethodArgs {
+  id: Opaque<"string">,
+  publicKeyX: Field,
+  publicKeyY: Field,
+  mutation: MapMutation,
+}
+
+struct RemoveSchnorrJubjubVerificationMethodArgs {
+  id: Opaque<"string">,
+}
+
+struct SetVerificationMethodRelationArgs {
+  relation: VerificationMethodRelation,
+  methodId: Opaque<"string">,
+  mutation: SetMutation,
+}
+
+struct SetServiceArgs {
+  service: Service,
+  mutation: MapMutation,
+}
+
+struct RemoveServiceArgs {
+  id: Opaque<"string">,
+}
+
+circuit controllerOperationHash(name: Bytes<32>): Field {
+  return transientHash<ControllerAuthorizationOperation>(
+    ControllerAuthorizationOperation { name: name }
+  );
+}
+
+circuit controllerNoArgsHash(): Field {
+  return transientHash<ControllerAuthorizationNoArgs>(
+    ControllerAuthorizationNoArgs { domain: pad(32, "no-args") }
+  );
+}
+
+export pure circuit controllerAuthorizationDigest(
+  contractId: ContractAddress,
+  expectedVersion: Uint<64>,
+  operationHash: Field,
+  argsHash: Field
+): Vector<4, Field> {
+  return [
+    transientHash<ControllerAuthorizationDomain>(
+      ControllerAuthorizationDomain { domain: pad(32, "midnight-did-ctrl-sig:v1") }
+    ),
+    transientHash<ControllerAuthorizationState>(
+      ControllerAuthorizationState {
+        contractId: contractId,
+        version: expectedVersion,
+      }
+    ),
+    operationHash,
+    argsHash,
+  ];
+}
+
+export pure circuit rotateControllerKeyAuthorizationDigest(
+  contractId: ContractAddress,
+  expectedVersion: Uint<64>,
+  newControllerPublicKey: JubjubPoint
+): Vector<4, Field> {
+  return controllerAuthorizationDigest(
+    contractId,
+    expectedVersion,
+    controllerOperationHash(pad(32, "rotateControllerKey")),
+    transientHash<RotateControllerKeyArgs>(
+      RotateControllerKeyArgs {
+        publicKeyX: jubjubPointX(newControllerPublicKey),
+        publicKeyY: jubjubPointY(newControllerPublicKey),
+      }
+    )
+  );
+}
+
+export pure circuit setAlsoKnownAsAuthorizationDigest(
+  contractId: ContractAddress,
+  expectedVersion: Uint<64>,
+  value: Opaque<"string">,
+  mutation: SetMutation
+): Vector<4, Field> {
+  return controllerAuthorizationDigest(
+    contractId,
+    expectedVersion,
+    controllerOperationHash(pad(32, "setAlsoKnownAs")),
+    transientHash<SetAlsoKnownAsArgs>(
+      SetAlsoKnownAsArgs { value: value, mutation: mutation }
+    )
+  );
+}
+
+export pure circuit setVerificationMethodAuthorizationDigest(
+  contractId: ContractAddress,
+  expectedVersion: Uint<64>,
+  verificationMethod: VerificationMethod,
+  mutation: MapMutation
+): Vector<4, Field> {
+  return controllerAuthorizationDigest(
+    contractId,
+    expectedVersion,
+    controllerOperationHash(pad(32, "setVerificationMethod")),
+    transientHash<SetVerificationMethodArgs>(
+      SetVerificationMethodArgs {
+        verificationMethod: verificationMethod,
+        mutation: mutation,
+      }
+    )
+  );
+}
+
+export pure circuit removeVerificationMethodAuthorizationDigest(
+  contractId: ContractAddress,
+  expectedVersion: Uint<64>,
+  id: Opaque<"string">
+): Vector<4, Field> {
+  return controllerAuthorizationDigest(
+    contractId,
+    expectedVersion,
+    controllerOperationHash(pad(32, "removeVerificationMethod")),
+    transientHash<RemoveVerificationMethodArgs>(
+      RemoveVerificationMethodArgs { id: id }
+    )
+  );
+}
+
+export pure circuit setSchnorrJubjubVerificationMethodAuthorizationDigest(
+  contractId: ContractAddress,
+  expectedVersion: Uint<64>,
+  verificationMethod: SchnorrJubjubVerificationMethod,
+  mutation: MapMutation
+): Vector<4, Field> {
+  return controllerAuthorizationDigest(
+    contractId,
+    expectedVersion,
+    controllerOperationHash(pad(32, "setSchnorrJubjubVM")),
+    transientHash<SetSchnorrJubjubVerificationMethodArgs>(
+      SetSchnorrJubjubVerificationMethodArgs {
+        id: verificationMethod.id,
+        publicKeyX: jubjubPointX(verificationMethod.publicKey),
+        publicKeyY: jubjubPointY(verificationMethod.publicKey),
+        mutation: mutation,
+      }
+    )
+  );
+}
+
+export pure circuit removeSchnorrJubjubVerificationMethodAuthorizationDigest(
+  contractId: ContractAddress,
+  expectedVersion: Uint<64>,
+  id: Opaque<"string">
+): Vector<4, Field> {
+  return controllerAuthorizationDigest(
+    contractId,
+    expectedVersion,
+    controllerOperationHash(pad(32, "removeSchnorrJubjubVM")),
+    transientHash<RemoveSchnorrJubjubVerificationMethodArgs>(
+      RemoveSchnorrJubjubVerificationMethodArgs { id: id }
+    )
+  );
+}
+
+export pure circuit setVerificationMethodRelationAuthorizationDigest(
+  contractId: ContractAddress,
+  expectedVersion: Uint<64>,
+  relation: VerificationMethodRelation,
+  methodId: Opaque<"string">,
+  mutation: SetMutation
+): Vector<4, Field> {
+  return controllerAuthorizationDigest(
+    contractId,
+    expectedVersion,
+    controllerOperationHash(pad(32, "setVMRelation")),
+    transientHash<SetVerificationMethodRelationArgs>(
+      SetVerificationMethodRelationArgs {
+        relation: relation,
+        methodId: methodId,
+        mutation: mutation,
+      }
+    )
+  );
+}
+
+export pure circuit setServiceAuthorizationDigest(
+  contractId: ContractAddress,
+  expectedVersion: Uint<64>,
+  service: Service,
+  mutation: MapMutation
+): Vector<4, Field> {
+  return controllerAuthorizationDigest(
+    contractId,
+    expectedVersion,
+    controllerOperationHash(pad(32, "setService")),
+    transientHash<SetServiceArgs>(
+      SetServiceArgs { service: service, mutation: mutation }
+    )
+  );
+}
+
+export pure circuit removeServiceAuthorizationDigest(
+  contractId: ContractAddress,
+  expectedVersion: Uint<64>,
+  id: Opaque<"string">
+): Vector<4, Field> {
+  return controllerAuthorizationDigest(
+    contractId,
+    expectedVersion,
+    controllerOperationHash(pad(32, "removeService")),
+    transientHash<RemoveServiceArgs>(RemoveServiceArgs { id: id })
+  );
+}
+
+export pure circuit deactivateAuthorizationDigest(
+  contractId: ContractAddress,
+  expectedVersion: Uint<64>
+): Vector<4, Field> {
+  return controllerAuthorizationDigest(
+    contractId,
+    expectedVersion,
+    controllerOperationHash(pad(32, "deactivate")),
+    controllerNoArgsHash()
+  );
+}
+
+circuit assertController(
+  signature: Schnorr_SchnorrSignature,
+  expectedVersion: Uint<64>,
+  digest: Vector<4, Field>
+): [] {
+  assert(disclose(expectedVersion) == version, "Controller authorization version is stale");
+  Schnorr_schnorrVerifyDigest(digest, signature, controllerPublicKey);
+}
+
+circuit assertControllerCanUpdate(
+  signature: Schnorr_SchnorrSignature,
+  expectedVersion: Uint<64>,
+  digest: Vector<4, Field>
+): [] {
+  assertController(signature, expectedVersion, digest);
   assert(active, "Contract is not active");
 }
 
@@ -211,27 +477,44 @@ constructor() {
   id = kernel.self();
   active = true;
   deactivated = false;
-  controllerPublicKey = disclose(controllerKey(localSecretKey()));
+  controllerPublicKey = disclose(localControllerPublicKey());
 
   const timestamp = disclose(currentTimestamp());
   created = timestamp;
   updated = timestamp;
 }
 
-export circuit rotateControllerKey(newControllerPublicKey: Bytes<32>): [] {
-  assertControllerCanUpdate();
+export circuit rotateControllerKey(
+  newControllerPublicKey: JubjubPoint,
+  controllerSignature: Schnorr_SchnorrSignature,
+  expectedVersion: Uint<64>
+): [] {
   const disclosedNewControllerPublicKey = disclose(newControllerPublicKey);
+  assertControllerCanUpdate(
+    controllerSignature,
+    expectedVersion,
+    rotateControllerKeyAuthorizationDigest(id, disclose(expectedVersion), disclosedNewControllerPublicKey)
+  );
   assert(disclosedNewControllerPublicKey != controllerPublicKey, "New controller key matches current controller key");
   controllerPublicKey = disclosedNewControllerPublicKey;
 
   recordUpdate();
 }
 
-export circuit setAlsoKnownAs(value: Opaque<"string">, mutation: SetMutation): [] {
-  assertControllerCanUpdate();
+export circuit setAlsoKnownAs(
+  value: Opaque<"string">,
+  mutation: SetMutation,
+  controllerSignature: Schnorr_SchnorrSignature,
+  expectedVersion: Uint<64>
+): [] {
   const disclosedMutation = disclose(mutation);
-  assertSetMutationDefined(disclosedMutation);
   const alias = disclose(value);
+  assertControllerCanUpdate(
+    controllerSignature,
+    expectedVersion,
+    setAlsoKnownAsAuthorizationDigest(id, disclose(expectedVersion), alias, disclosedMutation)
+  );
+  assertSetMutationDefined(disclosedMutation);
   if (disclosedMutation == SetMutation.Insert) {
     assert(!alsoKnownAs.member(alias), "alsoKnownAs value already exists");
     alsoKnownAs.insert(alias);
@@ -245,11 +528,22 @@ export circuit setAlsoKnownAs(value: Opaque<"string">, mutation: SetMutation): [
 
 export circuit setVerificationMethod(
   verificationMethod: VerificationMethod,
-  mutation: MapMutation
+  mutation: MapMutation,
+  controllerSignature: Schnorr_SchnorrSignature,
+  expectedVersion: Uint<64>
 ): [] {
-  assertControllerCanUpdate();
   const disclosedVerificationMethod = disclose(verificationMethod);
   const disclosedMutation = disclose(mutation);
+  assertControllerCanUpdate(
+    controllerSignature,
+    expectedVersion,
+    setVerificationMethodAuthorizationDigest(
+      id,
+      disclose(expectedVersion),
+      disclosedVerificationMethod,
+      disclosedMutation
+    )
+  );
   assertMapMutationDefined(disclosedMutation);
   assertSupportedVerificationMethod(disclosedVerificationMethod);
   if (disclosedMutation == MapMutation.Update) {
@@ -263,9 +557,17 @@ export circuit setVerificationMethod(
   recordUpdate();
 }
 
-export circuit removeVerificationMethod(id: Opaque<"string">): [] {
-  assertControllerCanUpdate();
-  const disclosedId = disclose(id);
+export circuit removeVerificationMethod(
+  methodId: Opaque<"string">,
+  controllerSignature: Schnorr_SchnorrSignature,
+  expectedVersion: Uint<64>
+): [] {
+  const disclosedId = disclose(methodId);
+  assertControllerCanUpdate(
+    controllerSignature,
+    expectedVersion,
+    removeVerificationMethodAuthorizationDigest(id, disclose(expectedVersion), disclosedId)
+  );
   assert(verificationMethods.member(disclosedId), "Verification method does not exist");
   assertVerificationMethodIsNotReferenced(disclosedId);
   verificationMethods.remove(disclosedId);
@@ -275,11 +577,22 @@ export circuit removeVerificationMethod(id: Opaque<"string">): [] {
 
 export circuit setSchnorrJubjubVerificationMethod(
   verificationMethod: SchnorrJubjubVerificationMethod,
-  mutation: MapMutation
+  mutation: MapMutation,
+  controllerSignature: Schnorr_SchnorrSignature,
+  expectedVersion: Uint<64>
 ): [] {
-  assertControllerCanUpdate();
   const disclosedVerificationMethod = disclose(verificationMethod);
   const disclosedMutation = disclose(mutation);
+  assertControllerCanUpdate(
+    controllerSignature,
+    expectedVersion,
+    setSchnorrJubjubVerificationMethodAuthorizationDigest(
+      id,
+      disclose(expectedVersion),
+      disclosedVerificationMethod,
+      disclosedMutation
+    )
+  );
   assertMapMutationDefined(disclosedMutation);
   if (disclosedMutation == MapMutation.Update) {
     assert(schnorrJubjubVerificationMethods.member(disclosedVerificationMethod.id), "Verification method does not exist");
@@ -292,9 +605,21 @@ export circuit setSchnorrJubjubVerificationMethod(
   recordUpdate();
 }
 
-export circuit removeSchnorrJubjubVerificationMethod(id: Opaque<"string">): [] {
-  assertControllerCanUpdate();
-  const disclosedId = disclose(id);
+export circuit removeSchnorrJubjubVerificationMethod(
+  methodId: Opaque<"string">,
+  controllerSignature: Schnorr_SchnorrSignature,
+  expectedVersion: Uint<64>
+): [] {
+  const disclosedId = disclose(methodId);
+  assertControllerCanUpdate(
+    controllerSignature,
+    expectedVersion,
+    removeSchnorrJubjubVerificationMethodAuthorizationDigest(
+      id,
+      disclose(expectedVersion),
+      disclosedId
+    )
+  );
   assert(schnorrJubjubVerificationMethods.member(disclosedId), "Verification method does not exist");
   assertVerificationMethodIsNotReferenced(disclosedId);
   schnorrJubjubVerificationMethods.remove(disclosedId);
@@ -319,12 +644,24 @@ export circuit verifySchnorrJubjubDigestSignature(
 export circuit setVerificationMethodRelation(
   relation: VerificationMethodRelation,
   methodId: Opaque<"string">,
-  mutation: SetMutation
+  mutation: SetMutation,
+  controllerSignature: Schnorr_SchnorrSignature,
+  expectedVersion: Uint<64>
 ): [] {
-  assertControllerCanUpdate();
   const disclosedRelation = disclose(relation);
   const disclosedMethodId = disclose(methodId);
   const disclosedMutation = disclose(mutation);
+  assertControllerCanUpdate(
+    controllerSignature,
+    expectedVersion,
+    setVerificationMethodRelationAuthorizationDigest(
+      id,
+      disclose(expectedVersion),
+      disclosedRelation,
+      disclosedMethodId,
+      disclosedMutation
+    )
+  );
   assertSetMutationDefined(disclosedMutation);
   assert(verificationMethodExists(disclosedMethodId), "Verification method does not exist");
   assert(disclosedRelation != VerificationMethodRelation.Undefined, "Verification relation must be defined");
@@ -340,10 +677,19 @@ export circuit setVerificationMethodRelation(
   recordUpdate();
 }
 
-export circuit setService(service: Service, mutation: MapMutation): [] {
-  assertControllerCanUpdate();
+export circuit setService(
+  service: Service,
+  mutation: MapMutation,
+  controllerSignature: Schnorr_SchnorrSignature,
+  expectedVersion: Uint<64>
+): [] {
   const disclosedService = disclose(service);
   const disclosedMutation = disclose(mutation);
+  assertControllerCanUpdate(
+    controllerSignature,
+    expectedVersion,
+    setServiceAuthorizationDigest(id, disclose(expectedVersion), disclosedService, disclosedMutation)
+  );
   assertMapMutationDefined(disclosedMutation);
   if (disclosedMutation == MapMutation.Update) {
     assert(services.member(disclosedService.id), "Service with a given id does not exist");
@@ -356,17 +702,32 @@ export circuit setService(service: Service, mutation: MapMutation): [] {
   recordUpdate();
 }
 
-export circuit removeService(id: Opaque<"string">): [] {
-  assertControllerCanUpdate();
-  const disclosedId = disclose(id);
+export circuit removeService(
+  serviceId: Opaque<"string">,
+  controllerSignature: Schnorr_SchnorrSignature,
+  expectedVersion: Uint<64>
+): [] {
+  const disclosedId = disclose(serviceId);
+  assertControllerCanUpdate(
+    controllerSignature,
+    expectedVersion,
+    removeServiceAuthorizationDigest(id, disclose(expectedVersion), disclosedId)
+  );
   assert(services.member(disclosedId), "Service with a given id does not exist");
   services.remove(disclosedId);
 
   recordUpdate();
 }
 
-export circuit deactivate(): [] {
-  assertController();
+export circuit deactivate(
+  controllerSignature: Schnorr_SchnorrSignature,
+  expectedVersion: Uint<64>
+): [] {
+  assertController(
+    controllerSignature,
+    expectedVersion,
+    deactivateAuthorizationDigest(id, disclose(expectedVersion))
+  );
   assert(active, "DID is already inactive");
   active = false;
   deactivated = true;