@semaphore-protocol/contracts 2.0.0 → 2.1.0

package/Semaphore.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.4;
+pragma solidity 0.8.4;
 
 import "./interfaces/ISemaphore.sol";
 import "./interfaces/IVerifier.sol";
@@ -9,43 +9,71 @@ import "./base/SemaphoreGroups.sol";
 /// @title Semaphore
 contract Semaphore is ISemaphore, SemaphoreCore, SemaphoreGroups {
     /// @dev Gets a tree depth and returns its verifier address.
-    mapping(uint8 => IVerifier) public verifiers;
+    mapping(uint256 => IVerifier) public verifiers;
 
     /// @dev Gets a group id and returns the group admin address.
     mapping(uint256 => address) public groupAdmins;
 
+    /// @dev Gets a group id and returns data to check if a Merkle root is expired.
+    mapping(uint256 => MerkleTreeExpiry) public merkleTreeExpiries;
+
     /// @dev Checks if the group admin is the transaction sender.
     /// @param groupId: Id of the group.
     modifier onlyGroupAdmin(uint256 groupId) {
-        require(groupAdmins[groupId] == _msgSender(), "Semaphore: caller is not the group admin");
+        if (groupAdmins[groupId] != _msgSender()) {
+            revert Semaphore__CallerIsNotTheGroupAdmin();
+        }
         _;
     }
 
     /// @dev Checks if there is a verifier for the given tree depth.
-    /// @param depth: Depth of the tree.
-    modifier onlySupportedDepth(uint8 depth) {
-        require(address(verifiers[depth]) != address(0), "Semaphore: tree depth is not supported");
+    /// @param merkleTreeDepth: Depth of the tree.
+    modifier onlySupportedMerkleTreeDepth(uint256 merkleTreeDepth) {
+        if (address(verifiers[merkleTreeDepth]) == address(0)) {
+            revert Semaphore__MerkleTreeDepthIsNotSupported();
+        }
         _;
     }
 
     /// @dev Initializes the Semaphore verifiers used to verify the user's ZK proofs.
     /// @param _verifiers: List of Semaphore verifiers (address and related Merkle tree depth).
     constructor(Verifier[] memory _verifiers) {
-        for (uint8 i = 0; i < _verifiers.length; i++) {
+        for (uint8 i = 0; i < _verifiers.length; ) {
             verifiers[_verifiers[i].merkleTreeDepth] = IVerifier(_verifiers[i].contractAddress);
+
+            unchecked {
+                ++i;
+            }
         }
     }
 
     /// @dev See {ISemaphore-createGroup}.
     function createGroup(
         uint256 groupId,
-        uint8 depth,
+        uint256 merkleTreeDepth,
         uint256 zeroValue,
         address admin
-    ) external override onlySupportedDepth(depth) {
-        _createGroup(groupId, depth, zeroValue);
+    ) external override onlySupportedMerkleTreeDepth(merkleTreeDepth) {
+        _createGroup(groupId, merkleTreeDepth, zeroValue);
 
         groupAdmins[groupId] = admin;
+        merkleTreeExpiries[groupId].rootDuration = 1 hours;
+
+        emit GroupAdminUpdated(groupId, address(0), admin);
+    }
+
+    /// @dev See {ISemaphore-createGroup}.
+    function createGroup(
+        uint256 groupId,
+        uint256 merkleTreeDepth,
+        uint256 zeroValue,
+        address admin,
+        uint256 merkleTreeRootDuration
+    ) external override onlySupportedMerkleTreeDepth(merkleTreeDepth) {
+        _createGroup(groupId, merkleTreeDepth, zeroValue);
+
+        groupAdmins[groupId] = admin;
+        merkleTreeExpiries[groupId].rootDuration = merkleTreeRootDuration;
 
         emit GroupAdminUpdated(groupId, address(0), admin);
     }
@@ -60,6 +88,21 @@ contract Semaphore is ISemaphore, SemaphoreCore, SemaphoreGroups {
     /// @dev See {ISemaphore-addMember}.
     function addMember(uint256 groupId, uint256 identityCommitment) external override onlyGroupAdmin(groupId) {
         _addMember(groupId, identityCommitment);
+
+        uint256 merkleTreeRoot = getMerkleTreeRoot(groupId);
+
+        merkleTreeExpiries[groupId].rootCreationDates[merkleTreeRoot] = block.timestamp;
+    }
+
+    /// @dev See {ISemaphore-updateMember}.
+    function updateMember(
+        uint256 groupId,
+        uint256 identityCommitment,
+        uint256 newIdentityCommitment,
+        uint256[] calldata proofSiblings,
+        uint8[] calldata proofPathIndices
+    ) external override onlyGroupAdmin(groupId) {
+        _updateMember(groupId, identityCommitment, newIdentityCommitment, proofSiblings, proofPathIndices);
     }
 
     /// @dev See {ISemaphore-removeMember}.
@@ -75,19 +118,36 @@ contract Semaphore is ISemaphore, SemaphoreCore, SemaphoreGroups {
     /// @dev See {ISemaphore-verifyProof}.
     function verifyProof(
         uint256 groupId,
+        uint256 merkleTreeRoot,
         bytes32 signal,
         uint256 nullifierHash,
         uint256 externalNullifier,
         uint256[8] calldata proof
     ) external override {
-        uint256 root = getRoot(groupId);
-        uint8 depth = getDepth(groupId);
+        uint256 currentMerkleTreeRoot = getMerkleTreeRoot(groupId);
+
+        if (currentMerkleTreeRoot == 0) {
+            revert Semaphore__GroupDoesNotExist();
+        }
+
+        if (merkleTreeRoot != currentMerkleTreeRoot) {
+            uint256 rootCreationDate = merkleTreeExpiries[groupId].rootCreationDates[merkleTreeRoot];
+            uint256 rootDuration = merkleTreeExpiries[groupId].rootDuration;
+
+            if (rootCreationDate == 0) {
+                revert Semaphore__MerkleTreeRootIsNotPartOfTheGroup();
+            }
+
+            if (block.timestamp > rootCreationDate + rootDuration) {
+                revert Semaphore__MerkleTreeRootIsExpired();
+            }
+        }
 
-        require(depth != 0, "Semaphore: group does not exist");
+        uint256 merkleTreeDepth = getMerkleTreeDepth(groupId);
 
-        IVerifier verifier = verifiers[depth];
+        IVerifier verifier = verifiers[merkleTreeDepth];
 
-        _verifyProof(signal, root, nullifierHash, externalNullifier, proof, verifier);
+        _verifyProof(signal, merkleTreeRoot, nullifierHash, externalNullifier, proof, verifier);
 
         _saveNullifierHash(nullifierHash);
 

package/base/SemaphoreConstants.sol

@@ -1,4 +1,4 @@
 //SPDX-License-Identifier: MIT
-pragma solidity ^0.8.4;
+pragma solidity 0.8.4;
 
 uint256 constant SNARK_SCALAR_FIELD = 21888242871839275222246405745257275088548364400416034343698204186575808495617;

package/base/SemaphoreCore.sol

@@ -1,5 +1,5 @@
 //SPDX-License-Identifier: MIT
-pragma solidity ^0.8.4;
+pragma solidity 0.8.4;
 
 import "../interfaces/ISemaphoreCore.sol";
 import "../interfaces/IVerifier.sol";
@@ -30,7 +30,9 @@ contract SemaphoreCore is ISemaphoreCore {
         uint256[8] calldata proof,
         IVerifier verifier
     ) internal view {
-        require(!nullifierHashes[nullifierHash], "SemaphoreCore: you cannot use the same nullifier twice");
+        if (nullifierHashes[nullifierHash]) {
+            revert Semaphore__YouAreUsingTheSameNillifierTwice();
+        }
 
         uint256 signalHash = _hashSignal(signal);
 

package/base/SemaphoreGroups.sol

@@ -1,9 +1,9 @@
 //SPDX-License-Identifier: MIT
-pragma solidity ^0.8.4;
+pragma solidity 0.8.4;
 
 import {SNARK_SCALAR_FIELD} from "./SemaphoreConstants.sol";
 import "../interfaces/ISemaphoreGroups.sol";
-import "@zk-kit/incremental-merkle-tree.sol/contracts/IncrementalBinaryTree.sol";
+import "@zk-kit/incremental-merkle-tree.sol/IncrementalBinaryTree.sol";
 import "@openzeppelin/contracts/utils/Context.sol";
 
 /// @title Semaphore groups contract.
@@ -17,38 +17,70 @@ abstract contract SemaphoreGroups is Context, ISemaphoreGroups {
 
     /// @dev Creates a new group by initializing the associated tree.
     /// @param groupId: Id of the group.
-    /// @param depth: Depth of the tree.
+    /// @param merkleTreeDepth: Depth of the tree.
     /// @param zeroValue: Zero value of the tree.
     function _createGroup(
         uint256 groupId,
-        uint8 depth,
+        uint256 merkleTreeDepth,
         uint256 zeroValue
     ) internal virtual {
-        require(groupId < SNARK_SCALAR_FIELD, "SemaphoreGroups: group id must be < SNARK_SCALAR_FIELD");
-        require(getDepth(groupId) == 0, "SemaphoreGroups: group already exists");
+        if (groupId >= SNARK_SCALAR_FIELD) {
+            revert Semaphore__GroupIdIsNotLessThanSnarkScalarField();
+        }
 
-        groups[groupId].init(depth, zeroValue);
+        if (getMerkleTreeDepth(groupId) != 0) {
+            revert Semaphore__GroupAlreadyExists();
+        }
 
-        emit GroupCreated(groupId, depth, zeroValue);
+        groups[groupId].init(merkleTreeDepth, zeroValue);
+
+        emit GroupCreated(groupId, merkleTreeDepth, zeroValue);
     }
 
     /// @dev Adds an identity commitment to an existing group.
     /// @param groupId: Id of the group.
     /// @param identityCommitment: New identity commitment.
     function _addMember(uint256 groupId, uint256 identityCommitment) internal virtual {
-        require(getDepth(groupId) != 0, "SemaphoreGroups: group does not exist");
+        if (getMerkleTreeDepth(groupId) == 0) {
+            revert Semaphore__GroupDoesNotExist();
+        }
 
         groups[groupId].insert(identityCommitment);
 
-        uint256 root = getRoot(groupId);
+        uint256 merkleTreeRoot = getMerkleTreeRoot(groupId);
+
+        emit MemberAdded(groupId, identityCommitment, merkleTreeRoot);
+    }
+
+    /// @dev Updates an identity commitment of an existing group. A proof of membership is
+    /// needed to check if the node to be updated is part of the tree.
+    /// @param groupId: Id of the group.
+    /// @param identityCommitment: Existing identity commitment to be updated.
+    /// @param newIdentityCommitment: New identity commitment.
+    /// @param proofSiblings: Array of the sibling nodes of the proof of membership.
+    /// @param proofPathIndices: Path of the proof of membership.
+    function _updateMember(
+        uint256 groupId,
+        uint256 identityCommitment,
+        uint256 newIdentityCommitment,
+        uint256[] calldata proofSiblings,
+        uint8[] calldata proofPathIndices
+    ) internal virtual {
+        if (getMerkleTreeRoot(groupId) == 0) {
+            revert Semaphore__GroupDoesNotExist();
+        }
+
+        groups[groupId].update(identityCommitment, newIdentityCommitment, proofSiblings, proofPathIndices);
+
+        uint256 merkleTreeRoot = getMerkleTreeRoot(groupId);
 
-        emit MemberAdded(groupId, identityCommitment, root);
+        emit MemberUpdated(groupId, identityCommitment, newIdentityCommitment, merkleTreeRoot);
     }
 
     /// @dev Removes an identity commitment from an existing group. A proof of membership is
     /// needed to check if the node to be deleted is part of the tree.
     /// @param groupId: Id of the group.
-    /// @param identityCommitment: Existing identity commitment to be deleted.
+    /// @param identityCommitment: Existing identity commitment to be removed.
     /// @param proofSiblings: Array of the sibling nodes of the proof of membership.
     /// @param proofPathIndices: Path of the proof of membership.
     function _removeMember(
@@ -57,27 +89,29 @@ abstract contract SemaphoreGroups is Context, ISemaphoreGroups {
         uint256[] calldata proofSiblings,
         uint8[] calldata proofPathIndices
     ) internal virtual {
-        require(getDepth(groupId) != 0, "SemaphoreGroups: group does not exist");
+        if (getMerkleTreeRoot(groupId) == 0) {
+            revert Semaphore__GroupDoesNotExist();
+        }
 
         groups[groupId].remove(identityCommitment, proofSiblings, proofPathIndices);
 
-        uint256 root = getRoot(groupId);
+        uint256 merkleTreeRoot = getMerkleTreeRoot(groupId);
 
-        emit MemberRemoved(groupId, identityCommitment, root);
+        emit MemberRemoved(groupId, identityCommitment, merkleTreeRoot);
     }
 
-    /// @dev See {ISemaphoreGroups-getRoot}.
-    function getRoot(uint256 groupId) public view virtual override returns (uint256) {
+    /// @dev See {ISemaphoreGroups-getMerkleTreeRoot}.
+    function getMerkleTreeRoot(uint256 groupId) public view virtual override returns (uint256) {
         return groups[groupId].root;
     }
 
-    /// @dev See {ISemaphoreGroups-getDepth}.
-    function getDepth(uint256 groupId) public view virtual override returns (uint8) {
+    /// @dev See {ISemaphoreGroups-getMerkleTreeDepth}.
+    function getMerkleTreeDepth(uint256 groupId) public view virtual override returns (uint256) {
         return groups[groupId].depth;
     }
 
-    /// @dev See {ISemaphoreGroups-getNumberOfLeaves}.
-    function getNumberOfLeaves(uint256 groupId) public view virtual override returns (uint256) {
+    /// @dev See {ISemaphoreGroups-getNumberOfMerkleTreeLeaves}.
+    function getNumberOfMerkleTreeLeaves(uint256 groupId) public view virtual override returns (uint256) {
         return groups[groupId].numberOfLeaves;
     }
 }

package/extensions/SemaphoreVoting.sol

@@ -1,5 +1,5 @@
 //SPDX-License-Identifier: MIT
-pragma solidity ^0.8.4;
+pragma solidity 0.8.4;
 
 import "../interfaces/ISemaphoreVoting.sol";
 import "../base/SemaphoreCore.sol";
@@ -9,32 +9,30 @@ import "../base/SemaphoreGroups.sol";
 /// @dev The following code allows you to create polls, add voters and allow them to vote anonymously.
 contract SemaphoreVoting is ISemaphoreVoting, SemaphoreCore, SemaphoreGroups {
     /// @dev Gets a tree depth and returns its verifier address.
-    mapping(uint8 => IVerifier) internal verifiers;
+    mapping(uint256 => IVerifier) internal verifiers;
 
     /// @dev Gets a poll id and returns the poll data.
     mapping(uint256 => Poll) internal polls;
 
-    /// @dev Since there can be multiple verifier contracts (each associated with a certain tree depth),
-    /// it is necessary to pass the addresses of the previously deployed contracts with the associated
-    /// tree depth. Depending on the depth chosen when creating the poll, a certain verifier will be
-    /// used to verify that the proof is correct.
-    /// @param depths: Three depths used in verifiers.
-    /// @param verifierAddresses: Verifier addresses.
-    constructor(uint8[] memory depths, address[] memory verifierAddresses) {
-        require(
-            depths.length == verifierAddresses.length,
-            "SemaphoreVoting: parameters lists does not have the same length"
-        );
-
-        for (uint8 i = 0; i < depths.length; i++) {
-            verifiers[depths[i]] = IVerifier(verifierAddresses[i]);
+    /// @dev Initializes the Semaphore verifiers used to verify the user's ZK proofs.
+    /// @param _verifiers: List of Semaphore verifiers (address and related Merkle tree depth).
+    constructor(Verifier[] memory _verifiers) {
+        for (uint8 i = 0; i < _verifiers.length; ) {
+            verifiers[_verifiers[i].merkleTreeDepth] = IVerifier(_verifiers[i].contractAddress);
+
+            unchecked {
+                ++i;
+            }
         }
     }
 
     /// @dev Checks if the poll coordinator is the transaction sender.
     /// @param pollId: Id of the poll.
     modifier onlyCoordinator(uint256 pollId) {
-        require(polls[pollId].coordinator == _msgSender(), "SemaphoreVoting: caller is not the poll coordinator");
+        if (polls[pollId].coordinator != _msgSender()) {
+            revert Semaphore__CallerIsNotThePollCoordinator();
+        }
+
         _;
     }
 
@@ -42,11 +40,13 @@ contract SemaphoreVoting is ISemaphoreVoting, SemaphoreCore, SemaphoreGroups {
     function createPoll(
         uint256 pollId,
         address coordinator,
-        uint8 depth
+        uint256 merkleTreeDepth
     ) public override {
-        require(address(verifiers[depth]) != address(0), "SemaphoreVoting: depth value is not supported");
+        if (address(verifiers[merkleTreeDepth]) == address(0)) {
+            revert Semaphore__MerkleTreeDepthIsNotSupported();
+        }
 
-        _createGroup(pollId, depth, 0);
+        _createGroup(pollId, merkleTreeDepth, 0);
 
         Poll memory poll;
 
@@ -59,14 +59,18 @@ contract SemaphoreVoting is ISemaphoreVoting, SemaphoreCore, SemaphoreGroups {
 
     /// @dev See {ISemaphoreVoting-addVoter}.
     function addVoter(uint256 pollId, uint256 identityCommitment) public override onlyCoordinator(pollId) {
-        require(polls[pollId].state == PollState.Created, "SemaphoreVoting: voters can only be added before voting");
+        if (polls[pollId].state != PollState.Created) {
+            revert Semaphore__PollHasAlreadyBeenStarted();
+        }
 
         _addMember(pollId, identityCommitment);
     }
 
     /// @dev See {ISemaphoreVoting-addVoter}.
     function startPoll(uint256 pollId, uint256 encryptionKey) public override onlyCoordinator(pollId) {
-        require(polls[pollId].state == PollState.Created, "SemaphoreVoting: poll has already been started");
+        if (polls[pollId].state != PollState.Created) {
+            revert Semaphore__PollHasAlreadyBeenStarted();
+        }
 
         polls[pollId].state = PollState.Ongoing;
 
@@ -82,13 +86,16 @@ contract SemaphoreVoting is ISemaphoreVoting, SemaphoreCore, SemaphoreGroups {
     ) public override onlyCoordinator(pollId) {
         Poll memory poll = polls[pollId];
 
-        require(poll.state == PollState.Ongoing, "SemaphoreVoting: vote can only be cast in an ongoing poll");
+        if (poll.state != PollState.Ongoing) {
+            revert Semaphore__PollIsNotOngoing();
+        }
+
+        uint256 merkleTreeDepth = getMerkleTreeDepth(pollId);
+        uint256 merkleTreeRoot = getMerkleTreeRoot(pollId);
 
-        uint8 depth = getDepth(pollId);
-        uint256 root = getRoot(pollId);
-        IVerifier verifier = verifiers[depth];
+        IVerifier verifier = verifiers[merkleTreeDepth];
 
-        _verifyProof(vote, root, nullifierHash, pollId, proof, verifier);
+        _verifyProof(vote, merkleTreeRoot, nullifierHash, pollId, proof, verifier);
 
         // Prevent double-voting (nullifierHash = hash(pollId + identityNullifier)).
         _saveNullifierHash(nullifierHash);
@@ -98,7 +105,9 @@ contract SemaphoreVoting is ISemaphoreVoting, SemaphoreCore, SemaphoreGroups {
 
     /// @dev See {ISemaphoreVoting-publishDecryptionKey}.
     function endPoll(uint256 pollId, uint256 decryptionKey) public override onlyCoordinator(pollId) {
-        require(polls[pollId].state == PollState.Ongoing, "SemaphoreVoting: poll is not ongoing");
+        if (polls[pollId].state != PollState.Ongoing) {
+            revert Semaphore__PollIsNotOngoing();
+        }
 
         polls[pollId].state = PollState.Ended;
 

package/extensions/SemaphoreWhistleblowing.sol

@@ -1,5 +1,5 @@
 //SPDX-License-Identifier: MIT
-pragma solidity ^0.8.4;
+pragma solidity 0.8.4;
 
 import "../interfaces/ISemaphoreWhistleblowing.sol";
 import "../base/SemaphoreCore.sol";
@@ -11,32 +11,30 @@ import "../base/SemaphoreGroups.sol";
 /// Leaks can be IPFS hashes, permanent links or other kinds of reference.
 contract SemaphoreWhistleblowing is ISemaphoreWhistleblowing, SemaphoreCore, SemaphoreGroups {
     /// @dev Gets a tree depth and returns its verifier address.
-    mapping(uint8 => IVerifier) internal verifiers;
+    mapping(uint256 => IVerifier) internal verifiers;
 
     /// @dev Gets an editor address and return their entity.
     mapping(address => uint256) private entities;
 
-    /// @dev Since there can be multiple verifier contracts (each associated with a certain tree depth),
-    /// it is necessary to pass the addresses of the previously deployed contracts with the associated
-    /// tree depth. Depending on the depth chosen when creating the entity, a certain verifier will be
-    /// used to verify that the proof is correct.
-    /// @param depths: Three depths used in verifiers.
-    /// @param verifierAddresses: Verifier addresses.
-    constructor(uint8[] memory depths, address[] memory verifierAddresses) {
-        require(
-            depths.length == verifierAddresses.length,
-            "SemaphoreWhistleblowing: parameters lists does not have the same length"
-        );
-
-        for (uint8 i = 0; i < depths.length; i++) {
-            verifiers[depths[i]] = IVerifier(verifierAddresses[i]);
+    /// @dev Initializes the Semaphore verifiers used to verify the user's ZK proofs.
+    /// @param _verifiers: List of Semaphore verifiers (address and related Merkle tree depth).
+    constructor(Verifier[] memory _verifiers) {
+        for (uint8 i = 0; i < _verifiers.length; ) {
+            verifiers[_verifiers[i].merkleTreeDepth] = IVerifier(_verifiers[i].contractAddress);
+
+            unchecked {
+                ++i;
+            }
         }
     }
 
     /// @dev Checks if the editor is the transaction sender.
     /// @param entityId: Id of the entity.
     modifier onlyEditor(uint256 entityId) {
-        require(entityId == entities[_msgSender()], "SemaphoreWhistleblowing: caller is not the editor");
+        if (entityId != entities[_msgSender()]) {
+            revert Semaphore__CallerIsNotTheEditor();
+        }
+
         _;
     }
 
@@ -44,11 +42,13 @@ contract SemaphoreWhistleblowing is ISemaphoreWhistleblowing, SemaphoreCore, Sem
     function createEntity(
         uint256 entityId,
         address editor,
-        uint8 depth
+        uint256 merkleTreeDepth
     ) public override {
-        require(address(verifiers[depth]) != address(0), "SemaphoreWhistleblowing: depth value is not supported");
+        if (address(verifiers[merkleTreeDepth]) == address(0)) {
+            revert Semaphore__MerkleTreeDepthIsNotSupported();
+        }
 
-        _createGroup(entityId, depth, 0);
+        _createGroup(entityId, merkleTreeDepth, 0);
 
         entities[editor] = entityId;
 
@@ -77,11 +77,12 @@ contract SemaphoreWhistleblowing is ISemaphoreWhistleblowing, SemaphoreCore, Sem
         uint256 entityId,
         uint256[8] calldata proof
     ) public override onlyEditor(entityId) {
-        uint8 depth = getDepth(entityId);
-        uint256 root = getRoot(entityId);
-        IVerifier verifier = verifiers[depth];
+        uint256 merkleTreeDepth = getMerkleTreeDepth(entityId);
+        uint256 merkleTreeRoot = getMerkleTreeRoot(entityId);
+
+        IVerifier verifier = verifiers[merkleTreeDepth];
 
-        _verifyProof(leak, root, nullifierHash, entityId, proof, verifier);
+        _verifyProof(leak, merkleTreeRoot, nullifierHash, entityId, proof, verifier);
 
         emit LeakPublished(entityId, leak);
     }

package/interfaces/ISemaphore.sol

@@ -1,12 +1,24 @@
 //SPDX-License-Identifier: MIT
-pragma solidity ^0.8.4;
+pragma solidity 0.8.4;
 
 /// @title Semaphore interface.
 /// @dev Interface of a Semaphore contract.
 interface ISemaphore {
+    error Semaphore__CallerIsNotTheGroupAdmin();
+    error Semaphore__MerkleTreeDepthIsNotSupported();
+    error Semaphore__MerkleTreeRootIsExpired();
+    error Semaphore__MerkleTreeRootIsNotPartOfTheGroup();
+
     struct Verifier {
         address contractAddress;
-        uint8 merkleTreeDepth;
+        uint256 merkleTreeDepth;
+    }
+
+    /// It defines all the parameters needed to check whether a
+    /// zero-knowledge proof generated with a certain Merkle tree is still valid.
+    struct MerkleTreeExpiry {
+        uint256 rootDuration;
+        mapping(uint256 => uint256) rootCreationDates;
     }
 
     /// @dev Emitted when an admin is assigned to a group.
@@ -23,12 +35,14 @@ 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 merkleTreeRoot: Root of the Merkle tree.
     /// @param signal: Semaphore signal.
     /// @param nullifierHash: Nullifier hash.
     /// @param externalNullifier: External nullifier.
     /// @param proof: Zero-knowledge proof.
     function verifyProof(
         uint256 groupId,
+        uint256 merkleTreeRoot,
         bytes32 signal,
         uint256 nullifierHash,
         uint256 externalNullifier,
@@ -42,11 +56,25 @@ interface ISemaphore {
     /// @param admin: Admin of the group.
     function createGroup(
         uint256 groupId,
-        uint8 depth,
+        uint256 depth,
         uint256 zeroValue,
         address admin
     ) external;
 
+    /// @dev Creates a new group. Only the admin will be able to add or remove members.
+    /// @param groupId: Id of the group.
+    /// @param depth: Depth of the tree.
+    /// @param zeroValue: Zero value of the tree.
+    /// @param admin: Admin of the group.
+    /// @param merkleTreeRootDuration: Time before the validity of a root expires.
+    function createGroup(
+        uint256 groupId,
+        uint256 depth,
+        uint256 zeroValue,
+        address admin,
+        uint256 merkleTreeRootDuration
+    ) external;
+
     /// @dev Updates the group admin.
     /// @param groupId: Id of the group.
     /// @param newAdmin: New admin of the group.
@@ -57,10 +85,25 @@ interface ISemaphore {
     /// @param identityCommitment: New identity commitment.
     function addMember(uint256 groupId, uint256 identityCommitment) external;
 
+    /// @dev Updates an identity commitment of an existing group. A proof of membership is
+    /// needed to check if the node to be updated is part of the tree.
+    /// @param groupId: Id of the group.
+    /// @param identityCommitment: Existing identity commitment to be updated.
+    /// @param newIdentityCommitment: New identity commitment.
+    /// @param proofSiblings: Array of the sibling nodes of the proof of membership.
+    /// @param proofPathIndices: Path of the proof of membership.
+    function updateMember(
+        uint256 groupId,
+        uint256 identityCommitment,
+        uint256 newIdentityCommitment,
+        uint256[] calldata proofSiblings,
+        uint8[] calldata proofPathIndices
+    ) external;
+
     /// @dev Removes a member from an existing group. A proof of membership is
     /// needed to check if the node to be removed is part of the tree.
     /// @param groupId: Id of the group.
-    /// @param identityCommitment: Identity commitment to be deleted.
+    /// @param identityCommitment: Identity commitment to be removed.
     /// @param proofSiblings: Array of the sibling nodes of the proof of membership.
     /// @param proofPathIndices: Path of the proof of membership.
     function removeMember(

package/interfaces/ISemaphoreCore.sol

@@ -1,9 +1,11 @@
 //SPDX-License-Identifier: MIT
-pragma solidity ^0.8.4;
+pragma solidity 0.8.4;
 
 /// @title SemaphoreCore interface.
 /// @dev Interface of SemaphoreCore contract.
 interface ISemaphoreCore {
+    error Semaphore__YouAreUsingTheSameNillifierTwice();
+
     /// @notice Emitted when a proof is verified correctly and a new nullifier hash is added.
     /// @param nullifierHash: Hash of external and identity nullifiers.
     event NullifierHashAdded(uint256 nullifierHash);

package/interfaces/ISemaphoreGroups.sol

@@ -1,39 +1,55 @@
 //SPDX-License-Identifier: MIT
-pragma solidity ^0.8.4;
+pragma solidity 0.8.4;
 
 /// @title SemaphoreGroups interface.
 /// @dev Interface of a SemaphoreGroups contract.
 interface ISemaphoreGroups {
+    error Semaphore__GroupDoesNotExist();
+    error Semaphore__GroupAlreadyExists();
+    error Semaphore__GroupIdIsNotLessThanSnarkScalarField();
+
     /// @dev Emitted when a new group is created.
     /// @param groupId: Id of the group.
-    /// @param depth: Depth of the tree.
+    /// @param merkleTreeDepth: Depth of the tree.
     /// @param zeroValue: Zero value of the tree.
-    event GroupCreated(uint256 indexed groupId, uint8 depth, uint256 zeroValue);
+    event GroupCreated(uint256 indexed groupId, uint256 merkleTreeDepth, uint256 zeroValue);
 
     /// @dev Emitted when a new identity commitment is added.
     /// @param groupId: Group id of the group.
     /// @param identityCommitment: New identity commitment.
-    /// @param root: New root hash of the tree.
-    event MemberAdded(uint256 indexed groupId, uint256 identityCommitment, uint256 root);
+    /// @param merkleTreeRoot: New root hash of the tree.
+    event MemberAdded(uint256 indexed groupId, uint256 identityCommitment, uint256 merkleTreeRoot);
 
-    /// @dev Emitted when a new identity commitment is removed.
+    /// @dev Emitted when an identity commitment is updated.
     /// @param groupId: Group id of the group.
     /// @param identityCommitment: New identity commitment.
-    /// @param root: New root hash of the tree.
-    event MemberRemoved(uint256 indexed groupId, uint256 identityCommitment, uint256 root);
+    /// @param newIdentityCommitment: New identity commitment.
+    /// @param merkleTreeRoot: New root hash of the tree.
+    event MemberUpdated(
+        uint256 indexed groupId,
+        uint256 identityCommitment,
+        uint256 newIdentityCommitment,
+        uint256 merkleTreeRoot
+    );
+
+    /// @dev Emitted when a new identity commitment is removed.
+    /// @param groupId: Group id of the group.
+    /// @param identityCommitment: Existing identity commitment to be removed.
+    /// @param merkleTreeRoot: New root hash of the tree.
+    event MemberRemoved(uint256 indexed groupId, uint256 identityCommitment, uint256 merkleTreeRoot);
 
     /// @dev Returns the last root hash of a group.
     /// @param groupId: Id of the group.
     /// @return Root hash of the group.
-    function getRoot(uint256 groupId) external view returns (uint256);
+    function getMerkleTreeRoot(uint256 groupId) external view returns (uint256);
 
     /// @dev Returns the depth of the tree of a group.
     /// @param groupId: Id of the group.
     /// @return Depth of the group tree.
-    function getDepth(uint256 groupId) external view returns (uint8);
+    function getMerkleTreeDepth(uint256 groupId) external view returns (uint256);
 
     /// @dev Returns the number of tree leaves of a group.
     /// @param groupId: Id of the group.
     /// @return Number of tree leaves.
-    function getNumberOfLeaves(uint256 groupId) external view returns (uint256);
+    function getNumberOfMerkleTreeLeaves(uint256 groupId) external view returns (uint256);
 }

package/interfaces/ISemaphoreNullifiers.sol

@@ -1,5 +1,5 @@
 //SPDX-License-Identifier: MIT
-pragma solidity ^0.8.4;
+pragma solidity 0.8.4;
 
 /// @title SemaphoreNullifiers interface.
 /// @dev Interface of SemaphoreNullifiers contract.

package/interfaces/ISemaphoreVoting.sol

@@ -1,15 +1,25 @@
 //SPDX-License-Identifier: MIT
-pragma solidity ^0.8.4;
+pragma solidity 0.8.4;
 
 /// @title SemaphoreVoting interface.
 /// @dev Interface of SemaphoreVoting contract.
 interface ISemaphoreVoting {
+    error Semaphore__CallerIsNotThePollCoordinator();
+    error Semaphore__MerkleTreeDepthIsNotSupported();
+    error Semaphore__PollHasAlreadyBeenStarted();
+    error Semaphore__PollIsNotOngoing();
+
     enum PollState {
         Created,
         Ongoing,
         Ended
     }
 
+    struct Verifier {
+        address contractAddress;
+        uint256 merkleTreeDepth;
+    }
+
     struct Poll {
         address coordinator;
         PollState state;
@@ -40,11 +50,11 @@ interface ISemaphoreVoting {
     /// @dev Creates a poll and the associated Merkle tree/group.
     /// @param pollId: Id of the poll.
     /// @param coordinator: Coordinator of the poll.
-    /// @param depth: Depth of the tree.
+    /// @param merkleTreeDepth: Depth of the tree.
     function createPoll(
         uint256 pollId,
         address coordinator,
-        uint8 depth
+        uint256 merkleTreeDepth
     ) external;
 
     /// @dev Adds a voter to a poll.

package/interfaces/ISemaphoreWhistleblowing.sol

@@ -1,9 +1,17 @@
 //SPDX-License-Identifier: MIT
-pragma solidity ^0.8.4;
+pragma solidity 0.8.4;
 
 /// @title SemaphoreWhistleblowing interface.
 /// @dev Interface of SemaphoreWhistleblowing contract.
 interface ISemaphoreWhistleblowing {
+    error Semaphore__CallerIsNotTheEditor();
+    error Semaphore__MerkleTreeDepthIsNotSupported();
+
+    struct Verifier {
+        address contractAddress;
+        uint256 merkleTreeDepth;
+    }
+
     /// @dev Emitted when a new entity is created.
     /// @param entityId: Id of the entity.
     /// @param editor: Editor of the entity.
@@ -17,11 +25,11 @@ interface ISemaphoreWhistleblowing {
     /// @dev Creates an entity and the associated Merkle tree/group.
     /// @param entityId: Id of the entity.
     /// @param editor: Editor of the entity.
-    /// @param depth: Depth of the tree.
+    /// @param merkleTreeDepth: Depth of the tree.
     function createEntity(
         uint256 entityId,
         address editor,
-        uint8 depth
+        uint256 merkleTreeDepth
     ) external;
 
     /// @dev Adds a whistleblower to an entity.

package/interfaces/IVerifier.sol

@@ -1,5 +1,5 @@
 //SPDX-License-Identifier: MIT
-pragma solidity ^0.8.4;
+pragma solidity 0.8.4;
 
 /// @title Verifier interface.
 /// @dev Interface of Verifier contract.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@semaphore-protocol/contracts",
-    "version": "2.0.0",
+    "version": "2.1.0",
     "description": "Semaphore contracts to manage groups and broadcast anonymous signals.",
     "license": "MIT",
     "files": [
@@ -32,7 +32,7 @@
         "access": "public"
     },
     "dependencies": {
-        "@openzeppelin/contracts": "^4.4.2",
-        "@zk-kit/incremental-merkle-tree.sol": "^0.3.1"
+        "@openzeppelin/contracts": "4.4.2",
+        "@zk-kit/incremental-merkle-tree.sol": "1.3.0"
     }
 }