@semaphore-protocol/contracts 4.0.0-alpha → 4.0.0-alpha.2

package/README.md

@@ -10,7 +10,7 @@
         <img src="https://img.shields.io/badge/project-Semaphore-blue.svg?style=flat-square">
     </a>
     <a href="https://github.com/semaphore-protocol/semaphore/blob/main/LICENSE">
-        <img alt="Github license" src="https://img.shields.io/github/license/semaphore-protocol/semaphore.svg?style=flat-square">
+        <img alt="NPM license" src="https://img.shields.io/npm/l/%40semaphore-protocol%2Fcontracts?style=flat-square">
     </a>
     <a href="https://www.npmjs.com/package/@semaphore-protocol/contracts">
         <img alt="NPM version" src="https://img.shields.io/npm/v/@semaphore-protocol/contracts?style=flat-square" />

package/Semaphore.sol

@@ -102,36 +102,34 @@ contract Semaphore is ISemaphore, SemaphoreGroups {
 
     function validateProof(
         uint256 groupId,
-        uint256 merkleTreeDepth,
-        uint256 merkleTreeRoot,
-        uint256 nullifier,
-        uint256 message,
-        uint256 scope,
-        uint256[8] calldata proof
+        SemaphoreProof calldata proof
     ) external override onlyExistingGroup(groupId) {
-        if (groups[groupId].nullifiers[nullifier]) {
+        if (groups[groupId].nullifiers[proof.nullifier]) {
             revert Semaphore__YouAreUsingTheSameNullifierTwice();
         }
 
-        if (!verifyProof(groupId, merkleTreeDepth, merkleTreeRoot, nullifier, message, scope, proof)) {
+        if (!verifyProof(groupId, proof)) {
             revert Semaphore__InvalidProof();
         }
 
-        groups[groupId].nullifiers[nullifier] = true;
-
-        emit ProofValidated(groupId, merkleTreeDepth, merkleTreeRoot, nullifier, message, scope, proof);
+        groups[groupId].nullifiers[proof.nullifier] = true;
+
+        emit ProofValidated(
+            groupId,
+            proof.merkleTreeDepth,
+            proof.merkleTreeRoot,
+            proof.nullifier,
+            proof.message,
+            proof.scope,
+            proof.points
+        );
     }
 
     function verifyProof(
         uint256 groupId,
-        uint256 merkleTreeDepth,
-        uint256 merkleTreeRoot,
-        uint256 nullifier,
-        uint256 message,
-        uint256 scope,
-        uint256[8] calldata proof
+        SemaphoreProof calldata proof
     ) public view override onlyExistingGroup(groupId) returns (bool) {
-        if (merkleTreeDepth < 1 || merkleTreeDepth > 12) {
+        if (proof.merkleTreeDepth < 1 || proof.merkleTreeDepth > 12) {
             revert Semaphore__MerkleTreeDepthIsNotSupported();
         }
 
@@ -145,8 +143,8 @@ contract Semaphore is ISemaphore, SemaphoreGroups {
 
         // A proof could have used an old Merkle tree root.
         // https://github.com/semaphore-protocol/semaphore/issues/98
-        if (merkleTreeRoot != currentMerkleTreeRoot) {
-            uint256 merkleRootCreationDate = groups[groupId].merkleRootCreationDates[merkleTreeRoot];
+        if (proof.merkleTreeRoot != currentMerkleTreeRoot) {
+            uint256 merkleRootCreationDate = groups[groupId].merkleRootCreationDates[proof.merkleTreeRoot];
             uint256 merkleTreeDuration = groups[groupId].merkleTreeDuration;
 
             if (merkleRootCreationDate == 0) {
@@ -160,11 +158,11 @@ contract Semaphore is ISemaphore, SemaphoreGroups {
 
         return
             verifier.verifyProof(
-                [proof[0], proof[1]],
-                [[proof[2], proof[3]], [proof[4], proof[5]]],
-                [proof[6], proof[7]],
-                [merkleTreeRoot, nullifier, _hash(message), _hash(scope)],
-                merkleTreeDepth
+                [proof.points[0], proof.points[1]],
+                [[proof.points[2], proof.points[3]], [proof.points[4], proof.points[5]]],
+                [proof.points[6], proof.points[7]],
+                [proof.merkleTreeRoot, proof.nullifier, _hash(proof.message), _hash(proof.scope)],
+                proof.merkleTreeDepth
             );
     }
 

package/base/SemaphoreGroups.sol

@@ -123,6 +123,11 @@ abstract contract SemaphoreGroups is ISemaphoreGroups {
         emit MemberRemoved(groupId, index, identityCommitment, merkleTreeRoot);
     }
 
+    /// @dev See {ISemaphoreGroups-getGroupAdmin}.
+    function getGroupAdmin(uint256 groupId) public view virtual override returns (address) {
+        return admins[groupId];
+    }
+
     /// @dev See {ISemaphoreGroups-hasMember}.
     function hasMember(uint256 groupId, uint256 identityCommitment) public view virtual override returns (bool) {
         return merkleTrees[groupId]._has(identityCommitment);

package/interfaces/ISemaphore.sol

@@ -17,6 +17,16 @@ interface ISemaphore {
         mapping(uint256 => bool) nullifiers;
     }
 
+    /// It defines all the group parameters used by Semaphore.sol.
+    struct SemaphoreProof {
+        uint256 merkleTreeDepth;
+        uint256 merkleTreeRoot;
+        uint256 nullifier;
+        uint256 message;
+        uint256 scope;
+        uint256[8] points;
+    }
+
     /// @dev Emitted when the Merkle tree duration of a group is updated.
     /// @param groupId: Id of the group.
     /// @param oldMerkleTreeDuration: Old Merkle tree duration of the group.
@@ -34,7 +44,7 @@ interface ISemaphore {
     /// @param nullifier: Nullifier.
     /// @param message: Semaphore message.
     /// @param scope: Scope.
-    /// @param proof: Zero-knowledge proof.
+    /// @param points: Zero-knowledge points.
     event ProofValidated(
         uint256 indexed groupId,
         uint256 merkleTreeDepth,
@@ -42,7 +52,7 @@ interface ISemaphore {
         uint256 nullifier,
         uint256 message,
         uint256 indexed scope,
-        uint256[8] proof
+        uint256[8] points
     );
 
     /// @dev See {SemaphoreGroups-_createGroup}.
@@ -82,37 +92,11 @@ interface ISemaphore {
     /// @dev Saves the nullifier hash to avoid double signaling and emits an event
     /// if the zero-knowledge proof is valid.
     /// @param groupId: Id of the group.
-    /// @param merkleTreeDepth: Depth of the Merkle tree.
-    /// @param merkleTreeRoot: Root of the Merkle tree.
-    /// @param nullifier: Nullifier.
-    /// @param message: Semaphore message.
-    /// @param scope: Scope.
     /// @param proof: Zero-knowledge proof.
-    function validateProof(
-        uint256 groupId,
-        uint256 merkleTreeDepth,
-        uint256 merkleTreeRoot,
-        uint256 nullifier,
-        uint256 message,
-        uint256 scope,
-        uint256[8] calldata proof
-    ) external;
+    function validateProof(uint256 groupId, SemaphoreProof calldata proof) external;
 
     /// @dev Verifies a zero-knowledge proof by returning true or false.
     /// @param groupId: Id of the group.
-    /// @param merkleTreeDepth: Depth of the Merkle tree.
-    /// @param merkleTreeRoot: Root of the Merkle tree.
-    /// @param nullifier: Nullifier.
-    /// @param message: Semaphore message.
-    /// @param scope: Scope.
     /// @param proof: Zero-knowledge proof.
-    function verifyProof(
-        uint256 groupId,
-        uint256 merkleTreeDepth,
-        uint256 merkleTreeRoot,
-        uint256 nullifier,
-        uint256 message,
-        uint256 scope,
-        uint256[8] calldata proof
-    ) external view returns (bool);
+    function verifyProof(uint256 groupId, SemaphoreProof calldata proof) external view returns (bool);
 }

package/interfaces/ISemaphoreGroups.sol

@@ -57,6 +57,11 @@ interface ISemaphoreGroups {
     /// @param merkleTreeRoot: New root hash of the tree.
     event MemberRemoved(uint256 indexed groupId, uint256 index, uint256 identityCommitment, uint256 merkleTreeRoot);
 
+    /// @dev Returns the address of the group admin.
+    /// @param groupId: Id of the group.
+    /// @return Address of the group admin.
+    function getGroupAdmin(uint256 groupId) external view returns (address);
+
     /// @dev Returns true if a member exists in a group.
     /// @param groupId: Id of the group.
     /// @param identityCommitment: Identity commitment.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@semaphore-protocol/contracts",
-  "version": "4.0.0-alpha",
+  "version": "4.0.0-alpha.2",
   "description": "Semaphore contracts to manage groups and broadcast anonymous signals.",
   "license": "MIT",
   "files": [