@maci-protocol/contracts 0.0.0-ci.2653bc0

package/contracts/crypto/Pairing.sol

@@ -0,0 +1,164 @@
+// SPDX-License-Identifier: MIT
+// 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.
+
+// 2019 OKIMS
+
+pragma solidity ^0.8.28;
+
+/// @title Pairing
+/// @notice A library implementing the alt_bn128 elliptic curve operations.
+library Pairing {
+  uint256 public constant PRIME_Q = 21888242871839275222246405745257275088696311157297823662689037894645226208583;
+
+  struct G1Point {
+    uint256 x;
+    uint256 y;
+  }
+
+  // Encoding of field elements is: X[0] * z + X[1]
+  struct G2Point {
+    uint256[2] x;
+    uint256[2] y;
+  }
+
+  /// @notice custom errors
+  error PairingAddFailed();
+  error PairingMulFailed();
+  error PairingOpcodeFailed();
+
+  /// @notice The negation of p, i.e. p.plus(p.negate()) should be zero.
+  function negate(G1Point memory p) internal pure returns (G1Point memory) {
+    // The prime q in the base field F_q for G1
+    if (p.x == 0 && p.y == 0) {
+      return G1Point(0, 0);
+    } else {
+      return G1Point(p.x, PRIME_Q - (p.y % PRIME_Q));
+    }
+  }
+
+  /// @notice r Returns the sum of two points of G1.
+  function plus(G1Point memory p1, G1Point memory p2) internal view returns (G1Point memory r) {
+    uint256[4] memory input;
+    input[0] = p1.x;
+    input[1] = p1.y;
+    input[2] = p2.x;
+    input[3] = p2.y;
+    bool success;
+
+    // solhint-disable-next-line no-inline-assembly
+    assembly {
+      success := staticcall(sub(gas(), 2000), 6, input, 0xc0, r, 0x60)
+      // Use "invalid" to make gas estimation work
+      switch success
+      case 0 {
+        invalid()
+      }
+    }
+
+    if (!success) {
+      revert PairingAddFailed();
+    }
+  }
+
+  /// @notice r Return the product of a point on G1 and a scalar, i.e.
+  ///         p == p.scalarMul(1) and p.plus(p) == p.scalarMul(2) for all
+  ///         points p.
+  function scalarMul(G1Point memory p, uint256 s) internal view returns (G1Point memory r) {
+    uint256[3] memory input;
+    input[0] = p.x;
+    input[1] = p.y;
+    input[2] = s;
+    bool success;
+    // solhint-disable-next-line no-inline-assembly
+    assembly {
+      success := staticcall(sub(gas(), 2000), 7, input, 0x80, r, 0x60)
+      // Use "invalid" to make gas estimation work
+      switch success
+      case 0 {
+        invalid()
+      }
+    }
+
+    if (!success) {
+      revert PairingMulFailed();
+    }
+  }
+
+  /// @return isValid The result of computing the pairing check
+  ///         e(p1[0], p2[0]) *  .... * e(p1[n], p2[n]) == 1
+  ///        For example,
+  ///        pairing([P1(), P1().negate()], [P2(), P2()]) should return true.
+  function pairing(
+    G1Point memory a1,
+    G2Point memory a2,
+    G1Point memory b1,
+    G2Point memory b2,
+    G1Point memory c1,
+    G2Point memory c2,
+    G1Point memory d1,
+    G2Point memory d2
+  ) internal view returns (bool isValid) {
+    G1Point[4] memory p1;
+    p1[0] = a1;
+    p1[1] = b1;
+    p1[2] = c1;
+    p1[3] = d1;
+
+    G2Point[4] memory p2;
+    p2[0] = a2;
+    p2[1] = b2;
+    p2[2] = c2;
+    p2[3] = d2;
+
+    uint256 inputSize = 24;
+    uint256[] memory input = new uint256[](inputSize);
+
+    for (uint8 i = 0; i < 4; ) {
+      uint8 j = i * 6;
+      input[j + 0] = p1[i].x;
+      input[j + 1] = p1[i].y;
+      input[j + 2] = p2[i].x[0];
+      input[j + 3] = p2[i].x[1];
+      input[j + 4] = p2[i].y[0];
+      input[j + 5] = p2[i].y[1];
+
+      unchecked {
+        i++;
+      }
+    }
+
+    uint256[1] memory out;
+    bool success;
+
+    // solhint-disable-next-line no-inline-assembly
+    assembly {
+      success := staticcall(sub(gas(), 2000), 8, add(input, 0x20), mul(inputSize, 0x20), out, 0x20)
+      // Use "invalid" to make gas estimation work
+      switch success
+      case 0 {
+        invalid()
+      }
+    }
+
+    if (!success) {
+      revert PairingOpcodeFailed();
+    }
+
+    isValid = out[0] != 0;
+  }
+}

package/contracts/crypto/PoseidonT3.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+/// @notice A library which provides functions for computing Pedersen hashes.
+library PoseidonT3 {
+  // solhint-disable-next-line no-empty-blocks
+  function poseidon(uint256[2] memory input) public pure returns (uint256) {}
+}

package/contracts/crypto/PoseidonT4.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+/// @notice A library which provides functions for computing Pedersen hashes.
+library PoseidonT4 {
+  // solhint-disable-next-line no-empty-blocks
+  function poseidon(uint256[3] memory input) public pure returns (uint256) {}
+}

package/contracts/crypto/PoseidonT5.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+/// @notice A library which provides functions for computing Pedersen hashes.
+library PoseidonT5 {
+  // solhint-disable-next-line no-empty-blocks
+  function poseidon(uint256[4] memory input) public pure returns (uint256) {}
+}

package/contracts/crypto/PoseidonT6.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+/// @notice A library which provides functions for computing Pedersen hashes.
+library PoseidonT6 {
+  // solhint-disable-next-line no-empty-blocks
+  function poseidon(uint256[5] memory input) public pure returns (uint256) {}
+}

package/contracts/crypto/SnarkCommon.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+import { Pairing } from "./Pairing.sol";
+
+/// @title SnarkCommon
+/// @notice a Contract which holds a struct
+/// representing a Groth16 verifying key
+contract SnarkCommon {
+  /// @notice a struct representing a Groth16 verifying key
+  struct VerifyingKey {
+    Pairing.G1Point alpha1;
+    Pairing.G2Point beta2;
+    Pairing.G2Point gamma2;
+    Pairing.G2Point delta2;
+    Pairing.G1Point[] ic;
+  }
+}

package/contracts/crypto/SnarkConstants.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+/// @title SnarkConstants
+/// @notice This contract contains constants related to the SNARK
+/// components of MACI.
+contract SnarkConstants {
+  /// @notice The scalar field
+  uint256 internal constant SNARK_SCALAR_FIELD =
+    21888242871839275222246405745257275088548364400416034343698204186575808495617;
+
+  /// @notice The public key here is the first Pedersen base
+  /// point from iden3's circomlib implementation of the Pedersen hash.
+  /// Since it is generated using a hash-to-curve function, we are
+  /// confident that no-one knows the private key associated with this
+  /// public key. See:
+  /// https://github.com/iden3/circomlib/blob/d5ed1c3ce4ca137a6b3ca48bec4ac12c1b38957a/src/pedersen_printbases.js
+  uint256 internal constant PAD_PUBKEY_X =
+    10457101036533406547632367118273992217979173478358440826365724437999023779287;
+  uint256 internal constant PAD_PUBKEY_Y =
+    19824078218392094440610104313265183977899662750282163392862422243483260492317;
+
+  /// @notice The Keccack256 hash of 'Maci'
+  uint256 internal constant NOTHING_UP_MY_SLEEVE =
+    8370432830353022751713833565135785980866757267633941821328460903436894336785;
+}

package/contracts/crypto/Verifier.sol

@@ -0,0 +1,93 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import { Pairing } from "./Pairing.sol";
+import { SnarkConstants } from "./SnarkConstants.sol";
+import { SnarkCommon } from "./SnarkCommon.sol";
+import { IVerifier } from "../interfaces/IVerifier.sol";
+
+/// @title Verifier
+/// @notice a Groth16 verifier contract
+contract Verifier is IVerifier, SnarkConstants, SnarkCommon {
+  struct Proof {
+    Pairing.G1Point a;
+    Pairing.G2Point b;
+    Pairing.G1Point c;
+  }
+
+  using Pairing for *;
+
+  uint256 public constant PRIME_Q = 21888242871839275222246405745257275088696311157297823662689037894645226208583;
+
+  /// @notice custom errors
+  error InvalidProofQ();
+  error InvalidInputVal();
+
+  /// @notice Verify a zk-SNARK proof
+  /// @param _proof The proof
+  /// @param vk The verifying key
+  /// @param inputs The public inputs to the circuit
+  /// @return isValid Whether the proof is valid given the verifying key and public
+  ///          input. Note that this function only supports one public input.
+  ///          Refer to the Semaphore source code for a verifier that supports
+  ///          multiple public inputs.
+  function verify(
+    uint256[8] memory _proof,
+    VerifyingKey memory vk,
+    uint256[] calldata inputs
+  ) public view override returns (bool isValid) {
+    Proof memory proof;
+    proof.a = Pairing.G1Point(_proof[0], _proof[1]);
+    proof.b = Pairing.G2Point([_proof[2], _proof[3]], [_proof[4], _proof[5]]);
+    proof.c = Pairing.G1Point(_proof[6], _proof[7]);
+
+    // Make sure that proof.A, B, and C are each less than the prime q
+    checkPoint(proof.a.x);
+    checkPoint(proof.a.y);
+    checkPoint(proof.b.x[0]);
+    checkPoint(proof.b.y[0]);
+    checkPoint(proof.b.x[1]);
+    checkPoint(proof.b.y[1]);
+    checkPoint(proof.c.x);
+    checkPoint(proof.c.y);
+
+    // Compute the linear combination vk_x
+    Pairing.G1Point memory vkX = Pairing.G1Point(0, 0);
+
+    uint256 inputsLength = inputs.length;
+
+    for (uint256 i = 0; i < inputsLength; ) {
+      uint256 input = inputs[i];
+
+      // Make sure that the input is less than the snark scalar field
+      if (input >= SNARK_SCALAR_FIELD) {
+        revert InvalidInputVal();
+      }
+
+      vkX = Pairing.plus(vkX, Pairing.scalarMul(vk.ic[i + 1], input));
+
+      unchecked {
+        i++;
+      }
+    }
+
+    vkX = Pairing.plus(vkX, vk.ic[0]);
+
+    isValid = Pairing.pairing(
+      Pairing.negate(proof.a),
+      proof.b,
+      vk.alpha1,
+      vk.beta2,
+      vkX,
+      vk.gamma2,
+      proof.c,
+      vk.delta2
+    );
+  }
+
+  function checkPoint(uint256 point) internal pure {
+    if (point >= PRIME_Q) {
+      revert InvalidProofQ();
+    }
+  }
+}

package/contracts/initialVoiceCreditProxy/ConstantInitialVoiceCreditProxy.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import { Clone } from "@excubiae/contracts/contracts/proxy/Clone.sol";
+
+import { IInitialVoiceCreditProxy } from "../interfaces/IInitialVoiceCreditProxy.sol";
+
+/// @title ConstantInitialVoiceCreditProxy
+/// @notice This contract allows to set a constant initial voice credit balance
+/// for MACI's voters.
+contract ConstantInitialVoiceCreditProxy is Clone, IInitialVoiceCreditProxy {
+  /// @notice the balance to be returned by getVoiceCredits
+  uint256 internal balance;
+
+  /// @notice Initializes the contract.
+  function _initialize() internal override {
+    super._initialize();
+
+    bytes memory data = _getAppendedBytes();
+    uint256 _balance = abi.decode(data, (uint256));
+
+    balance = _balance;
+  }
+
+  /// @notice Returns the constant balance for any new MACI's voter
+  /// @return balance
+  function getVoiceCredits(address, bytes memory) public view override returns (uint256) {
+    return balance;
+  }
+}

package/contracts/initialVoiceCreditProxy/ConstantInitialVoiceCreditProxyFactory.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import { Factory } from "@excubiae/contracts/contracts/proxy/Factory.sol";
+
+import { ConstantInitialVoiceCreditProxy } from "./ConstantInitialVoiceCreditProxy.sol";
+
+/// @title ConstantInitialVoiceCreditProxyFactory
+/// @notice Factory contract for deploying minimal proxy instances of ConstantInitialVoiceCreditProxy.
+/// @dev Simplifies deployment of ConstantInitialVoiceCreditProxy clones with appended configuration data.
+contract ConstantInitialVoiceCreditProxyFactory is Factory {
+  /// @notice Initializes the factory with the ConstantInitialVoiceCreditProxy implementation.
+  constructor() Factory(address(new ConstantInitialVoiceCreditProxy())) {}
+
+  /// @notice Deploys a new ConstantInitialVoiceCreditProxy clone.
+  /// @param balance the balance to be returned by getVoiceCredits
+  function deploy(uint256 balance) public {
+    bytes memory data = abi.encode(balance);
+    address clone = super._deploy(data);
+
+    ConstantInitialVoiceCreditProxy(clone).initialize();
+  }
+}

package/contracts/interfaces/IInitialVoiceCreditProxy.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+/// @title IInitialVoiceCreditProxy
+/// @notice InitialVoiceCreditProxy interface
+interface IInitialVoiceCreditProxy {
+  /// @notice Get the voice credits of a user
+  /// @param _user User address
+  /// @param _data Data to get voice credits
+  function getVoiceCredits(address _user, bytes memory _data) external view returns (uint256);
+}

package/contracts/interfaces/IMACI.sol

@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import { Params } from "../utilities/Params.sol";
+import { DomainObjs } from "../utilities/DomainObjs.sol";
+
+/// @title IMACI
+/// @notice MACI interface
+interface IMACI {
+  /// @notice A struct holding the addresses of poll, mp and tally
+  struct PollContracts {
+    address poll;
+    address messageProcessor;
+    address tally;
+  }
+  /// @notice A struct holding the params for poll deployment
+  struct DeployPollArgs {
+    /// @param startDate The start date of the poll
+    uint256 startDate;
+    /// @param endDate The end date of the poll
+    uint256 endDate;
+    /// @param treeDepths The depth of the Merkle trees
+    Params.TreeDepths treeDepths;
+    /// @param messageBatchSize The message batch size
+    uint8 messageBatchSize;
+    /// @param coordinatorPubKey The coordinator's public key
+    DomainObjs.PubKey coordinatorPubKey;
+    /// @param verifier The Verifier Contract
+    address verifier;
+    /// @param vkRegistry The VkRegistry Contract
+    address vkRegistry;
+    /// @param mode Voting mode
+    DomainObjs.Mode mode;
+    /// @param policy The policy contract
+    address policy;
+    /// @param initialVoiceCreditProxy The initial voice credit proxy contract
+    address initialVoiceCreditProxy;
+    /// @param relayer The message relayer (optional)
+    address[] relayers;
+    /// @param voteOptions The number of valid vote options for the poll
+    uint256 voteOptions;
+  }
+
+  /// @notice Get the depth of the state tree
+  /// @return The depth of the state tree
+  function stateTreeDepth() external view returns (uint8);
+
+  /// @notice Return the main root of the StateAq contract
+  /// @return The Merkle root
+  function getStateTreeRoot() external view returns (uint256);
+
+  /// @notice Get the index of a public key in the state tree
+  /// @param _pubKeyHash The hash of the public key
+  /// @return index The index of the public key in the state tree
+  function getStateIndex(uint256 _pubKeyHash) external view returns (uint256);
+
+  /// @notice Deploy a new Poll contract.
+  /// @param _pollArgs The deploy poll args
+  function deployPoll(DeployPollArgs memory _pollArgs) external returns (PollContracts memory);
+
+  /// @notice Allows any eligible user sign up. The sign-up policy should prevent
+  /// double sign-ups or ineligible users from doing so.  This function will
+  /// only succeed if the sign-up deadline has not passed.
+  /// @param _pubKey The user's desired public key.
+  /// @param _signUpPolicyData Data to pass to the sign-up policy
+  ///     register() function. For instance, the POAPPolicy or
+  ///     TokenPolicy requires this value to be the ABI-encoded
+  ///     token ID.
+  function signUp(DomainObjs.PubKey memory _pubKey, bytes memory _signUpPolicyData) external;
+
+  /// @notice Return the state root when the '_index' user signed up
+  /// @param _index The serial number when the user signed up
+  /// @return The Merkle root
+  function getStateRootOnIndexedSignUp(uint256 _index) external view returns (uint256);
+
+  /// @notice Get the number of signups
+  /// @return numsignUps The number of signups
+  function numSignUps() external view returns (uint256);
+
+  /// @notice Get the next poll ID
+  /// @return The next poll ID
+  function nextPollId() external view returns (uint256);
+}

package/contracts/interfaces/IMPFactory.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import { DomainObjs } from "../utilities/DomainObjs.sol";
+
+/// @title IMessageProcessorFactory
+/// @notice MessageProcessorFactory interface
+interface IMessageProcessorFactory {
+  /// @notice Deploy a new MessageProcessor contract and return the address.
+  /// @param _verifier Verifier contract
+  /// @param _vkRegistry VkRegistry contract
+  /// @param _poll Poll contract
+  /// @param _mode Voting mode
+  /// @return The deployed MessageProcessor contract
+  function deploy(
+    address _verifier,
+    address _vkRegistry,
+    address _poll,
+    DomainObjs.Mode _mode
+  ) external returns (address);
+}

package/contracts/interfaces/IMessageProcessor.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+/// @title IMessageProcessor
+/// @notice MessageProcessor interface
+interface IMessageProcessor {
+  /// @notice Get the result of whether there are unprocessed messages left
+  /// @return Whether there are unprocessed messages left
+  function processingComplete() external view returns (bool);
+
+  /// @notice Get the commitment to the state and ballot roots
+  /// @return The commitment to the state and ballot roots
+  function sbCommitment() external view returns (uint256);
+
+  /// @notice Get public circuit inputs.
+  /// @param _currentMessageBatchIndex The current processed batch index
+  /// @param _newSbCommitment The new state root and ballot root commitment
+  ///                         after all messages are processed
+  /// @param _outputBatchHash The output batch hash
+  /// @return publicInputs public circuit inputs
+  function getPublicCircuitInputs(
+    uint256 _currentMessageBatchIndex,
+    uint256 _newSbCommitment,
+    uint256 _outputBatchHash
+  ) external view returns (uint256[] memory);
+}

package/contracts/interfaces/IPoll.sol

@@ -0,0 +1,121 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import { DomainObjs } from "../utilities/DomainObjs.sol";
+import { IMACI } from "./IMACI.sol";
+
+/// @title IPoll
+/// @notice Poll interface
+interface IPoll {
+  /// @notice Join the poll for voting
+  /// @param _nullifier Hashed user's private key to check whether user has already voted
+  /// @param _pubKey Poll user's public key
+  /// @param _stateRootIndex Index of the MACI's stateRootOnSignUp for which the inclusion proof is generated
+  /// @param _proof The zk-SNARK proof
+  /// @param _signUpPolicyData Data to pass to the signup policy
+  /// @param _initialVoiceCreditProxyData Data to pass to the InitialVoiceCreditProxy
+  function joinPoll(
+    uint256 _nullifier,
+    DomainObjs.PubKey calldata _pubKey,
+    uint256 _stateRootIndex,
+    uint256[8] calldata _proof,
+    bytes memory _signUpPolicyData,
+    bytes memory _initialVoiceCreditProxyData
+  ) external;
+
+  /// @notice The number of messages which have been processed and the number of signups
+  /// @return numSignups The number of signups
+  /// @return numMsgs The number of messages sent by voters
+  function numSignUpsAndMessages() external view returns (uint256 numSignups, uint256 numMsgs);
+
+  /// @notice Get all message batch hashes
+  /// @return betchHashes array containing all batch hashes
+  function getBatchHashes() external view returns (uint256[] memory);
+
+  /// @notice Pad last unclosed batch
+  function padLastBatch() external;
+
+  /// @notice Allows anyone to publish a message (an encrypted command and signature).
+  /// This function also enqueues the message.
+  /// @param _message The message to publish
+  /// @param _encPubKey An ephemeral public key which can be combined with the
+  /// coordinator's private key to generate an ECDH shared key with which
+  /// to encrypt the message.
+  function publishMessage(DomainObjs.Message calldata _message, DomainObjs.PubKey calldata _encPubKey) external;
+
+  /// @notice Submit a message batch
+  /// @dev Can only be submitted before the voting deadline
+  /// @param _messages the messages
+  /// @param _encPubKeys the encrypted public keys
+  function publishMessageBatch(
+    DomainObjs.Message[] calldata _messages,
+    DomainObjs.PubKey[] calldata _encPubKeys
+  ) external;
+
+  /// @notice Allows relayer to publish messages using IPFS.
+  /// @param _messageHashes The message hashes
+  /// @param _ipfsHash The IPFS hash of the messages batch
+  function relayMessagesBatch(uint256[] calldata _messageHashes, bytes32 _ipfsHash) external;
+
+  /// @notice The second step of merging the poll state. This allows the
+  /// ProcessMessages circuit to access the latest state tree and ballots via
+  /// currentSbCommitment.
+  function mergeState() external;
+
+  /// @notice Returns the Poll's start and end dates
+  /// @return _startDate The start date of the poll
+  /// @return _endDate The end date of the poll
+  function getStartAndEndDate() external view returns (uint256 _startDate, uint256 _endDate);
+
+  /// @notice Returns the Poll's end date
+  /// @return _endDate The end date of the poll
+  function endDate() external view returns (uint256);
+
+  /// @notice Returns the Poll's start date
+  /// @return _startDate The start date of the poll
+  function startDate() external view returns (uint256);
+
+  /// @notice Get the result of whether the MACI contract's stateAq has been merged by this contract
+  /// @return Whether the MACI contract's stateAq has been merged by this contract
+  function stateMerged() external view returns (bool);
+
+  /// @notice Get the depths of the merkle trees
+  /// @return intStateTreeDepth The depth of the state tree
+  /// @return voteOptionTreeDepth The subdepth of the vote option tree
+  function treeDepths() external view returns (uint8 intStateTreeDepth, uint8 voteOptionTreeDepth);
+
+  /// @notice Get the number of vote options for the poll
+  /// @return voteOptions The number of vote options
+  function voteOptions() external view returns (uint256);
+
+  /// @notice Get message batch size for the poll
+  /// @return The message batch size
+  function messageBatchSize() external view returns (uint8);
+
+  /// @notice Get the hash of coordinator's public key
+  /// @return _coordinatorPubKeyHash the hash of coordinator's public key
+  function coordinatorPubKeyHash() external view returns (uint256 _coordinatorPubKeyHash);
+
+  /// @notice Get the commitment to the state leaves and the ballots. This is
+  /// hash3(stateRoot, ballotRoot, salt).
+  /// Its initial value should be
+  /// hash(maciStateRootSnapshot, emptyBallotRoot, 0)
+  /// Each successful invocation of processMessages() should use a different
+  /// salt to update this value, so that an external observer cannot tell in
+  /// the case that none of the messages are valid.
+  /// @return The commitment to the state leaves and the ballots
+  function currentSbCommitment() external view returns (uint256);
+
+  /// @notice Get the dynamic depth of the state tree at the time of poll
+  /// finalization (based on the number of leaves inserted)
+  function actualStateTreeDepth() external view returns (uint8);
+
+  /// @notice Get the external contracts
+  /// @return maci The IMACI contract
+  function getMaciContract() external view returns (IMACI maci);
+
+  /// @notice Get the index of a state leaf in the state tree
+  /// @param element The hash of thestate leaf
+  /// @return index The index of the state leaf in the state tree
+  function getStateIndex(uint256 element) external view returns (uint40);
+}