@semaphore-protocol/contracts 4.14.2 → 4.14.4

package/Semaphore.sol

@@ -10,8 +10,8 @@ import {MIN_DEPTH, MAX_DEPTH} from "./base/Constants.sol";
 /// @dev This contract uses the Semaphore base contracts to provide a complete service
 /// to allow admins to create and manage groups and their members to verify Semaphore proofs
 /// Group admins can add, update or remove group members, and can be an Ethereum account or a smart contract.
-/// This contract also assigns each new Merkle tree generated with a new root a duration (or an expiry)
-/// within which the proofs generated with that root can be validated.
+/// This contract also gives each root a duration (or an expiry) within which the proofs generated with
+/// that root can still be validated after the root has been replaced by a newer one.
 contract Semaphore is ISemaphore, SemaphoreGroups {
     ISemaphoreVerifier public verifier;
 
@@ -76,16 +76,26 @@ contract Semaphore is ISemaphore, SemaphoreGroups {
 
     /// @dev See {SemaphoreGroups-_addMember}.
     function addMember(uint256 groupId, uint256 identityCommitment) external override {
-        uint256 merkleTreeRoot = _addMember(groupId, identityCommitment);
+        uint256 oldMerkleTreeRoot = getMerkleTreeRoot(groupId);
 
-        groups[groupId].merkleRootCreationDates[merkleTreeRoot] = block.timestamp;
+        _addMember(groupId, identityCommitment);
+
+        // 0 marks a root as unknown and is also the root of a group with no members,
+        // so it is never stored.
+        if (oldMerkleTreeRoot != 0) {
+            groups[groupId].merkleRootSupersededDates[oldMerkleTreeRoot] = block.timestamp;
+        }
     }
 
     /// @dev See {SemaphoreGroups-_addMembers}.
     function addMembers(uint256 groupId, uint256[] calldata identityCommitments) external override {
-        uint256 merkleTreeRoot = _addMembers(groupId, identityCommitments);
+        uint256 oldMerkleTreeRoot = getMerkleTreeRoot(groupId);
+
+        _addMembers(groupId, identityCommitments);
 
-        groups[groupId].merkleRootCreationDates[merkleTreeRoot] = block.timestamp;
+        if (oldMerkleTreeRoot != 0) {
+            groups[groupId].merkleRootSupersededDates[oldMerkleTreeRoot] = block.timestamp;
+        }
     }
 
     /// @dev See {SemaphoreGroups-_updateMember}.
@@ -95,9 +105,12 @@ contract Semaphore is ISemaphore, SemaphoreGroups {
         uint256 newIdentityCommitment,
         uint256[] calldata merkleProofSiblings
     ) external override {
-        uint256 merkleTreeRoot = _updateMember(groupId, identityCommitment, newIdentityCommitment, merkleProofSiblings);
+        uint256 oldMerkleTreeRoot = getMerkleTreeRoot(groupId);
+
+        _updateMember(groupId, identityCommitment, newIdentityCommitment, merkleProofSiblings);
 
-        groups[groupId].merkleRootCreationDates[merkleTreeRoot] = block.timestamp;
+        // A group whose root is 0 has no members to update, so the old root is never 0.
+        groups[groupId].merkleRootSupersededDates[oldMerkleTreeRoot] = block.timestamp;
     }
 
     /// @dev See {SemaphoreGroups-_removeMember}.
@@ -106,9 +119,12 @@ contract Semaphore is ISemaphore, SemaphoreGroups {
         uint256 identityCommitment,
         uint256[] calldata merkleProofSiblings
     ) external override {
-        uint256 merkleTreeRoot = _removeMember(groupId, identityCommitment, merkleProofSiblings);
+        uint256 oldMerkleTreeRoot = getMerkleTreeRoot(groupId);
+
+        _removeMember(groupId, identityCommitment, merkleProofSiblings);
 
-        groups[groupId].merkleRootCreationDates[merkleTreeRoot] = block.timestamp;
+        // A group whose root is 0 has no members to remove, so the old root is never 0.
+        groups[groupId].merkleRootSupersededDates[oldMerkleTreeRoot] = block.timestamp;
     }
 
     /// @dev See {ISemaphore-validateProof}.
@@ -164,14 +180,19 @@ contract Semaphore is ISemaphore, SemaphoreGroups {
         // A proof could have used an old Merkle tree root.
         // https://github.com/semaphore-protocol/semaphore/issues/98
         if (proof.merkleTreeRoot != currentMerkleTreeRoot) {
-            uint256 merkleRootCreationDate = groups[groupId].merkleRootCreationDates[proof.merkleTreeRoot];
+            // An old root is accepted until merkleTreeDuration has passed since it was replaced,
+            // giving proofs made while it was still the current root time to arrive. The end of
+            // the window is exclusive, so a duration of 0 rejects every old root.
+            uint256 merkleRootSupersededDate = groups[groupId].merkleRootSupersededDates[proof.merkleTreeRoot];
             uint256 merkleTreeDuration = groups[groupId].merkleTreeDuration;
 
-            if (merkleRootCreationDate == 0) {
+            if (merkleRootSupersededDate == 0) {
                 revert Semaphore__MerkleTreeRootIsNotPartOfTheGroup();
             }
 
-            if (block.timestamp > merkleRootCreationDate + merkleTreeDuration) {
+            // merkleRootSupersededDate is never in the future, so this cannot underflow
+            // and the check stays within uint256 for any duration.
+            if (block.timestamp - merkleRootSupersededDate >= merkleTreeDuration) {
                 revert Semaphore__MerkleTreeRootIsExpired();
             }
         }

package/interfaces/ISemaphore.sol

@@ -13,7 +13,10 @@ interface ISemaphore {
     /// It defines all the group parameters used by Semaphore.sol.
     struct Group {
         uint256 merkleTreeDuration;
-        mapping(uint256 => uint256) merkleRootCreationDates;
+        /// @dev Gets a Merkle root and returns the time at which it was replaced, which is when
+        /// its expiration starts. The current root is not in this mapping, as its expiration
+        /// has not started yet.
+        mapping(uint256 => uint256) merkleRootSupersededDates;
         mapping(uint256 => bool) nullifiers;
     }
 
@@ -78,6 +81,10 @@ interface ISemaphore {
     function acceptGroupAdmin(uint256 groupId) external;
 
     /// @dev Updates the group Merkle tree duration.
+    /// The new duration applies to every past root of the group, not only to roots superseded
+    /// after this call, so raising it makes older roots valid again and lowering it invalidates
+    /// proofs that are already in flight. It is also how long a removed member can keep proving
+    /// membership with an older root, so it should be kept as short as the group can tolerate.
     /// @param groupId: Id of the group.
     /// @param newMerkleTreeDuration: New Merkle tree duration.
     function updateGroupMerkleTreeDuration(uint256 groupId, uint256 newMerkleTreeDuration) external;

package/package.json

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