@semaphore-protocol/contracts 0.1.0 → 0.2.0

package/Semaphore.sol

@@ -8,89 +8,89 @@ 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(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 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);
     }
-  }
-
-  /// @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/SemaphoreCore.sol

@@ -10,50 +10,50 @@ 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 {
+        require(!nullifierHashes[nullifierHash], "SemaphoreCore: you cannot use the same nullifier twice");
 
-    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

@@ -10,74 +10,74 @@ import "@openzeppelin/contracts/utils/Context.sol";
 /// @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 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;
+    }
 }

package/extensions/SemaphoreVoting.sol

@@ -8,100 +8,100 @@ 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(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 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) {
+        require(polls[pollId].coordinator == _msgSender(), "SemaphoreVoting: caller is not the poll coordinator");
+        _;
+    }
 
-  /// @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,
+        uint8 depth
+    ) public override {
+        require(address(verifiers[depth]) != address(0), "SemaphoreVoting: depth value is not supported");
 
-    _createGroup(pollId, depth, 0);
+        _createGroup(pollId, depth, 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) {
-    require(polls[pollId].state == PollState.Created, "SemaphoreVoting: voters can only be added before voting");
+    /// @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) {
-    require(polls[pollId].state == PollState.Created, "SemaphoreVoting: poll has already been started");
+    /// @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];
 
-    require(poll.state == PollState.Ongoing, "SemaphoreVoting: vote can only be cast in an ongoing poll");
+        require(poll.state == PollState.Ongoing, "SemaphoreVoting: vote can only be cast in an ongoing poll");
 
-    uint8 depth = getDepth(pollId);
-    uint256 root = getRoot(pollId);
-    IVerifier verifier = verifiers[depth];
+        uint8 depth = getDepth(pollId);
+        uint256 root = getRoot(pollId);
+        IVerifier verifier = verifiers[depth];
 
-    _verifyProof(vote, root, nullifierHash, pollId, proof, verifier);
+        _verifyProof(vote, root, 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) {
+        require(polls[pollId].state == PollState.Ongoing, "SemaphoreVoting: poll is not ongoing");
 
-    polls[pollId].state = PollState.Ended;
+        polls[pollId].state = PollState.Ended;
 
-    emit PollEnded(pollId, _msgSender(), decryptionKey);
-  }
+        emit PollEnded(pollId, _msgSender(), decryptionKey);
+    }
 }