@semaphore-protocol/contracts 0.1.0 → 2.1.0

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";
@@ -8,100 +8,109 @@ import "../base/SemaphoreGroups.sol";
 /// @title Semaphore voting contract.
 /// @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;
-
-  /// @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 Gets a tree depth and returns its verifier address.
+    mapping(uint256 => IVerifier) internal verifiers;
+
+    /// @dev Gets a poll id and returns the poll data.
+    mapping(uint256 => Poll) internal polls;
+
+    /// @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");
-    _;
-  }
+    /// @dev Checks if the poll coordinator is the transaction sender.
+    /// @param pollId: Id of the poll.
+    modifier onlyCoordinator(uint256 pollId) {
+        if (polls[pollId].coordinator != _msgSender()) {
+            revert Semaphore__CallerIsNotThePollCoordinator();
+        }
 
-  /// @dev See {ISemaphoreVoting-createPoll}.
-  function createPoll(
-    uint256 pollId,
-    address coordinator,
-    uint8 depth
-  ) public override {
-    require(address(verifiers[depth]) != address(0), "SemaphoreVoting: depth value is not supported");
+        _;
+    }
+
+    /// @dev See {ISemaphoreVoting-createPoll}.
+    function createPoll(
+        uint256 pollId,
+        address coordinator,
+        uint256 merkleTreeDepth
+    ) public override {
+        if (address(verifiers[merkleTreeDepth]) == address(0)) {
+            revert Semaphore__MerkleTreeDepthIsNotSupported();
+        }
 
-    _createGroup(pollId, depth, 0);
+        _createGroup(pollId, merkleTreeDepth, 0);
 
-    Poll memory poll;
+        Poll memory poll;
 
-    poll.coordinator = coordinator;
+        poll.coordinator = coordinator;
 
-    polls[pollId] = poll;
+        polls[pollId] = poll;
+
+        emit PollCreated(pollId, coordinator);
+    }
 
-    emit PollCreated(pollId, coordinator);
-  }
+    /// @dev See {ISemaphoreVoting-addVoter}.
+    function addVoter(uint256 pollId, uint256 identityCommitment) public override onlyCoordinator(pollId) {
+        if (polls[pollId].state != PollState.Created) {
+            revert Semaphore__PollHasAlreadyBeenStarted();
+        }
 
-  /// @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");
+        _addMember(pollId, identityCommitment);
+    }
 
-    _addMember(pollId, identityCommitment);
-  }
+    /// @dev See {ISemaphoreVoting-addVoter}.
+    function startPoll(uint256 pollId, uint256 encryptionKey) public override onlyCoordinator(pollId) {
+        if (polls[pollId].state != PollState.Created) {
+            revert Semaphore__PollHasAlreadyBeenStarted();
+        }
 
-  /// @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");
+        polls[pollId].state = PollState.Ongoing;
 
-    polls[pollId].state = PollState.Ongoing;
+        emit PollStarted(pollId, _msgSender(), encryptionKey);
+    }
 
-    emit PollStarted(pollId, _msgSender(), encryptionKey);
-  }
+    /// @dev See {ISemaphoreVoting-castVote}.
+    function castVote(
+        bytes32 vote,
+        uint256 nullifierHash,
+        uint256 pollId,
+        uint256[8] calldata proof
+    ) public override onlyCoordinator(pollId) {
+        Poll memory poll = polls[pollId];
 
-  /// @dev See {ISemaphoreVoting-castVote}.
-  function castVote(
-    bytes32 vote,
-    uint256 nullifierHash,
-    uint256 pollId,
-    uint256[8] calldata proof
-  ) public override onlyCoordinator(pollId) {
-    Poll memory poll = polls[pollId];
+        if (poll.state != PollState.Ongoing) {
+            revert Semaphore__PollIsNotOngoing();
+        }
 
-    require(poll.state == PollState.Ongoing, "SemaphoreVoting: vote can only be cast in an ongoing poll");
+        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);
+        // Prevent double-voting (nullifierHash = hash(pollId + identityNullifier)).
+        _saveNullifierHash(nullifierHash);
 
-    emit VoteAdded(pollId, vote);
-  }
+        emit VoteAdded(pollId, vote);
+    }
 
-  /// @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");
+    /// @dev See {ISemaphoreVoting-publishDecryptionKey}.
+    function endPoll(uint256 pollId, uint256 decryptionKey) public override onlyCoordinator(pollId) {
+        if (polls[pollId].state != PollState.Ongoing) {
+            revert Semaphore__PollIsNotOngoing();
+        }
 
-    polls[pollId].state = PollState.Ended;
+        polls[pollId].state = PollState.Ended;
 
-    emit PollEnded(pollId, _msgSender(), decryptionKey);
-  }
+        emit PollEnded(pollId, _msgSender(), decryptionKey);
+    }
 }

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";
@@ -10,79 +10,80 @@ import "../base/SemaphoreGroups.sol";
 /// organization, newspaper) and to allow them to publish news leaks anonymously.
 /// 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;
-
-  /// @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 Gets a tree depth and returns its verifier address.
+    mapping(uint256 => IVerifier) internal verifiers;
+
+    /// @dev Gets an editor address and return their entity.
+    mapping(address => uint256) private entities;
+
+    /// @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) {
+        if (entityId != entities[_msgSender()]) {
+            revert Semaphore__CallerIsNotTheEditor();
+        }
+
+        _;
+    }
+
+    /// @dev See {ISemaphoreWhistleblowing-createEntity}.
+    function createEntity(
+        uint256 entityId,
+        address editor,
+        uint256 merkleTreeDepth
+    ) public override {
+        if (address(verifiers[merkleTreeDepth]) == address(0)) {
+            revert Semaphore__MerkleTreeDepthIsNotSupported();
+        }
+
+        _createGroup(entityId, merkleTreeDepth, 0);
+
+        entities[editor] = entityId;
+
+        emit EntityCreated(entityId, editor);
+    }
+
+    /// @dev See {ISemaphoreWhistleblowing-addWhistleblower}.
+    function addWhistleblower(uint256 entityId, uint256 identityCommitment) public override onlyEditor(entityId) {
+        _addMember(entityId, identityCommitment);
+    }
+
+    /// @dev See {ISemaphoreWhistleblowing-removeWhistleblower}.
+    function removeWhistleblower(
+        uint256 entityId,
+        uint256 identityCommitment,
+        uint256[] calldata proofSiblings,
+        uint8[] calldata proofPathIndices
+    ) public override onlyEditor(entityId) {
+        _removeMember(entityId, identityCommitment, proofSiblings, proofPathIndices);
+    }
+
+    /// @dev See {ISemaphoreWhistleblowing-publishLeak}.
+    function publishLeak(
+        bytes32 leak,
+        uint256 nullifierHash,
+        uint256 entityId,
+        uint256[8] calldata proof
+    ) public override onlyEditor(entityId) {
+        uint256 merkleTreeDepth = getMerkleTreeDepth(entityId);
+        uint256 merkleTreeRoot = getMerkleTreeRoot(entityId);
+
+        IVerifier verifier = verifiers[merkleTreeDepth];
+
+        _verifyProof(leak, merkleTreeRoot, nullifierHash, entityId, proof, verifier);
+
+        emit LeakPublished(entityId, leak);
     }
-  }
-
-  /// @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");
-    _;
-  }
-
-  /// @dev See {ISemaphoreWhistleblowing-createEntity}.
-  function createEntity(
-    uint256 entityId,
-    address editor,
-    uint8 depth
-  ) public override {
-    require(address(verifiers[depth]) != address(0), "SemaphoreWhistleblowing: depth value is not supported");
-
-    _createGroup(entityId, depth, 0);
-
-    entities[editor] = entityId;
-
-    emit EntityCreated(entityId, editor);
-  }
-
-  /// @dev See {ISemaphoreWhistleblowing-addWhistleblower}.
-  function addWhistleblower(uint256 entityId, uint256 identityCommitment) public override onlyEditor(entityId) {
-    _addMember(entityId, identityCommitment);
-  }
-
-  /// @dev See {ISemaphoreWhistleblowing-removeWhistleblower}.
-  function removeWhistleblower(
-    uint256 entityId,
-    uint256 identityCommitment,
-    uint256[] calldata proofSiblings,
-    uint8[] calldata proofPathIndices
-  ) public override onlyEditor(entityId) {
-    _removeMember(entityId, identityCommitment, proofSiblings, proofPathIndices);
-  }
-
-  /// @dev See {ISemaphoreWhistleblowing-publishLeak}.
-  function publishLeak(
-    bytes32 leak,
-    uint256 nullifierHash,
-    uint256 entityId,
-    uint256[8] calldata proof
-  ) public override onlyEditor(entityId) {
-    uint8 depth = getDepth(entityId);
-    uint256 root = getRoot(entityId);
-    IVerifier verifier = verifiers[depth];
-
-    _verifyProof(leak, root, nullifierHash, entityId, proof, verifier);
-
-    emit LeakPublished(entityId, leak);
-  }
 }

package/interfaces/ISemaphore.sol

@@ -1,72 +1,115 @@
 //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 {
-  struct Verifier {
-    address contractAddress;
-    uint8 merkleTreeDepth;
-  }
+    error Semaphore__CallerIsNotTheGroupAdmin();
+    error Semaphore__MerkleTreeDepthIsNotSupported();
+    error Semaphore__MerkleTreeRootIsExpired();
+    error Semaphore__MerkleTreeRootIsNotPartOfTheGroup();
 
-  /// @dev Emitted when an admin is assigned to a group.
-  /// @param groupId: Id of the group.
-  /// @param oldAdmin: Old admin of the group.
-  /// @param newAdmin: New admin of the group.
-  event GroupAdminUpdated(uint256 indexed groupId, address indexed oldAdmin, address indexed newAdmin);
+    struct Verifier {
+        address contractAddress;
+        uint256 merkleTreeDepth;
+    }
 
-  /// @dev Emitted when a Semaphore proof is verified.
-  /// @param groupId: Id of the group.
-  /// @param signal: Semaphore signal.
-  event ProofVerified(uint256 indexed groupId, bytes32 signal);
+    /// 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 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 signal: Semaphore signal.
-  /// @param nullifierHash: Nullifier hash.
-  /// @param externalNullifier: External nullifier.
-  /// @param proof: Zero-knowledge proof.
-  function verifyProof(
-    uint256 groupId,
-    bytes32 signal,
-    uint256 nullifierHash,
-    uint256 externalNullifier,
-    uint256[8] calldata proof
-  ) external;
+    /// @dev Emitted when an admin is assigned to a group.
+    /// @param groupId: Id of the group.
+    /// @param oldAdmin: Old admin of the group.
+    /// @param newAdmin: New admin of the group.
+    event GroupAdminUpdated(uint256 indexed groupId, address indexed oldAdmin, address indexed newAdmin);
 
-  /// @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.
-  function createGroup(
-    uint256 groupId,
-    uint8 depth,
-    uint256 zeroValue,
-    address admin
-  ) external;
+    /// @dev Emitted when a Semaphore proof is verified.
+    /// @param groupId: Id of the group.
+    /// @param signal: Semaphore signal.
+    event ProofVerified(uint256 indexed groupId, bytes32 signal);
 
-  /// @dev Updates the group admin.
-  /// @param groupId: Id of the group.
-  /// @param newAdmin: New admin of the group.
-  function updateGroupAdmin(uint256 groupId, address newAdmin) external;
+    /// @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,
+        uint256[8] calldata proof
+    ) external;
 
-  /// @dev Adds a new member to an existing group.
-  /// @param groupId: Id of the group.
-  /// @param identityCommitment: New identity commitment.
-  function addMember(uint256 groupId, uint256 identityCommitment) 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.
+    function createGroup(
+        uint256 groupId,
+        uint256 depth,
+        uint256 zeroValue,
+        address admin
+    ) 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 proofSiblings: Array of the sibling nodes of the proof of membership.
-  /// @param proofPathIndices: Path of the proof of membership.
-  function removeMember(
-    uint256 groupId,
-    uint256 identityCommitment,
-    uint256[] calldata proofSiblings,
-    uint8[] calldata proofPathIndices
-  ) 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.
+    function updateGroupAdmin(uint256 groupId, address newAdmin) external;
+
+    /// @dev Adds a new member to an existing group.
+    /// @param groupId: Id of the group.
+    /// @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 removed.
+    /// @param proofSiblings: Array of the sibling nodes of the proof of membership.
+    /// @param proofPathIndices: Path of the proof of membership.
+    function removeMember(
+        uint256 groupId,
+        uint256 identityCommitment,
+        uint256[] calldata proofSiblings,
+        uint8[] calldata proofPathIndices
+    ) external;
 }

package/interfaces/ISemaphoreCore.sol

@@ -1,10 +1,12 @@
 //SPDX-License-Identifier: MIT
-pragma solidity ^0.8.4;
+pragma solidity 0.8.4;
 
 /// @title SemaphoreCore interface.
 /// @dev Interface of SemaphoreCore contract.
 interface ISemaphoreCore {
-  /// @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);
+    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 {
-  /// @dev Emitted when a new group is created.
-  /// @param groupId: Id of the group.
-  /// @param depth: Depth of the tree.
-  /// @param zeroValue: Zero value of the tree.
-  event GroupCreated(uint256 indexed groupId, uint8 depth, 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);
-
-  /// @dev Emitted when a new identity commitment is removed.
-  /// @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);
-
-  /// @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);
-
-  /// @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);
-
-  /// @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);
+    error Semaphore__GroupDoesNotExist();
+    error Semaphore__GroupAlreadyExists();
+    error Semaphore__GroupIdIsNotLessThanSnarkScalarField();
+
+    /// @dev Emitted when a new group is created.
+    /// @param groupId: Id of the group.
+    /// @param merkleTreeDepth: Depth of the tree.
+    /// @param zeroValue: Zero value of the tree.
+    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 merkleTreeRoot: New root hash of the tree.
+    event MemberAdded(uint256 indexed groupId, uint256 identityCommitment, uint256 merkleTreeRoot);
+
+    /// @dev Emitted when an identity commitment is updated.
+    /// @param groupId: Group id of the group.
+    /// @param identityCommitment: New identity commitment.
+    /// @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 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 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 getNumberOfMerkleTreeLeaves(uint256 groupId) external view returns (uint256);
 }