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

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/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/package.json

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