@crisp-e3/contracts 0.5.7 → 0.5.9

package/contracts/CRISPProgram.sol

@@ -10,7 +10,7 @@ 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, PoseidonT3 } from "@zk-kit/lazy-imt.sol/InternalLazyIMT.sol";
+import { LazyIMTData, InternalLazyIMT } from "@zk-kit/lazy-imt.sol/InternalLazyIMT.sol";
 import { HonkVerifier } from "./CRISPVerifier.sol";
 
 contract CRISPProgram is IE3Program, Ownable {
@@ -22,6 +22,7 @@ contract CRISPProgram is IE3Program, Ownable {
     bytes32 paramsHash;
     mapping(address slot => uint40 index) voteSlots;
     LazyIMTData votes;
+    uint256 numOptions;
   }
 
   // Constants
@@ -29,6 +30,8 @@ contract CRISPProgram is IE3Program, Ownable {
   bytes32 public constant ENCRYPTION_SCHEME_ID = keccak256("fhe.rs:BFV");
   /// @notice The depth of the input Merkle tree.
   uint8 public constant TREE_DEPTH = 20;
+  /// @notice Maximum number of bits allocated for vote counts in the plaintext output per option.
+  uint256 constant MAX_VOTE_BITS = 50;
 
   // State variables
   IEnclave public enclave;
@@ -54,9 +57,10 @@ contract CRISPProgram is IE3Program, Ownable {
   error InvalidTallyLength();
   error SlotIsEmpty();
   error MerkleRootNotSet();
+  error InvalidNumOptions();
 
   // Events
-  event InputPublished(uint256 indexed e3Id, bytes vote, uint256 index);
+  event InputPublished(uint256 indexed e3Id, bytes encryptedVote, uint256 index);
 
   /// @notice Initialize the contract, binding it to a specified RISC Zero verifier.
   /// @param _enclave The enclave address
@@ -106,10 +110,22 @@ contract CRISPProgram is IE3Program, Ownable {
   }
 
   /// @inheritdoc IE3Program
-  function validate(uint256 e3Id, uint256, bytes calldata e3ProgramParams, bytes calldata) external returns (bytes32) {
+  function validate(
+    uint256 e3Id,
+    uint256,
+    bytes calldata e3ProgramParams,
+    bytes calldata,
+    bytes calldata customParams
+  ) external returns (bytes32) {
     if (!authorizedContracts[msg.sender] && msg.sender != owner()) revert CallerNotAuthorized();
     if (e3Data[e3Id].paramsHash != bytes32(0)) revert E3AlreadyInitialized();
 
+    // decode custom params to get the number of options
+    (, , uint256 numOptions) = abi.decode(customParams, (address, uint256, uint256));
+    if (numOptions < 2) revert InvalidNumOptions();
+
+    e3Data[e3Id].numOptions = numOptions;
+
     e3Data[e3Id].paramsHash = keccak256(e3ProgramParams);
 
     // Initialize the votes Merkle tree for this E3 ID.
@@ -128,60 +144,70 @@ contract CRISPProgram is IE3Program, Ownable {
 
     if (data.length == 0) revert EmptyInputData();
 
-    (bytes memory noirProof, bytes32[] memory vote, address slotAddress) = abi.decode(data, (bytes, bytes32[], address));
-
-    bytes memory voteBytes = abi.encode(vote);
+    (bytes memory noirProof, address slotAddress, bytes32 encryptedVoteCommitment, bytes memory encryptedVote) = abi.decode(
+      data,
+      (bytes, address, bytes32, bytes)
+    );
 
-    (uint40 voteIndex, bool isFirstVote) = _processVote(e3Id, slotAddress, voteBytes);
-
-    // Set public inputs for the proof. Order must match Noir circuit.
-    bytes32[] memory noirPublicInputs = new bytes32[](4 + vote.length);
+    (uint40 voteIndex, bytes32 previousEncryptedVoteCommitment) = _processVote(e3Id, slotAddress, encryptedVoteCommitment);
 
     // Fetch E3 to get committee public key
     E3 memory e3 = enclave.getE3(e3Id);
 
-    noirPublicInputs[0] = e3.committeePublicKey;
-    noirPublicInputs[1] = bytes32(e3Data[e3Id].merkleRoot);
-    noirPublicInputs[2] = bytes32(uint256(uint160(slotAddress)));
-    noirPublicInputs[3] = bytes32(uint256(isFirstVote ? 1 : 0));
-    for (uint256 i = 0; i < vote.length; i++) {
-      noirPublicInputs[i + 4] = vote[i];
-    }
+    // Set the public inputs for the proof. Order must match Noir circuit.
+    bytes32[] memory noirPublicInputs = new bytes32[](7);
+    noirPublicInputs[0] = previousEncryptedVoteCommitment;
+    noirPublicInputs[1] = e3.committeePublicKey;
+    noirPublicInputs[2] = bytes32(e3Data[e3Id].merkleRoot);
+    noirPublicInputs[3] = bytes32(uint256(uint160(slotAddress)));
+    noirPublicInputs[4] = bytes32(uint256(previousEncryptedVoteCommitment == bytes32(0) ? 1 : 0));
+    noirPublicInputs[5] = bytes32(e3Data[e3Id].numOptions);
+    noirPublicInputs[6] = encryptedVoteCommitment;
 
     // Check if the ciphertext was encrypted correctly
     if (!honkVerifier.verify(noirProof, noirPublicInputs)) {
       revert InvalidNoirProof();
     }
 
-    emit InputPublished(e3Id, voteBytes, voteIndex);
+    emit InputPublished(e3Id, encryptedVote, voteIndex);
   }
 
   /// @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
+  /// @return votes - an array of vote counts for each option
+  function decodeTally(uint256 e3Id) public view returns (uint256[] memory votes) {
     E3 memory e3 = enclave.getE3(e3Id);
 
-    // decode it into an array of uint64
+    uint256 numOptions = e3Data[e3Id].numOptions;
+
+    // If num optionsis not configured, return empty array to avoid decoding errors.
+    // Users might be calling this function too early and there's no
+    if (numOptions == 0) {
+      return new uint256[](0);
+    }
+
     uint64[] memory tally = _decodeBytesToUint64Array(e3.plaintextOutput);
 
-    uint256 halfD = tally.length / 2;
+    uint256 segmentSize = tally.length / numOptions;
+    uint256 effectiveSize = segmentSize > MAX_VOTE_BITS ? MAX_VOTE_BITS : segmentSize;
 
-    // Convert yes votes
-    for (uint256 i = 0; i < halfD; i++) {
-      uint256 weight = 2 ** (halfD - 1 - i);
-      yes += tally[i] * weight;
-    }
+    votes = new uint256[](numOptions);
+
+    for (uint256 optIdx = 0; optIdx < numOptions; optIdx++) {
+      uint256 segmentStart = optIdx * segmentSize;
+      // Read only the last effectiveSize bits (where the value is, MSB first)
+      uint256 readStart = segmentStart + segmentSize - effectiveSize;
+      uint256 value = 0;
+
+      for (uint256 i = 0; i < effectiveSize; i++) {
+        uint256 weight = 2 ** (effectiveSize - 1 - i);
+        value += uint256(tally[readStart + i]) * weight;
+      }
 
-    // Convert no votes
-    for (uint256 i = halfD; i < tally.length; i++) {
-      uint256 weight = 2 ** (tally.length - 1 - i);
-      no += tally[i] * weight;
+      votes[optIdx] = value;
     }
 
-    return (yes, no);
+    return votes;
   }
 
   /// @notice Get the slot index for a given E3 ID and slot address
@@ -220,22 +246,26 @@ contract CRISPProgram is IE3Program, Ownable {
 
   /// @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) {
+  function _processVote(
+    uint256 e3Id,
+    address slotAddress,
+    bytes32 encryptedVoteCommitment
+  ) internal returns (uint40 voteIndex, bytes32 previousEncryptedVoteCommitment) {
     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;
+      previousEncryptedVoteCommitment = bytes32(0);
       voteIndex = e3Data[e3Id].votes.numberOfLeaves;
       e3Data[e3Id].voteSlots[slotAddress] = voteIndex + 1;
-      e3Data[e3Id].votes._insert(PoseidonT3.hash([uint256(keccak256(vote)), voteIndex]));
+      e3Data[e3Id].votes._insert(uint256(encryptedVoteCommitment));
     } else {
       // RE-VOTE
-      isFirstVote = false;
       voteIndex = storedIndexPlusOne - 1;
-      e3Data[e3Id].votes._update(PoseidonT3.hash([uint256(keccak256(vote)), voteIndex]), voteIndex);
+      previousEncryptedVoteCommitment = bytes32(e3Data[e3Id].votes.elements[voteIndex]);
+      e3Data[e3Id].votes._update(uint256(encryptedVoteCommitment), voteIndex);
     }
   }
 

package/contracts/CRISPVerifier.sol

@@ -1,91 +1,88 @@
-// 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.
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2022 Aztec
 pragma solidity >=0.8.21;
 
-uint256 constant N = 262144;
-uint256 constant LOG_N = 18;
-uint256 constant NUMBER_OF_PUBLIC_INPUTS = 2068;
-uint256 constant VK_HASH = 0x1ca8d8a2b64dc27e11e756a83b5efcf951b1dddf2ecb023022dcbf4ba1005de2;
+uint256 constant N = 524288;
+uint256 constant LOG_N = 19;
+uint256 constant NUMBER_OF_PUBLIC_INPUTS = 23;
+uint256 constant VK_HASH = 0x2349c3d182cb0307ecfa17d2cb91dcf9e7742a8daa67aa106831c761dd22030d;
 library HonkVerificationKey {
   function loadVerificationKey() internal pure returns (Honk.VerificationKey memory) {
     Honk.VerificationKey memory vk = Honk.VerificationKey({
-      circuitSize: uint256(262144),
-      logCircuitSize: uint256(18),
-      publicInputsSize: uint256(2068),
+      circuitSize: uint256(524288),
+      logCircuitSize: uint256(19),
+      publicInputsSize: uint256(23),
       ql: Honk.G1Point({
-        x: uint256(0x0c3acef8966ceb2984e47121b763f16a862f3cdb33c24d4b03009a9f737408f6),
-        y: uint256(0x0da7bce94c82ecdbd4ae789e9753251fd8afc89d9605932b1154387a3d8c00e6)
+        x: uint256(0x253c5186ca1b682f7d302cd73b85ea3447a5a2c64fc82b70652f7fc44b203128),
+        y: uint256(0x14f602413e183c57d3d3124290ab48b6c8b0cbace773766a573ead30bf5c2f4f)
       }),
       qr: Honk.G1Point({
-        x: uint256(0x2e41f2c832adad1d96df181c43ca52c717835470c7e471c087067197e33860d6),
-        y: uint256(0x25d16a68285523a3e9d8a42344a7489d493b8ddd51ed24b0c566651ca06eb8dc)
+        x: uint256(0x2d20633d112c7c7efd2821f2860e9d1287f8f68ddd4b0216bb179078497a571c),
+        y: uint256(0x11928235f13ba529b1ee2f75fe26dda5ed5c79ec36028c09ad2bd8b957546344)
       }),
       qo: Honk.G1Point({
-        x: uint256(0x0c0e53fdc05955a112f7b1efaa77afb15271c8ee842163186bbca2a110a6deba),
-        y: uint256(0x05a9f03fe46a2347ef8aceb395dbc221cf4e180f63bd6e9de07cded19378fdb2)
+        x: uint256(0x2b570f8e2eccc265f39b9e73778cf6e282554452adb19d2a2406952447d4aa6e),
+        y: uint256(0x14afd678c64e0dacd64724504e36bca6eccb5a477a5e2987b6543246b8135a90)
       }),
       q4: Honk.G1Point({
-        x: uint256(0x1e1cc841a9a3716e0689dca8bcc18f2b9e290bfeaef1f78c28cdcedb13f29d40),
-        y: uint256(0x12774484a5526ca36a7e91d0d53ec3e115321f609a662b5050ad378a024311e5)
+        x: uint256(0x2d7f53a245e9c855325eeb73c8fea788f5b457293cacfd7e3e332210a27a7d2f),
+        y: uint256(0x182d5ef8840426caa829856d7e800ee98509383d9ee637d1facbc11f7a8fba0d)
       }),
       qm: Honk.G1Point({
-        x: uint256(0x251c96f789fb3fc5258489bec45ec137c054966c8674132e27feeccf5a81cf25),
-        y: uint256(0x20491536be9bafbc08346c0a71a3ed3beffb13f2e9f092008230397a1c5fc98d)
+        x: uint256(0x19d90118c106191d2f2f0350a56547c943c1ed5910d47dd067761099b54d11f3),
+        y: uint256(0x0f8f03c2def6108448f72f5177b6a2eed01250670efb63ea6f5ab65abc2a6885)
       }),
       qc: Honk.G1Point({
-        x: uint256(0x0936620bea178cd901115b75f458c8de74899315505e3e52852f668b6fd37674),
-        y: uint256(0x1ea7f29d26f0d4a3ecd04724b76fe410c7a30e6eb4d8e44f09c5beeaa5f78780)
+        x: uint256(0x2ead500c79e717f5cdbba88ffef46477c4f30926bf59547a9c141c4158f7c843),
+        y: uint256(0x027d6b571b395cf61aae9626f172ce4e41e598456f7b8e535c027e9129b2c98e)
       }),
       qLookup: Honk.G1Point({
-        x: uint256(0x21ed84b63d62aef10a8cd203641cd62f5a42825efd4807a47a4f5d006e44b6af),
-        y: uint256(0x306347f78166296722434632227c5ac52adfcdf24ee09169a6fb79d4258c7cca)
+        x: uint256(0x136236e1bfc2af648ac078e134c1b4b9114b11937ebafcdd87f8ca7660715ebb),
+        y: uint256(0x02293c705250462935a653b7b993e13e2e8bc6480c45c84976d526cbdbd071df)
       }),
       qArith: Honk.G1Point({
-        x: uint256(0x053507710ff715cf9363741dc46cc5d686fdd09012e3ccf83a38e3f79f491bb0),
-        y: uint256(0x0d004c2714d1630398938e93adc23622cb4ae4ca78141a68fb9e365295650cde)
+        x: uint256(0x074e7ead679c76d2c2d6d3f158cb522e71d14a169b2b1d0792cdfdad726f17a4),
+        y: uint256(0x21f9acd78d4150858f29c259c07e4552f6ec4bffac6c1e174cfb90e2e26bd68a)
       }),
       qDeltaRange: Honk.G1Point({
-        x: uint256(0x0ddde3ce2b24613aed779dde885daa094fb9087cba224838118a08fa197139db),
-        y: uint256(0x0030cdcf467265124848353360e5e29839ebd846b687a512f99ae7f8a2a54490)
+        x: uint256(0x0cebfba75751a4eff3d7855bf0f314e523e2c709a75992eb5674a546627248e3),
+        y: uint256(0x16b715150f4de399940c535932174f5c634c9fd9137a94008bb38f89f1350b4c)
       }),
       qElliptic: Honk.G1Point({
-        x: uint256(0x0214eea9bd774ccbaea3cd9753e77adb6af9bfc2c5ef210160d6af8520204de9),
-        y: uint256(0x0ac1443dca135c5ddc9a1c38a4323d54a554867a0db1b82b752f9416b6eb8301)
+        x: uint256(0x174dba7fa4e38a55a78e43dda6c3fb81a1293285cf33eeb333ee186bb4331563),
+        y: uint256(0x0a2ff722359e35596e5abeec834c6cd73f4b06f5f2e837b31364f199f449ca77)
       }),
       qMemory: Honk.G1Point({
-        x: uint256(0x1cb6ea41a55bb0a307ebbbc130d80e6039a971ac4664ed84a2968b8bf2ebbf49),
-        y: uint256(0x0047bc403498ca5f6ed5c9d15827dcd65dae3030a28002112e1d789680eaac2e)
+        x: uint256(0x29f116092db8eb3773b017110ca5d3a7b35fa1b064cde91c9e280e20399d7ec2),
+        y: uint256(0x1f0e39e18ded75167a270d6e31b9a6ad9a9d1b0d67c365eeb172a3fea4d1371e)
       }),
       qNnf: Honk.G1Point({
-        x: uint256(0x2c45a53bef969d29924c1585f468d78c3f81a9a2026a37029e4651b8099f61b2),
-        y: uint256(0x1ff421b8b79665b7ad9c598f4143d155db08e0120f2a8bdd93fae19c5c8caca8)
+        x: uint256(0x19da50fca27dd36a006892b7cb6b36d7cfdac9d65fec6ae7a1a2e092e0988de5),
+        y: uint256(0x08f96f1d8e37be6dc83c9fbb3b912493841e4e81ab28a60c0fc85337cc4ed977)
       }),
       qPoseidon2External: Honk.G1Point({
-        x: uint256(0x29a806a3d3deae47f9de89d35a3200f2f66c4b78bab19c0dfb5fe8348f669582),
-        y: uint256(0x0dc3b792592ccdde2d18bae94cca0e8d499814c70e8bfaeaa63dd902ea7ad008)
+        x: uint256(0x2d20446a333063e66c1a552fecdfe12d0fdddeef0034569ac350f3299b09955a),
+        y: uint256(0x175e6e8776625134217ce9516a11cbbeab8c4c1c8b41cfb75f43de1f500b07d2)
       }),
       qPoseidon2Internal: Honk.G1Point({
-        x: uint256(0x05024f6de65a4dcced2738308dbda5326cbaafad2981f8b67526eb0eb1cce144),
-        y: uint256(0x07ec05f2076b4369362030c2c7acbef7efca4eea33e2b13c8a5b92b02a8e34c3)
+        x: uint256(0x090a76cca3c754a2ba40abdc2572fff64645060cfa5c48239a1df4dbb8360828),
+        y: uint256(0x0499d4c6aed1f78b33a6701459cd069e9bf7262754d2f15074a6c2401950761f)
       }),
       s1: Honk.G1Point({
-        x: uint256(0x01e80e00cc438bef1c0311d8e860d214f1f4f8c030cb97110c64fdb2dbb24f51),
-        y: uint256(0x17441e3965eacb1bedc71d9983aeb0558222c093f142e597fc66a0b7e9973907)
+        x: uint256(0x012609fcd0fa67214d78f2d5f5e3e2b459a3c4b21531646de7d51d9cd5383aa9),
+        y: uint256(0x21394cebbe5f66f3aecf43d318b3cb9fc7640825baba0c5a5c190a20ceeb5edb)
       }),
       s2: Honk.G1Point({
-        x: uint256(0x0d4e58d4f2698d73f7d0980c9e07a20d0587292bbc97212f9f85a786e03847bc),
-        y: uint256(0x27d389ca0c65494fab3c321aafe3f289ad39b778b76b524fa396c6b51004f812)
+        x: uint256(0x080c7f024d9c813c60c84fc3e9bcad553c51f276d55e8d7a03c044b41cedef36),
+        y: uint256(0x2109db10b2da84ec2c4a1b62689d0952ababe94915293dfee09f1083010e5cfb)
       }),
       s3: Honk.G1Point({
-        x: uint256(0x27e70f21603a4902a769ea6822a6c06d0715a9f39795fe18fdb6327bf41abca0),
-        y: uint256(0x1fedc45c7c852a9ebcb12ad5aa0a6df0c8f9576bed8a6d51ba8187b8936d4bd5)
+        x: uint256(0x2f7d6b77cd5c3ee56c255be61d0e90fd7da5898a7ce4850aaf1060513cb7cd9d),
+        y: uint256(0x2ce5fdacbf91fc3358f4eba637d60f109f70fa929a6a1bc1f9d86e7856b87dcd)
       }),
       s4: Honk.G1Point({
-        x: uint256(0x1ff580dc873878337c5f7697ceb402342ce1b821c37d766f97cedd93b63d0359),
-        y: uint256(0x196d7d19376846c104f0ef472a6ed732fd243e356908ba33f6c68901ffe8ce13)
+        x: uint256(0x1db1540beb4dc13e8519b82205e9b4cb48833040c8b322d626df57e078afecc4),
+        y: uint256(0x28eb12f9f02ac092326277365f9eeaff536b8dbf771f9ace22d0e122f922196a)
       }),
       t1: Honk.G1Point({
         x: uint256(0x1f16b037f0b4c96ea2a30a118a44e139881c0db8a4d6c9fde7db5c1c1738e61f),
@@ -104,28 +101,28 @@ library HonkVerificationKey {
         y: uint256(0x2d7e8c1ecb92e2490049b50efc811df63f1ca97e58d5e82852dbec0c29715d71)
       }),
       id1: Honk.G1Point({
-        x: uint256(0x0fc864a6c1236d620b1c09c9278c95610758a8f5fea80f681fd1587c9406ecbf),
-        y: uint256(0x077911571c3508dbc02c65c15ae1cb3af33b2b69fe73f460925f5c5f906fb51e)
+        x: uint256(0x0a10b2e79989b15e3a69bd491cdae007b0bf9c82d9be3d7867b33e2287b91dac),
+        y: uint256(0x257794eaba7a0e7aed16e03d4d8c4cf7d878b029f4ea45c559bbc19b5ec4d1de)
       }),
       id2: Honk.G1Point({
-        x: uint256(0x23760b478cf3aaefe6782ad269e6bed4dbad373b85cf73685b5eb77ec9498bcf),
-        y: uint256(0x12b6be9b4f5b3cce944a695ad7517218ffb6648ec1a74d4bd028b053a565de67)
+        x: uint256(0x25791b725ea7c712316ac4ffe10fdfcf37bd2b8f9d730ba2e26fa709bc7c3ae0),
+        y: uint256(0x15fba3e7928d36dc4dd6d6ff198b928c7246310974d4f74161cfd2781b9d3686)
       }),
       id3: Honk.G1Point({
-        x: uint256(0x144205f099b5c04c0a4a51e30bf20bd5fff8a82be5eac9a059961db089cb34dc),
-        y: uint256(0x256a6fdb5a8a8a5dfb285dcaeefb4bf590f58900fb648ba715e465cd3f745918)
+        x: uint256(0x270be32427e6404801b9b014f983d80acf18b828c6cf049f430d98fbe34e85e0),
+        y: uint256(0x2e7d27a99c4b574557ea6117c390c65072cdfa51a08621141ae26d7e143d0669)
       }),
       id4: Honk.G1Point({
-        x: uint256(0x1e1ea32eea4d1afcee4572ecca811099f54e90fcf09b4037f8505248cb65f2c6),
-        y: uint256(0x10df7dee70bc3946d428fe27811eedbe58a9a9565c9b734268e646b30aed50b8)
+        x: uint256(0x18e2902febdb3e45358fe65981f338a7ffd1b16edd917de670fabe5d15307e20),
+        y: uint256(0x2f6f36f307a0f7012dc3918795312e71a1d4752966c2bc3151e5f5b3151fc236)
       }),
       lagrangeFirst: Honk.G1Point({
         x: uint256(0x0000000000000000000000000000000000000000000000000000000000000001),
         y: uint256(0x0000000000000000000000000000000000000000000000000000000000000002)
       }),
       lagrangeLast: Honk.G1Point({
-        x: uint256(0x2e8854320df8d7e2bc104a691285ebb73e6a6aeb5834d8818ddfb90779ef7b4a),
-        y: uint256(0x2a1a85f62dd5371e29e46b650f9b995e91b864d6bebd1bcb0604635f5a5c4270)
+        x: uint256(0x12b14f226e24a52e0bc85bc5478c806023107f257430aae49136064dd3315c60),
+        y: uint256(0x0dfe490435cf839caf81df5c8a164afc5e3c8646f36bf27c19850b3f913edce4)
       })
     });
     return vk;

package/contracts/Mocks/MockEnclave.sol

@@ -13,6 +13,34 @@ contract MockEnclave {
   bytes public plaintextOutput;
   bytes32 public committeePublicKey;
 
+  uint256 public nextE3Id;
+
+  mapping(uint256 => E3) public e3s;
+
+  function request(address program) external {
+    e3s[nextE3Id] = E3({
+      seed: 0,
+      threshold: [uint32(1), uint32(2)],
+      requestBlock: 0,
+      startWindow: [uint256(0), uint256(0)],
+      duration: 0,
+      expiration: 0,
+      encryptionSchemeId: bytes32(0),
+      e3Program: IE3Program(program),
+      e3ProgramParams: bytes(""),
+      customParams: abi.encode(address(0), nextE3Id, 2),
+      decryptionVerifier: IDecryptionVerifier(address(0)),
+      committeePublicKey: committeePublicKey,
+      ciphertextOutput: bytes32(0),
+      plaintextOutput: plaintextOutput,
+      requester: address(0)
+    });
+
+    IE3Program(program).validate(nextE3Id, 0, bytes(""), bytes(""), abi.encode(address(0), nextE3Id, 2));
+
+    nextE3Id++;
+  }
+
   function setPlaintextOutput(bytes memory plaintext) external {
     plaintextOutput = plaintext;
   }
@@ -21,7 +49,7 @@ contract MockEnclave {
     committeePublicKey = publicKeyHash;
   }
 
-  function getE3(uint256 e3Id) external view returns (E3 memory) {
+  function getE3(uint256) external view returns (E3 memory) {
     return
       E3({
         seed: 0,
@@ -33,11 +61,12 @@ contract MockEnclave {
         encryptionSchemeId: bytes32(0),
         e3Program: IE3Program(address(0)),
         e3ProgramParams: bytes(""),
-        customParams: bytes(""),
+        customParams: abi.encode(address(0), 0, 2),
         decryptionVerifier: IDecryptionVerifier(address(0)),
         committeePublicKey: committeePublicKey,
         ciphertextOutput: bytes32(0),
-        plaintextOutput: plaintextOutput
+        plaintextOutput: plaintextOutput,
+        requester: address(0)
       });
   }
 }

package/contracts/Mocks/MockVotingToken.sol

@@ -0,0 +1,34 @@
+// 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 { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+/// @title MockVotingToken
+/// @notice A mock voting token for testing purposes
+/// @dev Public mint function that allows to keep balances to 1e9.
+/// @dev by default CRISP server will scale down voting power by 1e18/2
+/// @dev in this case leaving everyone with a balance of 1 to vote yes or no
+contract MockVotingToken is ERC20 {
+  // half of 10e18
+  uint256 public constant MAX_BALANCE = 1e9;
+
+  constructor() ERC20("Mock Voting Token", "MVT") {
+    _mint(msg.sender, 1e9);
+  }
+
+  function mint(address to, uint256) external {
+    if (balanceOf(to) + 1e9 > MAX_BALANCE) {
+      // silently fail
+      return;
+    }
+    _mint(to, 1e9);
+  }
+
+  function decimals() public pure override returns (uint8) {
+    return 18;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crisp-e3/contracts",
-  "version": "0.5.7",
+  "version": "0.5.9",
   "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.7"
+    "@enclave-e3/contracts": "0.1.8"
   },
   "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.5.7",
-    "@crisp-e3/sdk": "^0.5.7"
+    "@crisp-e3/zk-inputs": "^0.5.9",
+    "@crisp-e3/sdk": "^0.5.9"
   },
   "scripts": {
     "compile": "hardhat compile",
@@ -69,8 +69,9 @@
     "ciphernode:add:self": "hardhat ciphernode:add",
     "clean:deployments": "hardhat utils:clean-deployments",
     "deploy:contracts": "hardhat run deploy/deploy.ts",
+    "deploy:contracts:mock": "export USE_MOCKS=true PRINT_ENV_VARS=true && pnpm deploy:contracts",
     "deploy:contracts:full": "export DEPLOY_ENCLAVE=true && pnpm deploy:contracts",
-    "deploy:contracts:full:mock": "export DEPLOY_ENCLAVE=true USE_MOCK_VERIFIER=true PRINT_ENV_VARS=true && pnpm deploy:contracts",
+    "deploy:contracts:full:mock": "export DEPLOY_ENCLAVE=true USE_MOCKS=true PRINT_ENV_VARS=true && pnpm deploy:contracts",
     "test": "hardhat test mocha",
     "verify": "hardhat run deploy/verify.ts",
     "updateSubmissionWindow": "hardhat ciphernode:window"