@semaphore-protocol/contracts 0.1.0 → 2.1.0

package/README.md

@@ -0,0 +1,61 @@
+<p align="center">
+    <h1 align="center">
+        Semaphore contracts
+    </h1>
+    <p align="center">Semaphore contracts to manage groups and broadcast anonymous signals.</p>
+</p>
+
+<p align="center">
+    <a href="https://github.com/semaphore-protocol">
+        <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">
+    </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" />
+    </a>
+    <a href="https://npmjs.org/package/@semaphore-protocol/contracts">
+        <img alt="Downloads" src="https://img.shields.io/npm/dm/@semaphore-protocol/contracts.svg?style=flat-square" />
+    </a>
+</p>
+
+<div align="center">
+    <h4>
+        <a href="https://github.com/semaphore-protocol/semaphore/blob/main/CONTRIBUTING.md">
+            👥 Contributing
+        </a>
+        <span>&nbsp;&nbsp;|&nbsp;&nbsp;</span>
+        <a href="https://github.com/semaphore-protocol/semaphore/blob/main/CODE_OF_CONDUCT.md">
+            🤝 Code of conduct
+        </a>
+        <span>&nbsp;&nbsp;|&nbsp;&nbsp;</span>
+        <a href="https://github.com/semaphore-protocol/semaphore/contribute">
+            🔎 Issues
+        </a>
+        <span>&nbsp;&nbsp;|&nbsp;&nbsp;</span>
+        <a href="https://t.me/joinchat/B-PQx1U3GtAh--Z4Fwo56A">
+            🗣️ Chat &amp; Support
+        </a>
+    </h4>
+</div>
+
+To learn more about contracts visit [semaphore.appliedzkp.org](https://semaphore.appliedzkp.org/docs/technical-reference/contracts).
+
+---
+
+## 🛠 Install
+
+### npm or yarn
+
+Install the `@semaphore-protocol/contracts` package with npm:
+
+```bash
+npm i @semaphore-protocol/contracts
+```
+
+or yarn:
+
+```bash
+yarn add @semaphore-protocol/contracts
+```

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";
@@ -8,89 +8,149 @@ 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;
-
-  /// @dev Gets a group id and returns the group admin address.
-  mapping(uint256 => address) public groupAdmins;
-
-  /// @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");
-    _;
-  }
-
-  /// @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");
-    _;
-  }
-
-  /// @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++) {
-      verifiers[_verifiers[i].merkleTreeDepth] = IVerifier(_verifiers[i].contractAddress);
+    /// @dev Gets a tree depth and returns its verifier address.
+    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) {
+        if (groupAdmins[groupId] != _msgSender()) {
+            revert Semaphore__CallerIsNotTheGroupAdmin();
+        }
+        _;
+    }
+
+    /// @dev Checks if there is a verifier for the given tree depth.
+    /// @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; ) {
+            verifiers[_verifiers[i].merkleTreeDepth] = IVerifier(_verifiers[i].contractAddress);
+
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    /// @dev See {ISemaphore-createGroup}.
+    function createGroup(
+        uint256 groupId,
+        uint256 merkleTreeDepth,
+        uint256 zeroValue,
+        address admin
+    ) 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);
+    }
+
+    /// @dev See {ISemaphore-updateGroupAdmin}.
+    function updateGroupAdmin(uint256 groupId, address newAdmin) external override onlyGroupAdmin(groupId) {
+        groupAdmins[groupId] = newAdmin;
+
+        emit GroupAdminUpdated(groupId, _msgSender(), newAdmin);
+    }
+
+    /// @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}.
+    function removeMember(
+        uint256 groupId,
+        uint256 identityCommitment,
+        uint256[] calldata proofSiblings,
+        uint8[] calldata proofPathIndices
+    ) external override onlyGroupAdmin(groupId) {
+        _removeMember(groupId, identityCommitment, proofSiblings, proofPathIndices);
+    }
+
+    /// @dev See {ISemaphore-verifyProof}.
+    function verifyProof(
+        uint256 groupId,
+        uint256 merkleTreeRoot,
+        bytes32 signal,
+        uint256 nullifierHash,
+        uint256 externalNullifier,
+        uint256[8] calldata proof
+    ) external override {
+        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();
+            }
+        }
+
+        uint256 merkleTreeDepth = getMerkleTreeDepth(groupId);
+
+        IVerifier verifier = verifiers[merkleTreeDepth];
+
+        _verifyProof(signal, merkleTreeRoot, nullifierHash, externalNullifier, proof, verifier);
+
+        _saveNullifierHash(nullifierHash);
+
+        emit ProofVerified(groupId, signal);
     }
-  }
-
-  /// @dev See {ISemaphore-createGroup}.
-  function createGroup(
-    uint256 groupId,
-    uint8 depth,
-    uint256 zeroValue,
-    address admin
-  ) external override onlySupportedDepth(depth) {
-    _createGroup(groupId, depth, zeroValue);
-
-    groupAdmins[groupId] = admin;
-
-    emit GroupAdminUpdated(groupId, address(0), admin);
-  }
-
-  /// @dev See {ISemaphore-updateGroupAdmin}.
-  function updateGroupAdmin(uint256 groupId, address newAdmin) external override onlyGroupAdmin(groupId) {
-    groupAdmins[groupId] = newAdmin;
-
-    emit GroupAdminUpdated(groupId, _msgSender(), newAdmin);
-  }
-
-  /// @dev See {ISemaphore-addMember}.
-  function addMember(uint256 groupId, uint256 identityCommitment) external override onlyGroupAdmin(groupId) {
-    _addMember(groupId, identityCommitment);
-  }
-
-  /// @dev See {ISemaphore-removeMember}.
-  function removeMember(
-    uint256 groupId,
-    uint256 identityCommitment,
-    uint256[] calldata proofSiblings,
-    uint8[] calldata proofPathIndices
-  ) external override onlyGroupAdmin(groupId) {
-    _removeMember(groupId, identityCommitment, proofSiblings, proofPathIndices);
-  }
-
-  /// @dev See {ISemaphore-verifyProof}.
-  function verifyProof(
-    uint256 groupId,
-    bytes32 signal,
-    uint256 nullifierHash,
-    uint256 externalNullifier,
-    uint256[8] calldata proof
-  ) external override {
-    uint256 root = getRoot(groupId);
-    uint8 depth = getDepth(groupId);
-
-    require(depth != 0, "Semaphore: group does not exist");
-
-    IVerifier verifier = verifiers[depth];
-
-    _verifyProof(signal, root, nullifierHash, externalNullifier, proof, verifier);
-
-    _saveNullifierHash(nullifierHash);
-
-    emit ProofVerified(groupId, signal);
-  }
 }

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";
@@ -10,50 +10,52 @@ import "../interfaces/IVerifier.sol";
 /// nullifier to prevent double-signaling. External nullifier and Merkle trees (i.e. groups) must be
 /// managed externally.
 contract SemaphoreCore is ISemaphoreCore {
-  /// @dev Gets a nullifier hash and returns true or false.
-  /// It is used to prevent double-signaling.
-  mapping(uint256 => bool) internal nullifierHashes;
+    /// @dev Gets a nullifier hash and returns true or false.
+    /// It is used to prevent double-signaling.
+    mapping(uint256 => bool) internal nullifierHashes;
 
-  /// @dev Asserts that no nullifier already exists and if the zero-knowledge proof is valid.
-  /// Otherwise it reverts.
-  /// @param signal: Semaphore signal.
-  /// @param root: Root of the Merkle tree.
-  /// @param nullifierHash: Nullifier hash.
-  /// @param externalNullifier: External nullifier.
-  /// @param proof: Zero-knowledge proof.
-  /// @param verifier: Verifier address.
-  function _verifyProof(
-    bytes32 signal,
-    uint256 root,
-    uint256 nullifierHash,
-    uint256 externalNullifier,
-    uint256[8] calldata proof,
-    IVerifier verifier
-  ) internal view {
-    require(!nullifierHashes[nullifierHash], "SemaphoreCore: you cannot use the same nullifier twice");
+    /// @dev Asserts that no nullifier already exists and if the zero-knowledge proof is valid.
+    /// Otherwise it reverts.
+    /// @param signal: Semaphore signal.
+    /// @param root: Root of the Merkle tree.
+    /// @param nullifierHash: Nullifier hash.
+    /// @param externalNullifier: External nullifier.
+    /// @param proof: Zero-knowledge proof.
+    /// @param verifier: Verifier address.
+    function _verifyProof(
+        bytes32 signal,
+        uint256 root,
+        uint256 nullifierHash,
+        uint256 externalNullifier,
+        uint256[8] calldata proof,
+        IVerifier verifier
+    ) internal view {
+        if (nullifierHashes[nullifierHash]) {
+            revert Semaphore__YouAreUsingTheSameNillifierTwice();
+        }
 
-    uint256 signalHash = _hashSignal(signal);
+        uint256 signalHash = _hashSignal(signal);
 
-    verifier.verifyProof(
-      [proof[0], proof[1]],
-      [[proof[2], proof[3]], [proof[4], proof[5]]],
-      [proof[6], proof[7]],
-      [root, nullifierHash, signalHash, externalNullifier]
-    );
-  }
+        verifier.verifyProof(
+            [proof[0], proof[1]],
+            [[proof[2], proof[3]], [proof[4], proof[5]]],
+            [proof[6], proof[7]],
+            [root, nullifierHash, signalHash, externalNullifier]
+        );
+    }
 
-  /// @dev Stores the nullifier hash to prevent double-signaling.
-  /// Attention! Remember to call it when you verify a proof if you
-  /// need to prevent double-signaling.
-  /// @param nullifierHash: Semaphore nullifier hash.
-  function _saveNullifierHash(uint256 nullifierHash) internal {
-    nullifierHashes[nullifierHash] = true;
-  }
+    /// @dev Stores the nullifier hash to prevent double-signaling.
+    /// Attention! Remember to call it when you verify a proof if you
+    /// need to prevent double-signaling.
+    /// @param nullifierHash: Semaphore nullifier hash.
+    function _saveNullifierHash(uint256 nullifierHash) internal {
+        nullifierHashes[nullifierHash] = true;
+    }
 
-  /// @dev Creates a keccak256 hash of the signal.
-  /// @param signal: Semaphore signal.
-  /// @return Hash of the signal.
-  function _hashSignal(bytes32 signal) private pure returns (uint256) {
-    return uint256(keccak256(abi.encodePacked(signal))) >> 8;
-  }
+    /// @dev Creates a keccak256 hash of the signal.
+    /// @param signal: Semaphore signal.
+    /// @return Hash of the signal.
+    function _hashSignal(bytes32 signal) private pure returns (uint256) {
+        return uint256(keccak256(abi.encodePacked(signal))) >> 8;
+    }
 }

package/base/SemaphoreGroups.sol

@@ -1,83 +1,117 @@
 //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.
 /// @dev The following code allows you to create groups, add and remove members.
 /// You can use getters to obtain informations about groups (root, depth, number of leaves).
 abstract contract SemaphoreGroups is Context, ISemaphoreGroups {
-  using IncrementalBinaryTree for IncrementalTreeData;
-
-  /// @dev Gets a group id and returns the group/tree data.
-  mapping(uint256 => IncrementalTreeData) internal groups;
-
-  /// @dev Creates a new group by initializing the associated tree.
-  /// @param groupId: Id of the group.
-  /// @param depth: Depth of the tree.
-  /// @param zeroValue: Zero value of the tree.
-  function _createGroup(
-    uint256 groupId,
-    uint8 depth,
-    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");
-
-    groups[groupId].init(depth, zeroValue);
-
-    emit GroupCreated(groupId, depth, 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");
-
-    groups[groupId].insert(identityCommitment);
-
-    uint256 root = getRoot(groupId);
-
-    emit MemberAdded(groupId, identityCommitment, root);
-  }
-
-  /// @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 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
-  ) internal virtual {
-    require(getDepth(groupId) != 0, "SemaphoreGroups: group does not exist");
-
-    groups[groupId].remove(identityCommitment, proofSiblings, proofPathIndices);
-
-    uint256 root = getRoot(groupId);
-
-    emit MemberRemoved(groupId, identityCommitment, root);
-  }
-
-  /// @dev See {ISemaphoreGroups-getRoot}.
-  function getRoot(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) {
-    return groups[groupId].depth;
-  }
-
-  /// @dev See {ISemaphoreGroups-getNumberOfLeaves}.
-  function getNumberOfLeaves(uint256 groupId) public view virtual override returns (uint256) {
-    return groups[groupId].numberOfLeaves;
-  }
+    using IncrementalBinaryTree for IncrementalTreeData;
+
+    /// @dev Gets a group id and returns the group/tree data.
+    mapping(uint256 => IncrementalTreeData) internal groups;
+
+    /// @dev Creates a new group by initializing the associated tree.
+    /// @param groupId: Id of the group.
+    /// @param merkleTreeDepth: Depth of the tree.
+    /// @param zeroValue: Zero value of the tree.
+    function _createGroup(
+        uint256 groupId,
+        uint256 merkleTreeDepth,
+        uint256 zeroValue
+    ) internal virtual {
+        if (groupId >= SNARK_SCALAR_FIELD) {
+            revert Semaphore__GroupIdIsNotLessThanSnarkScalarField();
+        }
+
+        if (getMerkleTreeDepth(groupId) != 0) {
+            revert Semaphore__GroupAlreadyExists();
+        }
+
+        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 {
+        if (getMerkleTreeDepth(groupId) == 0) {
+            revert Semaphore__GroupDoesNotExist();
+        }
+
+        groups[groupId].insert(identityCommitment);
+
+        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 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 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
+    ) internal virtual {
+        if (getMerkleTreeRoot(groupId) == 0) {
+            revert Semaphore__GroupDoesNotExist();
+        }
+
+        groups[groupId].remove(identityCommitment, proofSiblings, proofPathIndices);
+
+        uint256 merkleTreeRoot = getMerkleTreeRoot(groupId);
+
+        emit MemberRemoved(groupId, identityCommitment, merkleTreeRoot);
+    }
+
+    /// @dev See {ISemaphoreGroups-getMerkleTreeRoot}.
+    function getMerkleTreeRoot(uint256 groupId) public view virtual override returns (uint256) {
+        return groups[groupId].root;
+    }
+
+    /// @dev See {ISemaphoreGroups-getMerkleTreeDepth}.
+    function getMerkleTreeDepth(uint256 groupId) public view virtual override returns (uint256) {
+        return groups[groupId].depth;
+    }
+
+    /// @dev See {ISemaphoreGroups-getNumberOfMerkleTreeLeaves}.
+    function getNumberOfMerkleTreeLeaves(uint256 groupId) public view virtual override returns (uint256) {
+        return groups[groupId].numberOfLeaves;
+    }
 }