@semaphore-protocol/contracts 3.15.2 → 4.0.0-alpha

package/interfaces/ISemaphore.sol

@@ -1,28 +1,22 @@
 //SPDX-License-Identifier: MIT
-pragma solidity 0.8.4;
+pragma solidity 0.8.23;
 
 /// @title Semaphore contract interface.
 interface ISemaphore {
-    error Semaphore__CallerIsNotTheGroupAdmin();
+    error Semaphore__GroupHasNoMembers();
     error Semaphore__MerkleTreeDepthIsNotSupported();
     error Semaphore__MerkleTreeRootIsExpired();
     error Semaphore__MerkleTreeRootIsNotPartOfTheGroup();
-    error Semaphore__YouAreUsingTheSameNillifierTwice();
+    error Semaphore__YouAreUsingTheSameNullifierTwice();
+    error Semaphore__InvalidProof();
 
-    /// It defines all the group parameters, in addition to those in the Merkle tree.
+    /// It defines all the group parameters used by Semaphore.sol.
     struct Group {
-        address admin;
         uint256 merkleTreeDuration;
         mapping(uint256 => uint256) merkleRootCreationDates;
-        mapping(uint256 => bool) nullifierHashes;
+        mapping(uint256 => bool) nullifiers;
     }
 
-    /// @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 Emitted when the Merkle tree duration of a group is updated.
     /// @param groupId: Id of the group.
     /// @param oldMerkleTreeDuration: Old Merkle tree duration of the group.
@@ -33,53 +27,34 @@ interface ISemaphore {
         uint256 newMerkleTreeDuration
     );
 
-    /// @dev Emitted when a Semaphore proof is verified.
+    /// @dev Emitted when a Semaphore proof is validated.
     /// @param groupId: Id of the group.
+    /// @param merkleTreeDepth: Depth of the Merkle tree.
     /// @param merkleTreeRoot: Root of the Merkle tree.
-    /// @param nullifierHash: Nullifier hash.
-    /// @param externalNullifier: External nullifier.
-    /// @param signal: Semaphore signal.
-    event ProofVerified(
+    /// @param nullifier: Nullifier.
+    /// @param message: Semaphore message.
+    /// @param scope: Scope.
+    /// @param proof: Zero-knowledge proof.
+    event ProofValidated(
         uint256 indexed groupId,
+        uint256 merkleTreeDepth,
         uint256 indexed merkleTreeRoot,
-        uint256 nullifierHash,
-        uint256 indexed externalNullifier,
-        uint256 signal
+        uint256 nullifier,
+        uint256 message,
+        uint256 indexed scope,
+        uint256[8] proof
     );
 
-    /// @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,
-        uint256 signal,
-        uint256 nullifierHash,
-        uint256 externalNullifier,
-        uint256[8] calldata proof
-    ) 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 admin: Admin of the group.
-    function createGroup(uint256 groupId, uint256 depth, address admin) external;
+    /// @dev See {SemaphoreGroups-_createGroup}.
+    function createGroup(uint256 groupId, address admin) external;
 
-    /// @dev Creates a new group. Only the admin will be able to add or remove members.
+    /// @dev It creates a group with a custom Merkle tree duration.
     /// @param groupId: Id of the group.
-    /// @param depth: Depth 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, address admin, uint256 merkleTreeRootDuration) external;
+    /// @param merkleTreeDuration: Merkle tree duration.
+    function createGroup(uint256 groupId, address admin, uint256 merkleTreeDuration) external;
 
-    /// @dev Updates the group admin.
-    /// @param groupId: Id of the group.
-    /// @param newAdmin: New admin of the group.
+    /// @dev See {SemaphoreGroups-_updateGroupAdmin}.
     function updateGroupAdmin(uint256 groupId, address newAdmin) external;
 
     /// @dev Updates the group Merkle tree duration.
@@ -87,41 +62,57 @@ interface ISemaphore {
     /// @param newMerkleTreeDuration: New Merkle tree duration.
     function updateGroupMerkleTreeDuration(uint256 groupId, uint256 newMerkleTreeDuration) external;
 
-    /// @dev Adds a new member to an existing group.
-    /// @param groupId: Id of the group.
-    /// @param identityCommitment: New identity commitment.
+    /// @dev See {SemaphoreGroups-_addMember}.
     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.
+    /// @dev See {SemaphoreGroups-_addMembers}.
     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.
-    /// @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.
+    /// @dev See {SemaphoreGroups-_updateMember}.
     function updateMember(
         uint256 groupId,
-        uint256 identityCommitment,
+        uint256 oldIdentityCommitment,
         uint256 newIdentityCommitment,
-        uint256[] calldata proofSiblings,
-        uint8[] calldata proofPathIndices
+        uint256[] calldata merkleProofSiblings
     ) 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.
+    /// @dev See {SemaphoreGroups-_removeMember}.
+    function removeMember(uint256 groupId, uint256 identityCommitment, uint256[] calldata merkleProofSiblings) 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 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(
+    /// @param merkleTreeDepth: Depth of the Merkle tree.
+    /// @param merkleTreeRoot: Root of the Merkle tree.
+    /// @param nullifier: Nullifier.
+    /// @param message: Semaphore message.
+    /// @param scope: Scope.
+    /// @param proof: Zero-knowledge proof.
+    function validateProof(
         uint256 groupId,
-        uint256 identityCommitment,
-        uint256[] calldata proofSiblings,
-        uint8[] calldata proofPathIndices
+        uint256 merkleTreeDepth,
+        uint256 merkleTreeRoot,
+        uint256 nullifier,
+        uint256 message,
+        uint256 scope,
+        uint256[8] calldata proof
     ) external;
+
+    /// @dev Verifies a zero-knowledge proof by returning true or false.
+    /// @param groupId: Id of the group.
+    /// @param merkleTreeDepth: Depth of the Merkle tree.
+    /// @param merkleTreeRoot: Root of the Merkle tree.
+    /// @param nullifier: Nullifier.
+    /// @param message: Semaphore message.
+    /// @param scope: Scope.
+    /// @param proof: Zero-knowledge proof.
+    function verifyProof(
+        uint256 groupId,
+        uint256 merkleTreeDepth,
+        uint256 merkleTreeRoot,
+        uint256 nullifier,
+        uint256 message,
+        uint256 scope,
+        uint256[8] calldata proof
+    ) external view returns (bool);
 }

package/interfaces/ISemaphoreGroups.sol

@@ -1,24 +1,41 @@
 //SPDX-License-Identifier: MIT
-pragma solidity 0.8.4;
+pragma solidity 0.8.23;
 
 /// @title SemaphoreGroups contract interface.
 interface ISemaphoreGroups {
     error Semaphore__GroupDoesNotExist();
     error Semaphore__GroupAlreadyExists();
+    error Semaphore__CallerIsNotTheGroupAdmin();
 
     /// @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);
+    event GroupCreated(uint256 indexed groupId);
+
+    /// @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 Emitted when a new identity commitment is added.
     /// @param groupId: Group id of the group.
-    /// @param index: Identity commitment index.
+    /// @param index: Merkle tree leaf index.
     /// @param identityCommitment: New identity commitment.
     /// @param merkleTreeRoot: New root hash of the tree.
     event MemberAdded(uint256 indexed groupId, uint256 index, uint256 identityCommitment, uint256 merkleTreeRoot);
 
+    /// @dev Emitted when many identity commitments are added at the same time.
+    /// @param groupId: Group id of the group.
+    /// @param startIndex: Index of the first element of the new identity commitments in the merkle tree.
+    /// @param identityCommitments: The new identity commitments.
+    /// @param merkleTreeRoot: New root hash of the tree.
+    event MembersAdded(
+        uint256 indexed groupId,
+        uint256 startIndex,
+        uint256[] identityCommitments,
+        uint256 merkleTreeRoot
+    );
+
     /// @dev Emitted when an identity commitment is updated.
     /// @param groupId: Group id of the group.
     /// @param index: Identity commitment index.
@@ -40,6 +57,18 @@ interface ISemaphoreGroups {
     /// @param merkleTreeRoot: New root hash of the tree.
     event MemberRemoved(uint256 indexed groupId, uint256 index, uint256 identityCommitment, uint256 merkleTreeRoot);
 
+    /// @dev Returns true if a member exists in a group.
+    /// @param groupId: Id of the group.
+    /// @param identityCommitment: Identity commitment.
+    /// @return True if the member exists, false otherwise.
+    function hasMember(uint256 groupId, uint256 identityCommitment) external view returns (bool);
+
+    /// @dev Returns the index of a member.
+    /// @param groupId: Id of the group.
+    /// @param identityCommitment: Identity commitment.
+    /// @return Index of member.
+    function indexOf(uint256 groupId, uint256 identityCommitment) external view returns (uint256);
+
     /// @dev Returns the last root hash of a group.
     /// @param groupId: Id of the group.
     /// @return Root hash of the group.
@@ -53,5 +82,5 @@ interface ISemaphoreGroups {
     /// @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);
+    function getMerkleTreeSize(uint256 groupId) external view returns (uint256);
 }

package/interfaces/ISemaphoreVerifier.sol

@@ -1,37 +1,13 @@
 //SPDX-License-Identifier: MIT
-pragma solidity 0.8.4;
-
-import "../base/Pairing.sol";
+pragma solidity 0.8.23;
 
 /// @title SemaphoreVerifier contract interface.
 interface ISemaphoreVerifier {
-    struct VerificationKey {
-        Pairing.G1Point alfa1;
-        Pairing.G2Point beta2;
-        Pairing.G2Point gamma2;
-        Pairing.G2Point delta2;
-        Pairing.G1Point[] IC;
-    }
-
-    struct Proof {
-        Pairing.G1Point A;
-        Pairing.G2Point B;
-        Pairing.G1Point C;
-    }
-
-    /// @dev Verifies whether a Semaphore proof is valid.
-    /// @param merkleTreeRoot: Root of the Merkle tree.
-    /// @param nullifierHash: Nullifier hash.
-    /// @param signal: Semaphore signal.
-    /// @param externalNullifier: External nullifier.
-    /// @param proof: Zero-knowledge proof.
-    /// @param merkleTreeDepth: Depth of the tree.
     function verifyProof(
-        uint256 merkleTreeRoot,
-        uint256 nullifierHash,
-        uint256 signal,
-        uint256 externalNullifier,
-        uint256[8] calldata proof,
-        uint256 merkleTreeDepth
-    ) external view;
+        uint[2] calldata _pA,
+        uint[2][2] calldata _pB,
+        uint[2] calldata _pC,
+        uint[4] calldata _pubSignals,
+        uint merkleTreeDepth
+    ) external view returns (bool);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@semaphore-protocol/contracts",
-  "version": "3.15.2",
+  "version": "4.0.0-alpha",
   "description": "Semaphore contracts to manage groups and broadcast anonymous signals.",
   "license": "MIT",
   "files": [
@@ -30,7 +30,6 @@
     "access": "public"
   },
   "dependencies": {
-    "@openzeppelin/contracts": "4.7.3",
-    "@zk-kit/incremental-merkle-tree.sol": "1.3.3"
+    "@zk-kit/imt.sol": "2.0.0-beta.5"
   }
 }

package/base/Pairing.sol

@@ -1,151 +0,0 @@
-// Copyright 2017 Christian Reitwiessner
-// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-// The following Pairing library is a modified version adapted to Semaphore.
-//
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.4;
-
-library Pairing {
-    error InvalidProof();
-
-    // The prime q in the base field F_q for G1
-    uint256 constant BASE_MODULUS = 21888242871839275222246405745257275088696311157297823662689037894645226208583;
-
-    // The prime modulus of the scalar field of G1.
-    uint256 constant SCALAR_MODULUS = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
-
-    struct G1Point {
-        uint256 X;
-        uint256 Y;
-    }
-
-    // Encoding of field elements is: X[0] * z + X[1]
-    struct G2Point {
-        uint256[2] X;
-        uint256[2] Y;
-    }
-
-    /// @return the generator of G1
-    function P1() public pure returns (G1Point memory) {
-        return G1Point(1, 2);
-    }
-
-    /// @return the generator of G2
-    function P2() public pure returns (G2Point memory) {
-        return
-            G2Point(
-                [
-                    11559732032986387107991004021392285783925812861821192530917403151452391805634,
-                    10857046999023057135944570762232829481370756359578518086990519993285655852781
-                ],
-                [
-                    4082367875863433681332203403145435568316851327593401208105741076214120093531,
-                    8495653923123431417604973247489272438418190587263600148770280649306958101930
-                ]
-            );
-    }
-
-    /// @return r the negation of p, i.e. p.addition(p.negate()) should be zero.
-    function negate(G1Point memory p) public pure returns (G1Point memory r) {
-        if (p.X == 0 && p.Y == 0) {
-            return G1Point(0, 0);
-        }
-
-        // Validate input or revert
-        if (p.X >= BASE_MODULUS || p.Y >= BASE_MODULUS) {
-            revert InvalidProof();
-        }
-
-        // We know p.Y > 0 and p.Y < BASE_MODULUS.
-        return G1Point(p.X, BASE_MODULUS - p.Y);
-    }
-
-    /// @return r the sum of two points of G1
-    function addition(G1Point memory p1, G1Point memory p2) public view returns (G1Point memory r) {
-        // By EIP-196 all input is validated to be less than the BASE_MODULUS and form points
-        // on the curve.
-        uint256[4] memory input;
-
-        input[0] = p1.X;
-        input[1] = p1.Y;
-        input[2] = p2.X;
-        input[3] = p2.Y;
-
-        bool success;
-
-        // solium-disable-next-line security/no-inline-assembly
-        assembly {
-            success := staticcall(sub(gas(), 2000), 6, input, 0xc0, r, 0x60)
-        }
-
-        if (!success) {
-            revert InvalidProof();
-        }
-    }
-
-    /// @return r the product of a point on G1 and a scalar, i.e.
-    /// p == p.scalar_mul(1) and p.addition(p) == p.scalar_mul(2) for all points p.
-    function scalar_mul(G1Point memory p, uint256 s) public view returns (G1Point memory r) {
-        // By EIP-196 the values p.X and p.Y are verified to be less than the BASE_MODULUS and
-        // form a valid point on the curve. But the scalar is not verified, so we do that explicitly.
-        if (s >= SCALAR_MODULUS) {
-            revert InvalidProof();
-        }
-
-        uint256[3] memory input;
-
-        input[0] = p.X;
-        input[1] = p.Y;
-        input[2] = s;
-
-        bool success;
-
-        // solium-disable-next-line security/no-inline-assembly
-        assembly {
-            success := staticcall(sub(gas(), 2000), 7, input, 0x80, r, 0x60)
-        }
-
-        if (!success) {
-            revert InvalidProof();
-        }
-    }
-
-    /// Asserts the pairing check
-    /// e(p1[0], p2[0]) *  .... * e(p1[n], p2[n]) == 1
-    /// For example pairing([P1(), P1().negate()], [P2(), P2()]) should succeed
-    function pairingCheck(G1Point[] memory p1, G2Point[] memory p2) public view {
-        // By EIP-197 all input is verified to be less than the BASE_MODULUS and form elements in their
-        // respective groups of the right order.
-        if (p1.length != p2.length) {
-            revert InvalidProof();
-        }
-
-        uint256 elements = p1.length;
-        uint256 inputSize = elements * 6;
-        uint256[] memory input = new uint256[](inputSize);
-
-        for (uint256 i = 0; i < elements; i++) {
-            input[i * 6 + 0] = p1[i].X;
-            input[i * 6 + 1] = p1[i].Y;
-            input[i * 6 + 2] = p2[i].X[0];
-            input[i * 6 + 3] = p2[i].X[1];
-            input[i * 6 + 4] = p2[i].Y[0];
-            input[i * 6 + 5] = p2[i].Y[1];
-        }
-
-        uint256[1] memory out;
-        bool success;
-
-        // solium-disable-next-line security/no-inline-assembly
-        assembly {
-            success := staticcall(sub(gas(), 2000), 8, add(input, 0x20), mul(inputSize, 0x20), out, 0x20)
-        }
-
-        if (!success || out[0] != 1) {
-            revert InvalidProof();
-        }
-    }
-}

package/extensions/SemaphoreVoting.sol

@@ -1,96 +0,0 @@
-//SPDX-License-Identifier: MIT
-pragma solidity 0.8.4;
-
-import "../interfaces/ISemaphoreVoting.sol";
-import "../interfaces/ISemaphoreVerifier.sol";
-import "../base/SemaphoreGroups.sol";
-
-/// @title Semaphore voting contract.
-/// @notice It allows users to vote anonymously in a poll.
-/// @dev The following code allows you to create polls, add voters and allow them to vote anonymously.
-contract SemaphoreVoting is ISemaphoreVoting, SemaphoreGroups {
-    ISemaphoreVerifier public verifier;
-
-    /// @dev Gets a poll id and returns the poll data.
-    mapping(uint256 => Poll) internal polls;
-
-    /// @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 Initializes the Semaphore verifier used to verify the user's ZK proofs.
-    /// @param _verifier: Semaphore verifier address.
-    constructor(ISemaphoreVerifier _verifier) {
-        verifier = _verifier;
-    }
-
-    /// @dev See {ISemaphoreVoting-createPoll}.
-    function createPoll(uint256 pollId, address coordinator, uint256 merkleTreeDepth) public override {
-        if (merkleTreeDepth < 16 || merkleTreeDepth > 32) {
-            revert Semaphore__MerkleTreeDepthIsNotSupported();
-        }
-
-        _createGroup(pollId, merkleTreeDepth);
-
-        polls[pollId].coordinator = 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();
-        }
-
-        _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();
-        }
-
-        polls[pollId].state = PollState.Ongoing;
-
-        emit PollStarted(pollId, _msgSender(), encryptionKey);
-    }
-
-    /// @dev See {ISemaphoreVoting-castVote}.
-    function castVote(uint256 vote, uint256 nullifierHash, uint256 pollId, uint256[8] calldata proof) public override {
-        if (polls[pollId].state != PollState.Ongoing) {
-            revert Semaphore__PollIsNotOngoing();
-        }
-
-        if (polls[pollId].nullifierHashes[nullifierHash]) {
-            revert Semaphore__YouAreUsingTheSameNillifierTwice();
-        }
-
-        uint256 merkleTreeDepth = getMerkleTreeDepth(pollId);
-        uint256 merkleTreeRoot = getMerkleTreeRoot(pollId);
-
-        verifier.verifyProof(merkleTreeRoot, nullifierHash, vote, pollId, proof, merkleTreeDepth);
-
-        polls[pollId].nullifierHashes[nullifierHash] = true;
-
-        emit VoteAdded(pollId, vote);
-    }
-
-    /// @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;
-
-        emit PollEnded(pollId, _msgSender(), decryptionKey);
-    }
-}

package/extensions/SemaphoreWhistleblowing.sol

@@ -1,77 +0,0 @@
-//SPDX-License-Identifier: MIT
-pragma solidity 0.8.4;
-
-import "../interfaces/ISemaphoreWhistleblowing.sol";
-import "../interfaces/ISemaphoreVerifier.sol";
-import "../base/SemaphoreGroups.sol";
-
-/// @title Semaphore whistleblowing contract.
-/// @notice It allows users to leak information anonymously .
-/// @dev The following code allows you to create entities for whistleblowers (e.g. non-profit
-/// organization, newspaper) and allow them to leak anonymously.
-/// Leaks can be IPFS hashes, permanent links or other kinds of references.
-contract SemaphoreWhistleblowing is ISemaphoreWhistleblowing, SemaphoreGroups {
-    ISemaphoreVerifier public verifier;
-
-    /// @dev Gets an entity id and return its editor address.
-    mapping(uint256 => address) private entities;
-
-    /// @dev Checks if the editor is the transaction sender.
-    /// @param entityId: Id of the entity.
-    modifier onlyEditor(uint256 entityId) {
-        if (entities[entityId] != _msgSender()) {
-            revert Semaphore__CallerIsNotTheEditor();
-        }
-
-        _;
-    }
-
-    /// @dev Initializes the Semaphore verifier used to verify the user's ZK proofs.
-    /// @param _verifier: Semaphore verifier address.
-    constructor(ISemaphoreVerifier _verifier) {
-        verifier = _verifier;
-    }
-
-    /// @dev See {ISemaphoreWhistleblowing-createEntity}.
-    function createEntity(uint256 entityId, address editor, uint256 merkleTreeDepth) public override {
-        if (merkleTreeDepth < 16 || merkleTreeDepth > 32) {
-            revert Semaphore__MerkleTreeDepthIsNotSupported();
-        }
-
-        _createGroup(entityId, merkleTreeDepth);
-
-        entities[entityId] = editor;
-
-        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(
-        uint256 leak,
-        uint256 nullifierHash,
-        uint256 entityId,
-        uint256[8] calldata proof
-    ) public override {
-        uint256 merkleTreeDepth = getMerkleTreeDepth(entityId);
-        uint256 merkleTreeRoot = getMerkleTreeRoot(entityId);
-
-        verifier.verifyProof(merkleTreeRoot, nullifierHash, leak, entityId, proof, merkleTreeDepth);
-
-        emit LeakPublished(entityId, leak);
-    }
-}