@crisp-e3/contracts 0.4.1 → 0.5.2

package/contracts/CRISPProgram.sol

@@ -11,100 +11,77 @@ import { IE3Program } from "@enclave-e3/contracts/contracts/interfaces/IE3Progra
 import { IEnclave } from "@enclave-e3/contracts/contracts/interfaces/IEnclave.sol";
 import { E3 } from "@enclave-e3/contracts/contracts/interfaces/IE3.sol";
 import { LazyIMTData, InternalLazyIMT, PoseidonT3 } from "@zk-kit/lazy-imt.sol/InternalLazyIMT.sol";
-
 import { HonkVerifier } from "./CRISPVerifier.sol";
 
 contract CRISPProgram is IE3Program, Ownable {
   using InternalLazyIMT for LazyIMTData;
-  /// @notice a structure that holds the round data
+
+  /// @notice Struct to store all data related to a voting round
   struct RoundData {
-    /// @notice The governance token address.
-    address token;
-    /// @notice The minimum balance required to pass the validation.
-    uint256 balanceThreshold;
-    /// @notice The Merkle root of the census.
-    uint256 censusMerkleRoot;
+    uint256 merkleRoot;
+    bytes32 paramsHash;
+    mapping(address slot => uint40 index) voteSlots;
+    LazyIMTData votes;
   }
 
   // Constants
+  /// @notice Encryption scheme ID used for the CRISP program.
   bytes32 public constant ENCRYPTION_SCHEME_ID = keccak256("fhe.rs:BFV");
-
-  // The depth of the input merkle tree
+  /// @notice The depth of the input Merkle tree.
   uint8 public constant TREE_DEPTH = 20;
+  /// @notice Half of the largest minimum degree used to fit votes inside the plaintext polynomial.
+  uint256 public constant HALF_LARGEST_MINIMUM_DEGREE = 28; // static, hardcoded in the circuit.
 
   // State variables
   IEnclave public enclave;
-  IRiscZeroVerifier public verifier;
-  HonkVerifier private immutable HONK_VERIFIER;
+  IRiscZeroVerifier public risc0Verifier;
   bytes32 public imageId;
-
-  /// @notice the round data
-  mapping(uint256 e3Id => RoundData roundData) public roundsData;
-  /// @notice whether the round data has been set
-  mapping(uint256 e3Id => bool isDataSet) public isRoundsDataSet;
-
-  /// @notice Half of the largest minimum degree used to fit votes
-  /// inside the plaintext polynomial
-  uint256 public constant HALF_LARGEST_MINIMUM_DEGREE = 28;
+  HonkVerifier private immutable honkVerifier;
 
   // Mappings
   mapping(address => bool) public authorizedContracts;
-  mapping(uint256 e3Id => bytes32 paramsHash) public paramsHashes;
-  /// @notice Mapping to store votes slot indices. Each eligible voter has their own slot
-  /// to store their vote inside the merkle tree.
-  mapping(uint256 e3Id => mapping(address slot => uint40 index)) public voteSlots;
-  mapping(uint256 e3Id => LazyIMTData) public votes;
+  mapping(uint256 e3Id => RoundData) e3Data;
 
   // Errors
   error CallerNotAuthorized();
   error E3AlreadyInitialized();
   error E3DoesNotExist();
   error EnclaveAddressZero();
-  error VerifierAddressZero();
-
-  /// @notice The error emitted when the honk verifier address is invalid.
+  error Risc0VerifierAddressZero();
   error InvalidHonkVerifier();
-  /// @notice The error emitted when the input data is empty.
   error EmptyInputData();
-  /// @notice The error emitted when the input data is invalid.
-  error InvalidInputData(bytes reason);
-  /// @notice The error emitted when the Noir proof is invalid.
   error InvalidNoirProof();
-  /// @notice The error emitted when the round data is not set.
-  error RoundDataNotSet();
-  /// @notice The error emitted when trying to set the round data more than once.
-  error RoundDataAlreadySet();
+  error InvalidMerkleRoot();
+  error MerkleRootAlreadySet();
 
-  /// @notice The event emitted when an input is published.
+  // Events
   event InputPublished(uint256 indexed e3Id, bytes vote, uint256 index);
 
   /// @notice Initialize the contract, binding it to a specified RISC Zero verifier.
   /// @param _enclave The enclave address
-  /// @param _verifier The RISC Zero verifier address
+  /// @param _risc0Verifier The RISC Zero verifier address
   /// @param _honkVerifier The honk verifier address
   /// @param _imageId The image ID for the guest program
-  constructor(IEnclave _enclave, IRiscZeroVerifier _verifier, HonkVerifier _honkVerifier, bytes32 _imageId) Ownable(msg.sender) {
-    require(address(_enclave) != address(0), EnclaveAddressZero());
-    require(address(_verifier) != address(0), VerifierAddressZero());
-    require(address(_honkVerifier) != address(0), InvalidHonkVerifier());
+  constructor(IEnclave _enclave, IRiscZeroVerifier _risc0Verifier, HonkVerifier _honkVerifier, bytes32 _imageId) Ownable(msg.sender) {
+    if (address(_enclave) == address(0)) revert EnclaveAddressZero();
+    if (address(_risc0Verifier) == address(0)) revert Risc0VerifierAddressZero();
+    if (address(_honkVerifier) == address(0)) revert InvalidHonkVerifier();
 
     enclave = _enclave;
-    verifier = _verifier;
-    HONK_VERIFIER = _honkVerifier;
+    risc0Verifier = _risc0Verifier;
+    honkVerifier = _honkVerifier;
     authorizedContracts[address(_enclave)] = true;
     imageId = _imageId;
   }
 
-  /// @notice Sets the Round data. Can only be set once.
+  /// @notice Sets the Merkle root for an E3 program. Can only be set once.
+  /// @param _e3Id The E3 program ID
   /// @param _root The Merkle root to set.
-  /// @param _token The governance token address.
-  /// @param _balanceThreshold The minimum balance required.
-  function setRoundData(uint256 _e3Id, uint256 _root, address _token, uint256 _balanceThreshold) external onlyOwner {
-    if (isRoundsDataSet[_e3Id]) revert RoundDataAlreadySet();
-
-    isRoundsDataSet[_e3Id] = true;
+  function setMerkleRoot(uint256 _e3Id, uint256 _root) external onlyOwner {
+    if (_root == 0) revert InvalidMerkleRoot();
+    if (e3Data[_e3Id].merkleRoot != 0) revert MerkleRootAlreadySet();
 
-    roundsData[_e3Id] = RoundData({ token: _token, balanceThreshold: _balanceThreshold, censusMerkleRoot: _root });
+    e3Data[_e3Id].merkleRoot = _root;
   }
 
   /// @notice Set the Image ID for the guest program
@@ -113,30 +90,29 @@ contract CRISPProgram is IE3Program, Ownable {
     imageId = _imageId;
   }
 
-  /// @notice Set the RISC Zero verifier address
-  /// @param _verifier The new RISC Zero verifier address
-  function setVerifier(IRiscZeroVerifier _verifier) external onlyOwner {
-    if (address(_verifier) == address(0)) revert VerifierAddressZero();
-    verifier = _verifier;
+  /// @notice Set the RISC Zero verifier.
+  /// @param _risc0Verifier The new RISC Zero verifier address
+  function setRisc0Verifier(IRiscZeroVerifier _risc0Verifier) external onlyOwner {
+    if (address(_risc0Verifier) == address(0)) revert Risc0VerifierAddressZero();
+    risc0Verifier = _risc0Verifier;
   }
 
   /// @notice Get the params hash for an E3 program
   /// @param e3Id The E3 program ID
   /// @return The params hash
   function getParamsHash(uint256 e3Id) public view returns (bytes32) {
-    return paramsHashes[e3Id];
+    return e3Data[e3Id].paramsHash;
   }
 
-  /// @notice Validate the E3 program parameters
-  /// @param e3Id The E3 program ID
-  /// @param e3ProgramParams The E3 program parameters
+  /// @inheritdoc IE3Program
   function validate(uint256 e3Id, uint256, bytes calldata e3ProgramParams, bytes calldata) external returns (bytes32) {
-    require(authorizedContracts[msg.sender] || msg.sender == owner(), CallerNotAuthorized());
-    require(paramsHashes[e3Id] == bytes32(0), E3AlreadyInitialized());
-    paramsHashes[e3Id] = keccak256(e3ProgramParams);
+    if (!authorizedContracts[msg.sender] && msg.sender != owner()) revert CallerNotAuthorized();
+    if (e3Data[e3Id].paramsHash != bytes32(0)) revert E3AlreadyInitialized();
+
+    e3Data[e3Id].paramsHash = keccak256(e3ProgramParams);
 
-    // we need to init the inputs merkle tree for this e3Id
-    votes[e3Id]._init(TREE_DEPTH);
+    // Initialize the votes Merkle tree for this E3 ID.
+    e3Data[e3Id].votes._init(TREE_DEPTH);
 
     return ENCRYPTION_SCHEME_ID;
   }
@@ -144,9 +120,11 @@ contract CRISPProgram is IE3Program, Ownable {
   /// @inheritdoc IE3Program
   function validateInput(uint256 e3Id, address, bytes memory data) external {
     // it should only be called via Enclave for now
-    require(authorizedContracts[msg.sender] || msg.sender == owner(), CallerNotAuthorized());
+    if (!authorizedContracts[msg.sender] && msg.sender != owner()) revert CallerNotAuthorized();
+
     // We need to ensure that the CRISP admin set the merkle root of the census.
-    if (!isRoundsDataSet[e3Id]) revert RoundDataNotSet();
+    // TODO: Uncomment this when we make the merkle root a public input of the circuit.
+    // if (e3Data[e3Id].merkleRoot == 0) revert MerkleRootNotSet();
 
     if (data.length == 0) revert EmptyInputData();
 
@@ -156,47 +134,23 @@ contract CRISPProgram is IE3Program, Ownable {
 
     (uint40 voteIndex, bool isFirstVote) = _processVote(e3Id, slotAddress, voteBytes);
 
+    // Set public inputs for the proof. Order must match Noir circuit.
     bytes32[] memory noirPublicInputs = new bytes32[](2 + vote.length);
 
-    // Set public inputs for the proof. Order must match Noir circuit.
     noirPublicInputs[0] = bytes32(uint256(uint160(slotAddress)));
-    // Pass isFirstVote flag to verifier (1 = first vote, 0 = re-vote)
     noirPublicInputs[1] = bytes32(uint256(isFirstVote ? 1 : 0));
-
-    // Set the encrypted vote to the noir public inputs.
     for (uint256 i = 0; i < vote.length; i++) {
       noirPublicInputs[i + 2] = vote[i];
     }
 
     // Check if the ciphertext was encrypted correctly
-    if (!HONK_VERIFIER.verify(noirProof, noirPublicInputs)) {
+    if (!honkVerifier.verify(noirProof, noirPublicInputs)) {
       revert InvalidNoirProof();
     }
 
     emit InputPublished(e3Id, voteBytes, voteIndex);
   }
 
-  /// @notice Process a vote: insert or update in the merkle tree depending
-  /// on whether it's the first vote or an override.
-  function _processVote(uint256 e3Id, address slotAddress, bytes memory vote) internal returns (uint40 voteIndex, bool isFirstVote) {
-    uint40 storedIndexPlusOne = voteSlots[e3Id][slotAddress];
-
-    // we treat the index 0 as not voted yet
-    // any valid index will be index + 1
-    if (storedIndexPlusOne == 0) {
-      // FIRST VOTE
-      isFirstVote = true;
-      voteIndex = votes[e3Id].numberOfLeaves;
-      voteSlots[e3Id][slotAddress] = voteIndex + 1;
-      votes[e3Id]._insert(PoseidonT3.hash([uint256(keccak256(vote)), voteIndex]));
-    } else {
-      // RE-VOTE
-      isFirstVote = false;
-      voteIndex = storedIndexPlusOne - 1;
-      votes[e3Id]._update(PoseidonT3.hash([uint256(keccak256(vote)), voteIndex]), voteIndex);
-    }
-  }
-
   /// @notice Decode the tally from the plaintext output
   /// @param e3Id The E3 program ID
   /// @return yes The number of yes votes
@@ -235,30 +189,49 @@ contract CRISPProgram is IE3Program, Ownable {
     return (yes, no);
   }
 
-  /// @notice Verify the proof
-  /// @param e3Id The E3 program ID
-  /// @param ciphertextOutputHash The hash of the ciphertext output
-  /// @param proof The proof to verify
+  /// @inheritdoc IE3Program
   function verify(uint256 e3Id, bytes32 ciphertextOutputHash, bytes memory proof) external view override returns (bool) {
-    require(paramsHashes[e3Id] != bytes32(0), E3DoesNotExist());
-    bytes32 inputRoot = bytes32(votes[e3Id]._root(TREE_DEPTH));
+    if (e3Data[e3Id].paramsHash == bytes32(0)) revert E3DoesNotExist();
+    bytes32 inputRoot = bytes32(e3Data[e3Id].votes._root(TREE_DEPTH));
     bytes memory journal = new bytes(396); // (32 + 1) * 4 * 3
 
-    encodeLengthPrefixAndHash(journal, 0, ciphertextOutputHash);
-    encodeLengthPrefixAndHash(journal, 132, paramsHashes[e3Id]);
-    encodeLengthPrefixAndHash(journal, 264, inputRoot);
+    _encodeLengthPrefixAndHash(journal, 0, ciphertextOutputHash);
+    _encodeLengthPrefixAndHash(journal, 132, e3Data[e3Id].paramsHash);
+    _encodeLengthPrefixAndHash(journal, 264, inputRoot);
 
-    verifier.verify(proof, imageId, sha256(journal));
+    risc0Verifier.verify(proof, imageId, sha256(journal));
     return true;
   }
 
+  /// @notice Process a vote: insert or update in the merkle tree depending
+  /// on whether it's the first vote or an override.
+  function _processVote(uint256 e3Id, address slotAddress, bytes memory vote) internal returns (uint40 voteIndex, bool isFirstVote) {
+    uint40 storedIndexPlusOne = e3Data[e3Id].voteSlots[slotAddress];
+
+    // we treat the index 0 as not voted yet
+    // any valid index will be index + 1
+    if (storedIndexPlusOne == 0) {
+      // FIRST VOTE
+      isFirstVote = true;
+      voteIndex = e3Data[e3Id].votes.numberOfLeaves;
+      e3Data[e3Id].voteSlots[slotAddress] = voteIndex + 1;
+      e3Data[e3Id].votes._insert(PoseidonT3.hash([uint256(keccak256(vote)), voteIndex]));
+    } else {
+      // RE-VOTE
+      isFirstVote = false;
+      voteIndex = storedIndexPlusOne - 1;
+      e3Data[e3Id].votes._update(PoseidonT3.hash([uint256(keccak256(vote)), voteIndex]), voteIndex);
+    }
+  }
+
   /// @notice Encode length prefix and hash
   /// @param journal The journal to encode into
   /// @param startIndex The start index in the journal
   /// @param hashVal The hash value to encode
-  function encodeLengthPrefixAndHash(bytes memory journal, uint256 startIndex, bytes32 hashVal) internal pure {
+  function _encodeLengthPrefixAndHash(bytes memory journal, uint256 startIndex, bytes32 hashVal) internal pure {
     journal[startIndex] = 0x20;
     startIndex += 4;
+
     for (uint256 i = 0; i < 32; i++) {
       journal[startIndex + i * 4] = hashVal[i];
     }

package/contracts/CRISPVerifier.sol

@@ -8,7 +8,7 @@ pragma solidity >=0.8.21;
 uint256 constant N = 262144;
 uint256 constant LOG_N = 18;
 uint256 constant NUMBER_OF_PUBLIC_INPUTS = 2066;
-uint256 constant VK_HASH = 0x063c39e8bdbf5641b7e7da911a54f2e808b084120de6fec9cd1223ce6ef0da85;
+uint256 constant VK_HASH = 0x20e20e306d8e4ab1bb38da9301dcff68986340a39ec3e45f3d680911b91aac9e;
 library HonkVerificationKey {
   function loadVerificationKey() internal pure returns (Honk.VerificationKey memory) {
     Honk.VerificationKey memory vk = Honk.VerificationKey({
@@ -16,116 +16,116 @@ library HonkVerificationKey {
       logCircuitSize: uint256(18),
       publicInputsSize: uint256(2066),
       ql: Honk.G1Point({
-        x: uint256(0x246e058a5ff7d94b72e2d8f1d273265644d4795cfb2a427bab835b180a5509fb),
-        y: uint256(0x221fc7eff2803fca12db033baa14646582610126778228307901d0db50748c5e)
+        x: uint256(0x1dddb42c5a7db46ec92d83144cb1fe8f8c1c862826388c25290ac8635ebc7dd7),
+        y: uint256(0x09549d2a558917eb071c0aaf4285d4827c566df2f1cd2d1e1b6ad5dab4afa499)
       }),
       qr: Honk.G1Point({
-        x: uint256(0x08011cd886ba5fc7884098df37d58eecfa75f404fead14dbbe1708d9fba3a702),
-        y: uint256(0x0a76efd12734f504e19bf349e90d20fc19400dd97c238195c67b118c14a35dc9)
+        x: uint256(0x0ed974b450a51723240b5e11b13e961951b95bf4c686c5be6c61b0e294b990ac),
+        y: uint256(0x10183cfef2d2ae78b9a83e62ed895bcfd086c7824be57c748914cf79b47627b1)
       }),
       qo: Honk.G1Point({
-        x: uint256(0x03250bf94bfb59a296a7227fe1f7a6873ca063c4c581a7b725d6ab685c53440c),
-        y: uint256(0x0663423bdefc067e3f531e2760b73340a76365a28d7753db11af572e71a7f395)
+        x: uint256(0x0376597dbc0a258dbe8691c07264e83d208bbab2795c9efba9f12f0cac99e773),
+        y: uint256(0x2704bee070b407f6d0956b82b1953f3697f7b0ebdd4cba286ba8a8aa876460be)
       }),
       q4: Honk.G1Point({
-        x: uint256(0x1db2b3316d4bba2799898fc14a80ee1a12fd9af0b6cf261b86a0e725737dd091),
-        y: uint256(0x0988609ce0b437fd1d5586ad60e05cc16f891e702fda15bfbbd79cf6ea306582)
+        x: uint256(0x26543108597623c48ef32ca11c95af0d3ea922ea43b41944ebc10940a76c67c3),
+        y: uint256(0x09c28d40fa91aeff40db0ce3e6b8b86f162ed9d65c3aaa1b74d25cf53999f847)
       }),
       qm: Honk.G1Point({
-        x: uint256(0x1a1ddaefb0b108d39e35111ea8cab1f89d6fb1e6ca3d4d28ae1b6ad3acdb4c4f),
-        y: uint256(0x110c07c930f3fd905e11cf35db1b4e8d267f016d94ffc9f0b3833dd27641fd4d)
+        x: uint256(0x0b63b4e86f99c000048a814e8579bbfb107bf06c473d3edc163e754ca41678d0),
+        y: uint256(0x1f3c3a429312accbf47a69871e0afe1c4902ec16747ee48914767cc3bb280d92)
       }),
       qc: Honk.G1Point({
-        x: uint256(0x24a1d61ec991a93d44d50980c43acae82f4013d66126daf568a854cbc88c5a88),
-        y: uint256(0x20327007b5abc8edee984da35d5c8b8f8565165d4708436627ba34a90ded8431)
+        x: uint256(0x27213ed6f59cc8fbc7380d04b4791900114e5f85f7c728fc98ae03fb4b7093da),
+        y: uint256(0x021c6a47a6d42a4f6c7a01c7b043c2bfc15b3a3ff270126510d60f1b86e01dac)
       }),
       qLookup: Honk.G1Point({
-        x: uint256(0x205057a47479c3744023a35ca3d08d79c3499d9af48e264ecb31823713bbbca8),
-        y: uint256(0x19b2541dcaae69df644bec1bb8ce13455719c73fcadac3763d81a6b1c70560f3)
+        x: uint256(0x056cab9e0cc90d6187f1504470e987376fb9d964f5e69f79d3dc50a3aba8b070),
+        y: uint256(0x2a0690805846bbbba0fe533d4ec11edc41678b77983bcba8f10a71ece5298fee)
       }),
       qArith: Honk.G1Point({
-        x: uint256(0x06294dfc20c077df81e702e90386bca302a58eb9a8e42d116e88b4bcc7605f67),
-        y: uint256(0x06a35b9ed28d64b5c79f08a6ed5698a501e9a45e71cd515d3a89455ea711489d)
+        x: uint256(0x02a42dcfc958fc3919cf2198202d7a6822c5ac22b5a20246ab7d35c549aeb1e0),
+        y: uint256(0x26cc1db7e7db68551027e647657bbbb1a4e5c6cc8d2778fb8d8833eaf0ec6c22)
       }),
       qDeltaRange: Honk.G1Point({
-        x: uint256(0x21cb2b3ddedbbb4529c61e4586aa3913a975644620c112f1c892f1b0930633d8),
-        y: uint256(0x2b2d51a0dc545770c23b83eceb33b488e8217ed4af94bbecd3233520f1a09e36)
+        x: uint256(0x1faf3b8674c17daf3e0f63e7c9356cacb82450ef207412dcf21922e73850f746),
+        y: uint256(0x07b754988b169db012bc034513ac4ee42746fe1bf233dc531af97d5bc2d0db0c)
       }),
       qElliptic: Honk.G1Point({
-        x: uint256(0x0b33cc711a57329b7a8532a68b487c08afc55c25843549a9f80a1a954c946c62),
-        y: uint256(0x068fcecd26322a8e6c9699ef0aaa0f2a0d309c5cb2bca51f14287d121c4694fa)
+        x: uint256(0x04788fb295f478b04078cab13188d28645677fda3a09ec788387afce8f2b5804),
+        y: uint256(0x29194accd4f5315943071685ff9c2b02480c0bff1c21915b16dd54ec561019fb)
       }),
       qMemory: Honk.G1Point({
-        x: uint256(0x12924d915fd97341729ab4a38d431bdb22555119117c62a2ee78941855604328),
-        y: uint256(0x253f6f540fea2a3f6d3b9f9d24d142b1e942c383fe5b45aea1306992c99fb094)
+        x: uint256(0x0bf2ec6066d37230ae861b2473bf67d5ea2fff4fe3b1ff276c71c0edab34c040),
+        y: uint256(0x230bbf4647507639fa136c8112d8682c34686c7d62fee9899fd8a456dc19c71b)
       }),
       qNnf: Honk.G1Point({
-        x: uint256(0x23916c7db7b5ec14f6c4a90328e16fad9e03f0d36a7c22750a82bdb74925d008),
-        y: uint256(0x0d2d9f771a28305ef54fd924dbab1b7fd294e39f2e64b1884fec624a151a78cc)
+        x: uint256(0x27b6e6deb48b8f1510b8bc376c0d0998166587549833fc86d6cc9eef0ed465c5),
+        y: uint256(0x072563066ec76ae4137df6971684a2904be8f2fef972f1f8ac9407bf41c044f6)
       }),
       qPoseidon2External: Honk.G1Point({
-        x: uint256(0x277f77603f20d5d41e1149588bc2942ba2938ac9d9444622709ed99f1e207a4e),
-        y: uint256(0x214d57941547e7acf0f4db0ba32b3a80ccf3bc7195673d43a58e36b735df60e6)
+        x: uint256(0x0412d71f1f86606512556c6d48194094f6f15e108cffeb5171ac5deafcf21ba5),
+        y: uint256(0x0d92c1ab9f5838fa6bda23289f6baab5abb7fafd2505b05412be72c98eed5784)
       }),
       qPoseidon2Internal: Honk.G1Point({
-        x: uint256(0x09a0b5fbddaa5b0077595c630a0403f3de09ae31815145dae74c04ac7013cdd2),
-        y: uint256(0x1c8f6eebb7992fbbd7b84ef11585538f876749bedd8e61b70fd86a22f3f0c47d)
+        x: uint256(0x03a37c8f14f04a0c47b55fc372681424912f79c3ae565a2afce81587846e00c5),
+        y: uint256(0x0dfb3edabbbd97745fea4c569bc99dd450bad935f50610a36639cae94acddf56)
       }),
       s1: Honk.G1Point({
-        x: uint256(0x20dbaae9012430dfd99a8e15c41e5ce5e33abe943d4e6bcae2568196a6e2bf16),
-        y: uint256(0x164b7d011804aa4dbb49c6d96cb28e3b16af2c3532c2407f0ce12c52be461956)
+        x: uint256(0x21d3dd322812fd84e7ba8137cdc4e181de182d713192f4a039cd825e5a7fc33d),
+        y: uint256(0x11d9b3e7533a65c73578f09d5950d207d615dbcbcba9ca10198af6994ea38d29)
       }),
       s2: Honk.G1Point({
-        x: uint256(0x1da71ffed08aa0fa2b5a58ab3fc27ffb7e2cf131547842780a24963048e2d5aa),
-        y: uint256(0x00ec65400c01cf5af83108cda478482094334d2ba594e370e47bb0bef1e30491)
+        x: uint256(0x245a672b0d35bdf197675411082a8ee1024aab2f95727039206a8403380fdaf8),
+        y: uint256(0x12abd51740375d49166bde266697381ca5260279174752c9e03ed6c466b86744)
       }),
       s3: Honk.G1Point({
-        x: uint256(0x076d8ef37e5f6a8a967907da958538f3302bc2360c31614a5e1832a1f3ceb421),
-        y: uint256(0x1c83f5d0dda79e6f11f5969084b6dcddd1432a426dca69f83a1b1cee21c9e208)
+        x: uint256(0x05d92f2af6e654e025fe6c6bab1a4e12b19f7a2cc149c33402472a0cc40cbaf7),
+        y: uint256(0x061370e345b4062d14f056256bbfa2c10eba7e585fb46ccead341f6811bd757a)
       }),
       s4: Honk.G1Point({
-        x: uint256(0x0fbf35404645e90f9aa8a9a37507098b6a6332c214ba9b9d65f6e05a5ef82b26),
-        y: uint256(0x0a6e47c369491fe21fc51c7b254dbaad6a9b6fba5f5fc1e1d66b11a05aca1eb5)
+        x: uint256(0x0860e07d6e2e6d913e58cd1eefa86a1d9a4cf4e29133f46c3d400b32dc9594af),
+        y: uint256(0x14c0357e31df310162c613184178967efe7a79c13f114a07ece96e80d301f082)
       }),
       t1: Honk.G1Point({
-        x: uint256(0x08a5ba822823e5f21f5585f7d90f070aaad388561d817362c819850cccf82580),
-        y: uint256(0x2d296fb3ec6c283d6f822a7e7f9edbe350516a4f9cba53be9dc8ac6240d0559c)
+        x: uint256(0x1f16b037f0b4c96ea2a30a118a44e139881c0db8a4d6c9fde7db5c1c1738e61f),
+        y: uint256(0x00c7781bda34afc32dedfb0d0f6b16c987c83375da000e180b44ad25685fc2ae)
       }),
       t2: Honk.G1Point({
-        x: uint256(0x201b4ffc4068dd22cc3a99a1ef5bc10e2be7841ed934ad5ea5247f992687c29b),
-        y: uint256(0x28351d4eacb149a545035052b1b2081b7e8c3ffa751c5bc31483b653f95cb6ca)
+        x: uint256(0x29345f914a28707887bee191c3a928191de584827a6d1a78ccce1d7629ca9dc0),
+        y: uint256(0x1920cebd0b33ac9713424e3bc03d53d79dc72f6afc24c90e56593094a213444c)
       }),
       t3: Honk.G1Point({
-        x: uint256(0x0d1a271b6b84d9a2d8953885c3b2d13d10aa96a483eeb4c7a41d65c19d69d638),
-        y: uint256(0x2a40aaa4bc03f75cbc60cc97a07b3e8885d4c99101b026f18219c82ee71443c4)
+        x: uint256(0x261c990958bc2ef77a45467d9639ab2c68cf787ff7bce55ce3074dfdaedc8f8f),
+        y: uint256(0x23c1c05424a40360a61e46f4deab04988a6f5b71dda351e0da608cff1f332ee0)
       }),
       t4: Honk.G1Point({
-        x: uint256(0x18216d5e69c40817c81feefd02de1aa548f7bf9d9ce4d671e96b22f368709ed5),
-        y: uint256(0x1e5e5f5acbdcd05a0ebffacea7a5426da9ec26a79cbb95692c9e9a499ff0155a)
+        x: uint256(0x2b651d2fd644b2972d72ec439dc69d3339d0b052a296bfc48c6a08396aaca078),
+        y: uint256(0x2d7e8c1ecb92e2490049b50efc811df63f1ca97e58d5e82852dbec0c29715d71)
       }),
       id1: Honk.G1Point({
-        x: uint256(0x0fcc20437825949a4e696438aea909760b3db2d273bf5b17f5fbfe3a70f036fb),
-        y: uint256(0x210603917536ed64abdd44a319ea9341a3f30a789789230a7e9cf6214b4bce7e)
+        x: uint256(0x2f22768b7d6cb9255a78d3045f4f91993c2b85d416d7368644777bb6a6aed6a4),
+        y: uint256(0x23a7f91dfce36352c68d9814946618220ada657d112dccac1d30f4b0e800cb78)
       }),
       id2: Honk.G1Point({
-        x: uint256(0x1ecfabef38de6cd4881366a1b917f8ff9f99a024f4b5087c0c0f566d2c3ea36b),
-        y: uint256(0x1dd57e4a465cfe220a85cafe9c22d18ea7500a73930a72a173882333424658fd)
+        x: uint256(0x0676ce7aa26b2303b49ab8eb603cd4d4d6cdde30dd8767a32e5a57cbad40d485),
+        y: uint256(0x0030ffd41d9c36d601af702ae6705909e05bdeae7a3668eda8a24b7f270e67a3)
       }),
       id3: Honk.G1Point({
-        x: uint256(0x0c44be4c332daa7e6c1989b113af431bbbd1177a9e3b296182a038c4898c58b8),
-        y: uint256(0x07c0db6714c5c1aae2d785402c39e9d18b09e367033cfcb2aecbb6991da057b1)
+        x: uint256(0x0d4104567de0b2e61083dfc969d70b67294cadb2bcae5e2fd5974fbfe3cdd025),
+        y: uint256(0x19beae607e8892176b30d2494fce1a7a9fcf9b367469413261bcb1db9d0c504b)
       }),
       id4: Honk.G1Point({
-        x: uint256(0x24443689861aa88435f69edc9782024e9207b659aab7df6694958fb85f6d4d5a),
-        y: uint256(0x19fa9eb82c3e56a745b7900324b2a205ab358a1dac89439011fc099408d21c96)
+        x: uint256(0x0927f450005fd2df96b3439570e88147f600d043616c8fb9a145ab6d25bc1b72),
+        y: uint256(0x12de11d953c0ba1f015f7363a5bfae565d2b5edefb6854eb60f71fe3e9950c7e)
       }),
       lagrangeFirst: Honk.G1Point({
         x: uint256(0x0000000000000000000000000000000000000000000000000000000000000001),
         y: uint256(0x0000000000000000000000000000000000000000000000000000000000000002)
       }),
       lagrangeLast: Honk.G1Point({
-        x: uint256(0x11dc324ee0b909fa5ec049c5832d17f8ba51b9f2990874ea77384948fcaa6800),
-        y: uint256(0x243280a04dd209d1241eb79b76c07ccc3bf501dd5b79fa218d4669cfb30316f8)
+        x: uint256(0x29b5224a64e89595783b8ed5c7d047e4d8a337cbf836ee2be2f20d7d47ce95b2),
+        y: uint256(0x13396543d3d0ccf426d918fd2199d9507eafa2a505f0cce2d958231b29af1e66)
       })
     });
     return vk;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crisp-e3/contracts",
-  "version": "0.4.1",
+  "version": "0.5.2",
   "type": "module",
   "files": [
     "contracts",
@@ -31,7 +31,7 @@
     "@zk-kit/lazy-imt.sol": "2.0.0-beta.12",
     "poseidon-solidity": "^0.0.5",
     "solady": "^0.1.13",
-    "@enclave-e3/contracts": "0.1.5"
+    "@enclave-e3/contracts": "0.1.7"
   },
   "devDependencies": {
     "@nomicfoundation/hardhat-ethers": "4",
@@ -59,8 +59,8 @@
     "typechain": "^8.3.0",
     "typescript": "5.8.3",
     "viem": "2.30.6",
-    "@crisp-e3/zk-inputs": "^0.4.1",
-    "@crisp-e3/sdk": "^0.4.1"
+    "@crisp-e3/sdk": "^0.5.2",
+    "@crisp-e3/zk-inputs": "^0.5.2"
   },
   "scripts": {
     "compile": "hardhat compile",
@@ -69,9 +69,9 @@
     "ciphernode:add:self": "hardhat ciphernode:add",
     "clean:deployments": "hardhat utils:clean-deployments",
     "deploy:contracts": "hardhat run deploy/deploy.ts",
-    "deploy:contracts:full": "export DEPLOY_ENCLAVE=true && pnpm deploy:contracts",
-    "deploy:contracts:full:mock": "export DEPLOY_ENCLAVE=true && export USE_MOCK_VERIFIER=true && export USE_MOCK_INPUT_VALIDATOR=true && pnpm deploy:contracts",
+    "deploy:contracts:full": "export DEPLOY_ENCLAVE=true USE_MOCK_VERIFIER=true && pnpm deploy:contracts",
     "test": "hardhat test mocha",
-    "verify": "hardhat run deploy/verify.ts"
+    "verify": "hardhat run deploy/verify.ts",
+    "updateSubmissionWindow": "hardhat ciphernode:window"
   }
 }

package/contracts/Mocks/MockCRISPProgram.sol

@@ -1,214 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-only
-//
-// This file is provided WITHOUT ANY WARRANTY;
-// without even the implied warranty of MERCHANTABILITY
-// or FITNESS FOR A PARTICULAR PURPOSE.
-pragma solidity >=0.8.27;
-
-import { IRiscZeroVerifier } from "risc0/IRiscZeroVerifier.sol";
-import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
-import { IE3Program } from "@enclave-e3/contracts/contracts/interfaces/IE3Program.sol";
-import { IEnclave } from "@enclave-e3/contracts/contracts/interfaces/IEnclave.sol";
-import { E3 } from "@enclave-e3/contracts/contracts/interfaces/IE3.sol";
-import { LazyIMTData, InternalLazyIMT } from "@zk-kit/lazy-imt.sol/InternalLazyIMT.sol";
-
-import { HonkVerifier } from "../CRISPVerifier.sol";
-
-contract MockCRISPProgram is IE3Program, Ownable {
-  using InternalLazyIMT for LazyIMTData;
-  /// @notice a structure that holds the round data
-  struct RoundData {
-    /// @notice The governance token address.
-    address token;
-    /// @notice The minimum balance required to pass the validation.
-    uint256 balanceThreshold;
-    /// @notice The Merkle root of the census.
-    uint256 censusMerkleRoot;
-  }
-
-  // Constants
-  bytes32 public constant ENCRYPTION_SCHEME_ID = keccak256("fhe.rs:BFV");
-
-  // The depth of the input merkle tree
-  uint8 public constant TREE_DEPTH = 20;
-
-  // State variables
-  IEnclave public enclave;
-  IRiscZeroVerifier public verifier;
-  HonkVerifier private immutable HONK_VERIFIER;
-  bytes32 public imageId;
-
-  /// @notice the round data
-  RoundData public roundData;
-  /// @notice whether the round data has been set
-  bool public isDataSet;
-
-  /// @notice Half of the largest minimum degree used to fit votes
-  /// inside the plaintext polynomial
-  uint256 public constant HALF_LARGEST_MINIMUM_DEGREE = 28;
-
-  // Mappings
-  mapping(address => bool) public authorizedContracts;
-  mapping(uint256 e3Id => bytes32 paramsHash) public paramsHashes;
-  /// @notice Mapping to store votes slot indices. Each eligible voter has their own slot
-  /// to store their vote inside the merkle tree.
-  mapping(uint256 e3Id => mapping(address slot => uint40 index)) public voteSlots;
-  mapping(uint256 e3Id => LazyIMTData) public votes;
-
-  // Errors
-  error CallerNotAuthorized();
-  error E3AlreadyInitialized();
-  error E3DoesNotExist();
-  error EnclaveAddressZero();
-  error VerifierAddressZero();
-
-  /// @notice The error emitted when the honk verifier address is invalid.
-  error InvalidHonkVerifier();
-  /// @notice The error emitted when the input data is empty.
-  error EmptyInputData();
-  /// @notice The error emitted when the input data is invalid.
-  error InvalidInputData(bytes reason);
-  /// @notice The error emitted when the Noir proof is invalid.
-  error InvalidNoirProof();
-  /// @notice The error emitted when the round data is not set.
-  error RoundDataNotSet();
-  /// @notice The error emitted when trying to set the round data more than once.
-  error RoundDataAlreadySet();
-
-  /// @notice The event emitted when an input is published.
-  event InputPublished(uint256 indexed e3Id, bytes vote, uint256 index);
-
-  /// @notice Initialize the contract, binding it to a specified RISC Zero verifier.
-  /// @param _enclave The enclave address
-  /// @param _verifier The RISC Zero verifier address
-  /// @param _honkVerifier The honk verifier address
-  /// @param _imageId The image ID for the guest program
-  constructor(IEnclave _enclave, IRiscZeroVerifier _verifier, HonkVerifier _honkVerifier, bytes32 _imageId) Ownable(msg.sender) {
-    require(address(_enclave) != address(0), EnclaveAddressZero());
-    require(address(_verifier) != address(0), VerifierAddressZero());
-    require(address(_honkVerifier) != address(0), InvalidHonkVerifier());
-
-    enclave = _enclave;
-    verifier = _verifier;
-    HONK_VERIFIER = _honkVerifier;
-    authorizedContracts[address(_enclave)] = true;
-    imageId = _imageId;
-  }
-
-  /// @notice Sets the Round data. Can only be set once.
-  /// @param _root The Merkle root to set.
-  /// @param _token The governance token address.
-  /// @param _balanceThreshold The minimum balance required.
-  function setRoundData(uint256 _root, address _token, uint256 _balanceThreshold) external onlyOwner {
-    if (isDataSet) revert RoundDataAlreadySet();
-
-    isDataSet = true;
-
-    roundData = RoundData({ token: _token, balanceThreshold: _balanceThreshold, censusMerkleRoot: _root });
-  }
-
-  /// @notice Set the Image ID for the guest program
-  /// @param _imageId The new image ID.
-  function setImageId(bytes32 _imageId) external onlyOwner {
-    imageId = _imageId;
-  }
-
-  /// @notice Set the RISC Zero verifier address
-  /// @param _verifier The new RISC Zero verifier address
-  function setVerifier(IRiscZeroVerifier _verifier) external onlyOwner {
-    if (address(_verifier) == address(0)) revert VerifierAddressZero();
-    verifier = _verifier;
-  }
-
-  /// @notice Get the params hash for an E3 program
-  /// @param e3Id The E3 program ID
-  /// @return The params hash
-  function getParamsHash(uint256 e3Id) public view returns (bytes32) {
-    return paramsHashes[e3Id];
-  }
-
-  /// @notice Validate the E3 program parameters
-  /// @param e3Id The E3 program ID
-  /// @param e3ProgramParams The E3 program parameters
-  function validate(uint256 e3Id, uint256, bytes calldata e3ProgramParams, bytes calldata) external returns (bytes32) {
-    require(authorizedContracts[msg.sender] || msg.sender == owner(), CallerNotAuthorized());
-    require(paramsHashes[e3Id] == bytes32(0), E3AlreadyInitialized());
-    paramsHashes[e3Id] = keccak256(e3ProgramParams);
-
-    return ENCRYPTION_SCHEME_ID;
-  }
-
-  /// @inheritdoc IE3Program
-  function validateInput(uint256 e3Id, address, bytes memory data) external {
-    if (data.length == 0) revert EmptyInputData();
-
-    (, , bytes memory vote, ) = abi.decode(data, (bytes, bytes32[], bytes, address));
-  }
-
-  /// @notice Decode the tally from the plaintext output
-  /// @param e3Id The E3 program ID
-  /// @return yes The number of yes votes
-  /// @return no The number of no votes
-  function decodeTally(uint256 e3Id) public view returns (uint256 yes, uint256 no) {
-    // fetch from enclave
-    E3 memory e3 = enclave.getE3(e3Id);
-
-    // abi decode it into an array of uint256
-    uint256[] memory tally = abi.decode(e3.plaintextOutput, (uint256[]));
-
-    /// @notice We want to completely ignore anything outside of the coefficients
-    /// we agreed to store out votes on.
-    uint256 halfD = tally.length / 2;
-    uint256 START_INDEX_Y = halfD - HALF_LARGEST_MINIMUM_DEGREE;
-    uint256 START_INDEX_N = tally.length - HALF_LARGEST_MINIMUM_DEGREE;
-
-    // first weight (we are converting back from bits to integer)
-    uint256 weight = 2 ** (HALF_LARGEST_MINIMUM_DEGREE - 1);
-
-    // Convert yes votes
-    for (uint256 i = START_INDEX_Y; i < halfD; i++) {
-      yes += tally[i] * weight;
-      weight /= 2; // Right shift equivalent
-    }
-
-    // Reset weight for no votes
-    weight = 2 ** (HALF_LARGEST_MINIMUM_DEGREE - 1);
-
-    // Convert no votes
-    for (uint256 i = START_INDEX_N; i < tally.length; i++) {
-      no += tally[i] * weight;
-      weight /= 2;
-    }
-
-    return (yes, no);
-  }
-
-  /// @notice Verify the proof
-  /// @param e3Id The E3 program ID
-  /// @param ciphertextOutputHash The hash of the ciphertext output
-  /// @param proof The proof to verify
-  function verify(uint256 e3Id, bytes32 ciphertextOutputHash, bytes memory proof) external view override returns (bool) {
-    require(paramsHashes[e3Id] != bytes32(0), E3DoesNotExist());
-    bytes32 inputRoot = bytes32(votes[e3Id]._root(TREE_DEPTH));
-    bytes memory journal = new bytes(396); // (32 + 1) * 4 * 3
-
-    encodeLengthPrefixAndHash(journal, 0, ciphertextOutputHash);
-    encodeLengthPrefixAndHash(journal, 132, paramsHashes[e3Id]);
-    encodeLengthPrefixAndHash(journal, 264, inputRoot);
-
-    verifier.verify(proof, imageId, sha256(journal));
-    return true;
-  }
-
-  /// @notice Encode length prefix and hash
-  /// @param journal The journal to encode into
-  /// @param startIndex The start index in the journal
-  /// @param hashVal The hash value to encode
-  function encodeLengthPrefixAndHash(bytes memory journal, uint256 startIndex, bytes32 hashVal) internal pure {
-    journal[startIndex] = 0x20;
-    startIndex += 4;
-    for (uint256 i = 0; i < 32; i++) {
-      journal[startIndex + i * 4] = hashVal[i];
-    }
-  }
-}