@semaphore-protocol/contracts 4.0.0-beta.1 → 4.0.0-beta.3

package/Semaphore.sol

@@ -4,6 +4,7 @@ pragma solidity 0.8.23;
 import {ISemaphore} from "./interfaces/ISemaphore.sol";
 import {ISemaphoreVerifier} from "./interfaces/ISemaphoreVerifier.sol";
 import {SemaphoreGroups} from "./base/SemaphoreGroups.sol";
+import {MIN_DEPTH, MAX_DEPTH} from "./base/Constants.sol";
 
 /// @title Semaphore
 /// @dev This contract uses the Semaphore base contracts to provide a complete service
@@ -17,6 +18,9 @@ contract Semaphore is ISemaphore, SemaphoreGroups {
     /// @dev Gets a group id and returns the group parameters.
     mapping(uint256 => Group) public groups;
 
+    /// @dev Counter to assign an incremental id to the groups.
+    uint256 public groupCounter;
+
     /// @dev Initializes the Semaphore verifier used to verify the user's ZK proofs.
     /// @param _verifier: Semaphore verifier addresse.
     constructor(ISemaphoreVerifier _verifier) {
@@ -24,14 +28,24 @@ contract Semaphore is ISemaphore, SemaphoreGroups {
     }
 
     /// @dev See {SemaphoreGroups-_createGroup}.
-    function createGroup(uint256 groupId, address admin) external override {
+    function createGroup() external override returns (uint256 groupId) {
+        groupId = groupCounter++;
+        _createGroup(groupId, msg.sender);
+
+        groups[groupId].merkleTreeDuration = 1 hours;
+    }
+
+    /// @dev See {SemaphoreGroups-_createGroup}.
+    function createGroup(address admin) external override returns (uint256 groupId) {
+        groupId = groupCounter++;
         _createGroup(groupId, admin);
 
         groups[groupId].merkleTreeDuration = 1 hours;
     }
 
     /// @dev See {ISemaphore-createGroup}.
-    function createGroup(uint256 groupId, address admin, uint256 merkleTreeDuration) external override {
+    function createGroup(address admin, uint256 merkleTreeDuration) external override returns (uint256 groupId) {
+        groupId = groupCounter++;
         _createGroup(groupId, admin);
 
         groups[groupId].merkleTreeDuration = merkleTreeDuration;
@@ -46,7 +60,7 @@ contract Semaphore is ISemaphore, SemaphoreGroups {
     function updateGroupMerkleTreeDuration(
         uint256 groupId,
         uint256 newMerkleTreeDuration
-    ) external override onlyExistingGroup(groupId) onlyGroupAdmin(groupId) {
+    ) external override onlyGroupAdmin(groupId) {
         uint256 oldMerkleTreeDuration = groups[groupId].merkleTreeDuration;
 
         groups[groupId].merkleTreeDuration = newMerkleTreeDuration;
@@ -56,18 +70,14 @@ contract Semaphore is ISemaphore, SemaphoreGroups {
 
     /// @dev See {SemaphoreGroups-_addMember}.
     function addMember(uint256 groupId, uint256 identityCommitment) external override {
-        _addMember(groupId, identityCommitment);
-
-        uint256 merkleTreeRoot = getMerkleTreeRoot(groupId);
+        uint256 merkleTreeRoot = _addMember(groupId, identityCommitment);
 
         groups[groupId].merkleRootCreationDates[merkleTreeRoot] = block.timestamp;
     }
 
     /// @dev See {SemaphoreGroups-_addMembers}.
     function addMembers(uint256 groupId, uint256[] calldata identityCommitments) external override {
-        _addMembers(groupId, identityCommitments);
-
-        uint256 merkleTreeRoot = getMerkleTreeRoot(groupId);
+        uint256 merkleTreeRoot = _addMembers(groupId, identityCommitments);
 
         groups[groupId].merkleRootCreationDates[merkleTreeRoot] = block.timestamp;
     }
@@ -79,9 +89,7 @@ contract Semaphore is ISemaphore, SemaphoreGroups {
         uint256 newIdentityCommitment,
         uint256[] calldata merkleProofSiblings
     ) external override {
-        _updateMember(groupId, identityCommitment, newIdentityCommitment, merkleProofSiblings);
-
-        uint256 merkleTreeRoot = getMerkleTreeRoot(groupId);
+        uint256 merkleTreeRoot = _updateMember(groupId, identityCommitment, newIdentityCommitment, merkleProofSiblings);
 
         groups[groupId].merkleRootCreationDates[merkleTreeRoot] = block.timestamp;
     }
@@ -92,18 +100,13 @@ contract Semaphore is ISemaphore, SemaphoreGroups {
         uint256 identityCommitment,
         uint256[] calldata merkleProofSiblings
     ) external override {
-        _removeMember(groupId, identityCommitment, merkleProofSiblings);
-
-        uint256 merkleTreeRoot = getMerkleTreeRoot(groupId);
+        uint256 merkleTreeRoot = _removeMember(groupId, identityCommitment, merkleProofSiblings);
 
         groups[groupId].merkleRootCreationDates[merkleTreeRoot] = block.timestamp;
     }
 
     /// @dev See {ISemaphore-validateProof}.
-    function validateProof(
-        uint256 groupId,
-        SemaphoreProof calldata proof
-    ) external override onlyExistingGroup(groupId) {
+    function validateProof(uint256 groupId, SemaphoreProof calldata proof) external override {
         // The function will revert if the nullifier that is part of the proof,
         // was already used inside the group with id groupId.
         if (groups[groupId].nullifiers[proof.nullifier]) {
@@ -136,7 +139,7 @@ contract Semaphore is ISemaphore, SemaphoreGroups {
         SemaphoreProof calldata proof
     ) public view override onlyExistingGroup(groupId) returns (bool) {
         // The function will revert if the Merkle tree depth is not supported.
-        if (proof.merkleTreeDepth < 1 || proof.merkleTreeDepth > 12) {
+        if (proof.merkleTreeDepth < MIN_DEPTH || proof.merkleTreeDepth > MAX_DEPTH) {
             revert Semaphore__MerkleTreeDepthIsNotSupported();
         }
 

package/base/Constants.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+/// @dev Minimum supported tree depth.
+uint8 constant MIN_DEPTH = 1;
+
+/// @dev Maximum supported tree depth.
+uint8 constant MAX_DEPTH = 12;

package/base/SemaphoreGroups.sol

@@ -42,10 +42,6 @@ abstract contract SemaphoreGroups is ISemaphoreGroups {
     /// @param groupId: Id of the group.
     /// @param admin: Admin of the group.
     function _createGroup(uint256 groupId, address admin) internal virtual {
-        if (admins[groupId] != address(0)) {
-            revert Semaphore__GroupAlreadyExists();
-        }
-
         admins[groupId] = admin;
 
         emit GroupCreated(groupId);
@@ -55,10 +51,7 @@ abstract contract SemaphoreGroups is ISemaphoreGroups {
     /// @dev Updates the group admin.
     /// @param groupId: Id of the group.
     /// @param newAdmin: New admin of the group.
-    function _updateGroupAdmin(
-        uint256 groupId,
-        address newAdmin
-    ) internal virtual onlyExistingGroup(groupId) onlyGroupAdmin(groupId) {
+    function _updateGroupAdmin(uint256 groupId, address newAdmin) internal virtual onlyGroupAdmin(groupId) {
         admins[groupId] = newAdmin;
 
         emit GroupAdminUpdated(groupId, msg.sender, newAdmin);
@@ -67,12 +60,13 @@ abstract contract SemaphoreGroups is ISemaphoreGroups {
     /// @dev Adds an identity commitment to an existing group.
     /// @param groupId: Id of the group.
     /// @param identityCommitment: New identity commitment.
+    /// @return merkleTreeRoot New root hash of the tree.
     function _addMember(
         uint256 groupId,
         uint256 identityCommitment
-    ) internal virtual onlyExistingGroup(groupId) onlyGroupAdmin(groupId) {
+    ) internal virtual onlyGroupAdmin(groupId) returns (uint256 merkleTreeRoot) {
         uint256 index = getMerkleTreeSize(groupId);
-        uint256 merkleTreeRoot = merkleTrees[groupId]._insert(identityCommitment);
+        merkleTreeRoot = merkleTrees[groupId]._insert(identityCommitment);
 
         emit MemberAdded(groupId, index, identityCommitment, merkleTreeRoot);
     }
@@ -80,9 +74,13 @@ abstract contract SemaphoreGroups is ISemaphoreGroups {
     /// @dev Adds new members to an existing group.
     /// @param groupId: Id of the group.
     /// @param identityCommitments: New identity commitments.
-    function _addMembers(uint256 groupId, uint256[] calldata identityCommitments) internal virtual {
+    /// @return merkleTreeRoot New root hash of the tree.
+    function _addMembers(
+        uint256 groupId,
+        uint256[] calldata identityCommitments
+    ) internal virtual onlyGroupAdmin(groupId) returns (uint256 merkleTreeRoot) {
         uint256 startIndex = getMerkleTreeSize(groupId);
-        uint256 merkleTreeRoot = merkleTrees[groupId]._insertMany(identityCommitments);
+        merkleTreeRoot = merkleTrees[groupId]._insertMany(identityCommitments);
 
         emit MembersAdded(groupId, startIndex, identityCommitments, merkleTreeRoot);
     }
@@ -93,14 +91,15 @@ abstract contract SemaphoreGroups is ISemaphoreGroups {
     /// @param oldIdentityCommitment: Existing identity commitment to be updated.
     /// @param newIdentityCommitment: New identity commitment.
     /// @param merkleProofSiblings: Array of the sibling nodes of the proof of membership.
+    /// @return merkleTreeRoot New root hash of the tree.
     function _updateMember(
         uint256 groupId,
         uint256 oldIdentityCommitment,
         uint256 newIdentityCommitment,
         uint256[] calldata merkleProofSiblings
-    ) internal virtual onlyExistingGroup(groupId) onlyGroupAdmin(groupId) {
+    ) internal virtual onlyGroupAdmin(groupId) returns (uint256 merkleTreeRoot) {
         uint256 index = merkleTrees[groupId]._indexOf(oldIdentityCommitment);
-        uint256 merkleTreeRoot = merkleTrees[groupId]._update(
+        merkleTreeRoot = merkleTrees[groupId]._update(
             oldIdentityCommitment,
             newIdentityCommitment,
             merkleProofSiblings
@@ -114,14 +113,15 @@ abstract contract SemaphoreGroups is ISemaphoreGroups {
     /// @param groupId: Id of the group.
     /// @param identityCommitment: Existing identity commitment to be removed.
     /// @param merkleProofSiblings: Array of the sibling nodes of the proof of membership.
+    /// @return merkleTreeRoot New root hash of the tree.
     function _removeMember(
         uint256 groupId,
         uint256 identityCommitment,
         uint256[] calldata merkleProofSiblings
-    ) internal virtual onlyExistingGroup(groupId) onlyGroupAdmin(groupId) {
+    ) internal virtual onlyGroupAdmin(groupId) returns (uint256 merkleTreeRoot) {
         uint256 index = merkleTrees[groupId]._indexOf(identityCommitment);
 
-        uint256 merkleTreeRoot = merkleTrees[groupId]._remove(identityCommitment, merkleProofSiblings);
+        merkleTreeRoot = merkleTrees[groupId]._remove(identityCommitment, merkleProofSiblings);
 
         emit MemberRemoved(groupId, index, identityCommitment, merkleTreeRoot);
     }

package/base/SemaphoreVerifier.sol

@@ -3,6 +3,8 @@
 
 pragma solidity 0.8.23;
 
+import {MAX_DEPTH} from "./Constants.sol";
+
 contract SemaphoreVerifier {
     // Scalar field size
     uint256 constant r = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
@@ -22,12 +24,12 @@ contract SemaphoreVerifier {
     uint256 constant gammay2 = 8495653923123431417604973247489272438418190587263600148770280649306958101930;
 
     // TODO: Add more variables when Semaphore supports tree depth > 12.
-    // Right now Semaphore supports tree depth 1-12.
+    // Right now Semaphore supports tree depth 1-12. It will support up to 32.
 
     // Verification Key points.
     // These values are taken from the verification key json file generated with snarkjs.
     // It allows to use the same verifier to verify proofs for all the tree depths supported by Semaphore.
-    uint256[14][12] VK_POINTS = [
+    uint256[14][MAX_DEPTH] VK_POINTS = [
         [
             563562783592406106461234396505774794044312891062077216951605541624542949349,
             16293410697967515504861065986355060225819302510590370360517024529684437085892,

package/interfaces/ISemaphore.sol

@@ -56,13 +56,16 @@ interface ISemaphore {
     );
 
     /// @dev See {SemaphoreGroups-_createGroup}.
-    function createGroup(uint256 groupId, address admin) external;
+    function createGroup() external returns (uint256);
+
+    /// @dev See {SemaphoreGroups-_createGroup}.
+    function createGroup(address admin) external returns (uint256);
 
     /// @dev It creates a group with a custom Merkle tree duration.
-    /// @param groupId: Id of the group.
     /// @param admin: Admin of the group. It can be an Ethereum account or a smart contract.
     /// @param merkleTreeDuration: Merkle tree duration.
-    function createGroup(uint256 groupId, address admin, uint256 merkleTreeDuration) external;
+    /// @return Id of the group.
+    function createGroup(address admin, uint256 merkleTreeDuration) external returns (uint256);
 
     /// @dev See {SemaphoreGroups-_updateGroupAdmin}.
     function updateGroupAdmin(uint256 groupId, address newAdmin) external;

package/interfaces/ISemaphoreGroups.sol

@@ -4,7 +4,6 @@ pragma solidity 0.8.23;
 /// @title SemaphoreGroups contract interface.
 interface ISemaphoreGroups {
     error Semaphore__GroupDoesNotExist();
-    error Semaphore__GroupAlreadyExists();
     error Semaphore__CallerIsNotTheGroupAdmin();
 
     /// @dev Event emitted when a new group is created.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@semaphore-protocol/contracts",
-  "version": "4.0.0-beta.1",
+  "version": "4.0.0-beta.3",
   "description": "Semaphore contracts to manage groups and broadcast anonymous signals.",
   "license": "MIT",
   "files": [
@@ -30,6 +30,6 @@
     "access": "public"
   },
   "dependencies": {
-    "@zk-kit/imt.sol": "2.0.0-beta.5"
+    "@zk-kit/imt.sol": "2.0.0-beta.8"
   }
 }