@semaphore-protocol/contracts 2.1.0 → 2.4.0

package/README.md

@@ -7,7 +7,7 @@
 
 <p align="center">
     <a href="https://github.com/semaphore-protocol">
-        <img src="https://img.shields.io/badge/project-semaphore-blue.svg?style=flat-square">
+        <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">
@@ -34,7 +34,7 @@
             🔎 Issues
         </a>
         <span>&nbsp;&nbsp;|&nbsp;&nbsp;</span>
-        <a href="https://t.me/joinchat/B-PQx1U3GtAh--Z4Fwo56A">
+        <a href="https://discord.gg/6mSdGHnstH">
             🗣️ Chat &amp; Support
         </a>
     </h4>
@@ -59,3 +59,62 @@ or yarn:
 ```bash
 yarn add @semaphore-protocol/contracts
 ```
+
+## 📜 Usage
+
+### Compile contracts
+
+Compile the smart contracts with [Hardhat](https://hardhat.org/):
+
+```bash
+yarn compile
+```
+
+### Testing
+
+Run [Mocha](https://mochajs.org/) to test the contracts:
+
+```bash
+yarn test
+```
+
+You can also generate a test coverage report:
+
+```bash
+yarn test:coverage
+```
+
+Or a test gas report:
+
+```bash
+yarn test:report-gas
+```
+
+### Deploy contracts
+
+Deploy a verifier contract with depth = 20:
+
+```bash
+yarn deploy:verifier --depth 20
+```
+
+Deploy the `Semaphore.sol` contract with one verifier:
+
+```bash
+yarn deploy:semaphore --verifiers '[{"merkleTreeDepth": 20, "contractAddress": "0x06bcD633988c1CE7Bd134DbE2C12119b6f3E4bD1"}]'
+```
+
+Deploy all verifiers and Semaphore contract:
+
+```bash
+yarn deploy:all
+```
+
+If you want to deploy contracts in a specific network you can set up the `DEFAULT_NETWORK` variable in your `.env` file with the name of one of our supported networks (hardhat, localhost, goerli, arbitrum). Or you can specify it as option:
+
+```bash
+yarn deploy:all --network goerli
+yarn deploy:all --network localhost
+```
+
+If you want to deploy contracts on Goerli or Arbitrum, remember to provide a valid private key and an Infura API in your `.env` file.

package/Semaphore.sol

@@ -94,6 +94,25 @@ contract Semaphore is ISemaphore, SemaphoreCore, SemaphoreGroups {
         merkleTreeExpiries[groupId].rootCreationDates[merkleTreeRoot] = block.timestamp;
     }
 
+    /// @dev See {ISemaphore-addMembers}.
+    function addMembers(uint256 groupId, uint256[] calldata identityCommitments)
+        external
+        override
+        onlyGroupAdmin(groupId)
+    {
+        for (uint8 i = 0; i < identityCommitments.length; ) {
+            _addMember(groupId, identityCommitments[i]);
+
+            unchecked {
+                ++i;
+            }
+        }
+
+        uint256 merkleTreeRoot = getMerkleTreeRoot(groupId);
+
+        merkleTreeExpiries[groupId].rootCreationDates[merkleTreeRoot] = block.timestamp;
+    }
+
     /// @dev See {ISemaphore-updateMember}.
     function updateMember(
         uint256 groupId,
@@ -149,8 +168,8 @@ contract Semaphore is ISemaphore, SemaphoreCore, SemaphoreGroups {
 
         _verifyProof(signal, merkleTreeRoot, nullifierHash, externalNullifier, proof, verifier);
 
-        _saveNullifierHash(nullifierHash);
+        _saveNullifierHash(uint256(keccak256(abi.encodePacked(groupId, nullifierHash))));
 
-        emit ProofVerified(groupId, signal);
+        emit ProofVerified(groupId, merkleTreeRoot, nullifierHash, externalNullifier, signal);
     }
 }

package/base/SemaphoreGroups.sol

@@ -48,8 +48,9 @@ abstract contract SemaphoreGroups is Context, ISemaphoreGroups {
         groups[groupId].insert(identityCommitment);
 
         uint256 merkleTreeRoot = getMerkleTreeRoot(groupId);
+        uint256 index = getNumberOfMerkleTreeLeaves(groupId) - 1;
 
-        emit MemberAdded(groupId, identityCommitment, merkleTreeRoot);
+        emit MemberAdded(groupId, index, identityCommitment, merkleTreeRoot);
     }
 
     /// @dev Updates an identity commitment of an existing group. A proof of membership is
@@ -73,8 +74,9 @@ abstract contract SemaphoreGroups is Context, ISemaphoreGroups {
         groups[groupId].update(identityCommitment, newIdentityCommitment, proofSiblings, proofPathIndices);
 
         uint256 merkleTreeRoot = getMerkleTreeRoot(groupId);
+        uint256 index = proofPathIndicesToMemberIndex(proofPathIndices);
 
-        emit MemberUpdated(groupId, identityCommitment, newIdentityCommitment, merkleTreeRoot);
+        emit MemberUpdated(groupId, index, identityCommitment, newIdentityCommitment, merkleTreeRoot);
     }
 
     /// @dev Removes an identity commitment from an existing group. A proof of membership is
@@ -96,8 +98,9 @@ abstract contract SemaphoreGroups is Context, ISemaphoreGroups {
         groups[groupId].remove(identityCommitment, proofSiblings, proofPathIndices);
 
         uint256 merkleTreeRoot = getMerkleTreeRoot(groupId);
+        uint256 index = proofPathIndicesToMemberIndex(proofPathIndices);
 
-        emit MemberRemoved(groupId, identityCommitment, merkleTreeRoot);
+        emit MemberRemoved(groupId, index, identityCommitment, merkleTreeRoot);
     }
 
     /// @dev See {ISemaphoreGroups-getMerkleTreeRoot}.
@@ -114,4 +117,27 @@ abstract contract SemaphoreGroups is Context, ISemaphoreGroups {
     function getNumberOfMerkleTreeLeaves(uint256 groupId) public view virtual override returns (uint256) {
         return groups[groupId].numberOfLeaves;
     }
+
+    /// @dev Converts the path indices of a Merkle proof to the identity commitment index in the tree.
+    /// @param proofPathIndices: Path of the proof of membership.
+    /// @return Index of a group member.
+    function proofPathIndicesToMemberIndex(uint8[] calldata proofPathIndices) private pure returns (uint256) {
+        uint256 memberIndex = 0;
+
+        for (uint8 i = uint8(proofPathIndices.length); i > 0; ) {
+            if (memberIndex > 0 || proofPathIndices[i - 1] != 0) {
+                memberIndex *= 2;
+
+                if (proofPathIndices[i - 1] == 1) {
+                    memberIndex += 1;
+                }
+            }
+
+            unchecked {
+                --i;
+            }
+        }
+
+        return memberIndex;
+    }
 }

package/interfaces/ISemaphore.sol

@@ -29,8 +29,17 @@ interface ISemaphore {
 
     /// @dev Emitted when a Semaphore proof is verified.
     /// @param groupId: Id of the group.
+    /// @param merkleTreeRoot: Root of the Merkle tree.
+    /// @param externalNullifier: External nullifier.
+    /// @param nullifierHash: Nullifier hash.
     /// @param signal: Semaphore signal.
-    event ProofVerified(uint256 indexed groupId, bytes32 signal);
+    event ProofVerified(
+        uint256 indexed groupId,
+        uint256 merkleTreeRoot,
+        uint256 externalNullifier,
+        uint256 nullifierHash,
+        bytes32 signal
+    );
 
     /// @dev Saves the nullifier hash to avoid double signaling and emits an event
     /// if the zero-knowledge proof is valid.
@@ -85,6 +94,11 @@ interface ISemaphore {
     /// @param identityCommitment: New identity commitment.
     function addMember(uint256 groupId, uint256 identityCommitment) external;
 
+    /// @dev Adds new members to an existing group.
+    /// @param groupId: Id of the group.
+    /// @param identityCommitments: New identity commitments.
+    function addMembers(uint256 groupId, uint256[] calldata identityCommitments) 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.

package/interfaces/ISemaphoreGroups.sol

@@ -16,17 +16,20 @@ interface ISemaphoreGroups {
 
     /// @dev Emitted when a new identity commitment is added.
     /// @param groupId: Group id of the group.
+    /// @param index: Identity commitment index.
     /// @param identityCommitment: New identity commitment.
     /// @param merkleTreeRoot: New root hash of the tree.
-    event MemberAdded(uint256 indexed groupId, uint256 identityCommitment, uint256 merkleTreeRoot);
+    event MemberAdded(uint256 indexed groupId, uint256 index, 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 index: Identity commitment index.
+    /// @param identityCommitment: Existing identity commitment to be updated.
     /// @param newIdentityCommitment: New identity commitment.
     /// @param merkleTreeRoot: New root hash of the tree.
     event MemberUpdated(
         uint256 indexed groupId,
+        uint256 index,
         uint256 identityCommitment,
         uint256 newIdentityCommitment,
         uint256 merkleTreeRoot
@@ -34,9 +37,10 @@ interface ISemaphoreGroups {
 
     /// @dev Emitted when a new identity commitment is removed.
     /// @param groupId: Group id of the group.
+    /// @param index: Identity commitment index.
     /// @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);
+    event MemberRemoved(uint256 indexed groupId, uint256 index, uint256 identityCommitment, uint256 merkleTreeRoot);
 
     /// @dev Returns the last root hash of a group.
     /// @param groupId: Id of the group.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@semaphore-protocol/contracts",
-    "version": "2.1.0",
+    "version": "2.4.0",
     "description": "Semaphore contracts to manage groups and broadcast anonymous signals.",
     "license": "MIT",
     "files": [
@@ -20,11 +20,8 @@
         "circom",
         "proof-of-membership"
     ],
-    "homepage": "https://github.com/semaphore-protocol/semaphore.git#readme",
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/semaphore-protocol/semaphore.git.git"
-    },
+    "repository": "https://github.com/semaphore-protocol/semaphore",
+    "homepage": "https://github.com/semaphore-protocol/semaphore/tree/main/packages/contracts",
     "bugs": {
         "url": "https://github.com/semaphore-protocol/semaphore.git/issues"
     },