@crisp-e3/contracts 0.5.8 → 0.5.10

package/contracts/CRISPProgram.sol

@@ -16,12 +16,22 @@ import { HonkVerifier } from "./CRISPVerifier.sol";
 contract CRISPProgram is IE3Program, Ownable {
   using InternalLazyIMT for LazyIMTData;
 
+  /// @notice Enum to represent credit modes
+  enum CreditMode {
+    /// @notice Everyone has constant credits
+    CONSTANT,
+    /// @notice Credits are custom (can be based on token balance, etc)
+    CUSTOM
+  }
+
   /// @notice Struct to store all data related to a voting round
   struct RoundData {
     uint256 merkleRoot;
     bytes32 paramsHash;
     mapping(address slot => uint40 index) voteSlots;
     LazyIMTData votes;
+    uint256 numOptions;
+    CreditMode creditMode;
   }
 
   // Constants
@@ -29,6 +39,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,6 +66,7 @@ contract CRISPProgram is IE3Program, Ownable {
   error InvalidTallyLength();
   error SlotIsEmpty();
   error MerkleRootNotSet();
+  error InvalidNumOptions();
 
   // Events
   event InputPublished(uint256 indexed e3Id, bytes encryptedVote, uint256 index);
@@ -106,10 +119,25 @@ 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, CreditMode creditMode, ) = abi.decode(customParams, (address, uint256, uint256, CreditMode, uint256));
+    if (numOptions < 2) revert InvalidNumOptions();
+
+    // we need to know the number of options for decoding the tally
+    e3Data[e3Id].numOptions = numOptions;
+    // we want to save the credit more so it can be verified on chain by everyone
+    e3Data[e3Id].creditMode = creditMode;
+
     e3Data[e3Id].paramsHash = keccak256(e3ProgramParams);
 
     // Initialize the votes Merkle tree for this E3 ID.
@@ -139,13 +167,14 @@ contract CRISPProgram is IE3Program, Ownable {
     E3 memory e3 = enclave.getE3(e3Id);
 
     // Set the public inputs for the proof. Order must match Noir circuit.
-    bytes32[] memory noirPublicInputs = new bytes32[](6);
+    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] = encryptedVoteCommitment;
+    noirPublicInputs[5] = bytes32(e3Data[e3Id].numOptions);
+    noirPublicInputs[6] = encryptedVoteCommitment;
 
     // Check if the ciphertext was encrypted correctly
     if (!honkVerifier.verify(noirProof, noirPublicInputs)) {
@@ -157,30 +186,40 @@ contract CRISPProgram is IE3Program, Ownable {
 
   /// @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

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 = 22;
-uint256 constant VK_HASH = 0x0d53ba57f65358b21e53cf07b91c27906ac4d24b9205fda35494e1a44ba7242a;
+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(22),
+      circuitSize: uint256(524288),
+      logCircuitSize: uint256(19),
+      publicInputsSize: uint256(23),
       ql: Honk.G1Point({
-        x: uint256(0x112a6aa13787457ce92f268d8f6719287c1add28a224712ea3e2e7d96e2bc70b),
-        y: uint256(0x14dcf6e306f1dc722638d4984332053df53689114040ccd69d5926f485219e15)
+        x: uint256(0x253c5186ca1b682f7d302cd73b85ea3447a5a2c64fc82b70652f7fc44b203128),
+        y: uint256(0x14f602413e183c57d3d3124290ab48b6c8b0cbace773766a573ead30bf5c2f4f)
       }),
       qr: Honk.G1Point({
-        x: uint256(0x22a648530332803c4a992d98fd94a036c8ff1341c3d0ba385210b8851049206c),
-        y: uint256(0x0b891280448cdaee82da9caec22fb4820e3140558570c252669508b4f90fba2b)
+        x: uint256(0x2d20633d112c7c7efd2821f2860e9d1287f8f68ddd4b0216bb179078497a571c),
+        y: uint256(0x11928235f13ba529b1ee2f75fe26dda5ed5c79ec36028c09ad2bd8b957546344)
       }),
       qo: Honk.G1Point({
-        x: uint256(0x1ca6c37b9177a348c574f214e0683da82632df5c0d10addde3f372cda3f8978a),
-        y: uint256(0x22ce8ff67ba39a26d4ad603fbe668d9eb3f34f80b4e21e5cbf421d873f6ca040)
+        x: uint256(0x2b570f8e2eccc265f39b9e73778cf6e282554452adb19d2a2406952447d4aa6e),
+        y: uint256(0x14afd678c64e0dacd64724504e36bca6eccb5a477a5e2987b6543246b8135a90)
       }),
       q4: Honk.G1Point({
-        x: uint256(0x0af0446ba584e461430e07a1f990aaee46d7b5088ad9f54d4a1350d57fa37ab6),
-        y: uint256(0x152ab3b635c7f88c62d6bb37fdff5bed5e42e01e0f9894058c10deea1994e4ef)
+        x: uint256(0x2d7f53a245e9c855325eeb73c8fea788f5b457293cacfd7e3e332210a27a7d2f),
+        y: uint256(0x182d5ef8840426caa829856d7e800ee98509383d9ee637d1facbc11f7a8fba0d)
       }),
       qm: Honk.G1Point({
-        x: uint256(0x2493bb0b6575f4240fa4ca66ab503effe7ad653c552cfe608e662e18e8ce5eb8),
-        y: uint256(0x1b5829dbe6ee24d5f1a776ddc4e27a90888310a3f384fe8f70cd86c2f9eebf7e)
+        x: uint256(0x19d90118c106191d2f2f0350a56547c943c1ed5910d47dd067761099b54d11f3),
+        y: uint256(0x0f8f03c2def6108448f72f5177b6a2eed01250670efb63ea6f5ab65abc2a6885)
       }),
       qc: Honk.G1Point({
-        x: uint256(0x2ccaa4f079bfc85f3887807ba17bffd69c73402d557395f6730d31cf1f208e53),
-        y: uint256(0x11e38adba343d4c9839c5b4ed4d54c38d7d0e17b0c3890add1544aa18a53f805)
+        x: uint256(0x2ead500c79e717f5cdbba88ffef46477c4f30926bf59547a9c141c4158f7c843),
+        y: uint256(0x027d6b571b395cf61aae9626f172ce4e41e598456f7b8e535c027e9129b2c98e)
       }),
       qLookup: Honk.G1Point({
-        x: uint256(0x111ada27d4243c5df982e1cd77f2d9aff394ba4f2ba2faf8ec1a8e5b6d78d1e7),
-        y: uint256(0x1cf81a5fe339ef18222213e43155e149d0211317fe0a68d795681f31ef25ad0f)
+        x: uint256(0x136236e1bfc2af648ac078e134c1b4b9114b11937ebafcdd87f8ca7660715ebb),
+        y: uint256(0x02293c705250462935a653b7b993e13e2e8bc6480c45c84976d526cbdbd071df)
       }),
       qArith: Honk.G1Point({
-        x: uint256(0x2771f716f503f8552b69271a62ec8cd7ab492b67f4859d8ff0321ce075e0361e),
-        y: uint256(0x0a7762803ccc6145a73d9df81cb83b8d7125f07f998525b8ec888bb39ff32658)
+        x: uint256(0x074e7ead679c76d2c2d6d3f158cb522e71d14a169b2b1d0792cdfdad726f17a4),
+        y: uint256(0x21f9acd78d4150858f29c259c07e4552f6ec4bffac6c1e174cfb90e2e26bd68a)
       }),
       qDeltaRange: Honk.G1Point({
-        x: uint256(0x0188abc30c433d60b371a87b89bef69474c4de9748b2b4b4e01d3e423cc2e975),
-        y: uint256(0x2bbddad8b0e16ca7d71b0ca54b0f6251ea7c4457d76ba3327982171026423a40)
+        x: uint256(0x0cebfba75751a4eff3d7855bf0f314e523e2c709a75992eb5674a546627248e3),
+        y: uint256(0x16b715150f4de399940c535932174f5c634c9fd9137a94008bb38f89f1350b4c)
       }),
       qElliptic: Honk.G1Point({
-        x: uint256(0x1a2e2850cfbe3912c8f6a4c0099bc93bc50841ce22d665b83b081753ce664a24),
-        y: uint256(0x1976524b69c879a83c4d704ff5cb39397679528681ad378e6753e8b63457c40e)
+        x: uint256(0x174dba7fa4e38a55a78e43dda6c3fb81a1293285cf33eeb333ee186bb4331563),
+        y: uint256(0x0a2ff722359e35596e5abeec834c6cd73f4b06f5f2e837b31364f199f449ca77)
       }),
       qMemory: Honk.G1Point({
-        x: uint256(0x2e569e263fc7a1cfa7b839e1d01a24bb6e07a396cbe93280eaa5f428f9bfcda3),
-        y: uint256(0x232683b772e71e0839c2c22a0325540c142df09d86ad281e95c9a8526c8a8b1d)
+        x: uint256(0x29f116092db8eb3773b017110ca5d3a7b35fa1b064cde91c9e280e20399d7ec2),
+        y: uint256(0x1f0e39e18ded75167a270d6e31b9a6ad9a9d1b0d67c365eeb172a3fea4d1371e)
       }),
       qNnf: Honk.G1Point({
-        x: uint256(0x21cdfcabf16e6fa296718413cc974b48e44c715143907a9c5cc722aa737b74b0),
-        y: uint256(0x2280bd00b21340373b65aa88a619fa5f770435b772e1620701f76d769d041ea4)
+        x: uint256(0x19da50fca27dd36a006892b7cb6b36d7cfdac9d65fec6ae7a1a2e092e0988de5),
+        y: uint256(0x08f96f1d8e37be6dc83c9fbb3b912493841e4e81ab28a60c0fc85337cc4ed977)
       }),
       qPoseidon2External: Honk.G1Point({
-        x: uint256(0x0e5cb0521c16b7e51540251b51adb95e4ce6d507a75c32e0c33377c21853d058),
-        y: uint256(0x2ca91c89d04305640dcd8eefc8d33d78d27efee8fda3ac261150c8d675dff0d3)
+        x: uint256(0x2d20446a333063e66c1a552fecdfe12d0fdddeef0034569ac350f3299b09955a),
+        y: uint256(0x175e6e8776625134217ce9516a11cbbeab8c4c1c8b41cfb75f43de1f500b07d2)
       }),
       qPoseidon2Internal: Honk.G1Point({
-        x: uint256(0x1e7842d12cae260b5fabe275ae67fc449e3a55615f7f83da87b1ea7c9e8f0500),
-        y: uint256(0x1ea86788529c46dc304e64c22662f3c8c4e3e2e347500ccf539780071a293aad)
+        x: uint256(0x090a76cca3c754a2ba40abdc2572fff64645060cfa5c48239a1df4dbb8360828),
+        y: uint256(0x0499d4c6aed1f78b33a6701459cd069e9bf7262754d2f15074a6c2401950761f)
       }),
       s1: Honk.G1Point({
-        x: uint256(0x0e90e964ef25f8c1aec26541f31cc9320b50fd36e39520d025d13e032037727e),
-        y: uint256(0x1089017a718fae9b93f24789f8ef17aeed176bf9d16edb535a63d32648528a92)
+        x: uint256(0x012609fcd0fa67214d78f2d5f5e3e2b459a3c4b21531646de7d51d9cd5383aa9),
+        y: uint256(0x21394cebbe5f66f3aecf43d318b3cb9fc7640825baba0c5a5c190a20ceeb5edb)
       }),
       s2: Honk.G1Point({
-        x: uint256(0x1aacf9506f5763680928c04b60d8217d4db189f8e148fd444a114ea18338fc8c),
-        y: uint256(0x0b260dbc5d61e1b32e055570a5dd0a835b4f9672cd12dad8314aaa58eea62dd4)
+        x: uint256(0x080c7f024d9c813c60c84fc3e9bcad553c51f276d55e8d7a03c044b41cedef36),
+        y: uint256(0x2109db10b2da84ec2c4a1b62689d0952ababe94915293dfee09f1083010e5cfb)
       }),
       s3: Honk.G1Point({
-        x: uint256(0x00357d87f2822ca4102863d9736d121154762e65008fb88d0851b22f7d564c5f),
-        y: uint256(0x261b2a08cf2c8f3df7c5758aa7532df230d3348c1ad7b6ff1cf75dce3e8a03c7)
+        x: uint256(0x2f7d6b77cd5c3ee56c255be61d0e90fd7da5898a7ce4850aaf1060513cb7cd9d),
+        y: uint256(0x2ce5fdacbf91fc3358f4eba637d60f109f70fa929a6a1bc1f9d86e7856b87dcd)
       }),
       s4: Honk.G1Point({
-        x: uint256(0x063add626791aade9be4f0371c6bb601295f7715cd35c540a64881892bb9015f),
-        y: uint256(0x242cfc11084db62679ffc86ae33655c2adf2c60ee9a18c3fda51910194358f18)
+        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(0x1dab2791b5e739b6eda84ec6578132dd1f9295f16540f1a221a615f137c750d0),
-        y: uint256(0x0be694840789fada394fb3182a06d50f0c313775cea2b52e6ec3d09705d4ed13)
+        x: uint256(0x0a10b2e79989b15e3a69bd491cdae007b0bf9c82d9be3d7867b33e2287b91dac),
+        y: uint256(0x257794eaba7a0e7aed16e03d4d8c4cf7d878b029f4ea45c559bbc19b5ec4d1de)
       }),
       id2: Honk.G1Point({
-        x: uint256(0x2922506083c612268913dac1af860cae5d49406ce01679ccfc17f95f1ab2a95f),
-        y: uint256(0x29b3e2aa20c02de724c5142a941fdc7578c80fa8e2984882ffdf2c3a98ab8877)
+        x: uint256(0x25791b725ea7c712316ac4ffe10fdfcf37bd2b8f9d730ba2e26fa709bc7c3ae0),
+        y: uint256(0x15fba3e7928d36dc4dd6d6ff198b928c7246310974d4f74161cfd2781b9d3686)
       }),
       id3: Honk.G1Point({
-        x: uint256(0x021afc0b974f923bb6e3116b7a7d04af835678e17a0e8ef3e9e723ca2c2122e9),
-        y: uint256(0x1a1a18df93aba1975b374fd27695da35bbc0e243edbbcf67ec6e58c3441198fb)
+        x: uint256(0x270be32427e6404801b9b014f983d80acf18b828c6cf049f430d98fbe34e85e0),
+        y: uint256(0x2e7d27a99c4b574557ea6117c390c65072cdfa51a08621141ae26d7e143d0669)
       }),
       id4: Honk.G1Point({
-        x: uint256(0x22c8713ddae54a7bb0751e8e2d97049735a71cf2e840c5a8c4e3d94af4bad28b),
-        y: uint256(0x12b05267a7d72d33761c4742e8b03365cbdb383efd91743447b64d1714259595)
+        x: uint256(0x18e2902febdb3e45358fe65981f338a7ffd1b16edd917de670fabe5d15307e20),
+        y: uint256(0x2f6f36f307a0f7012dc3918795312e71a1d4752966c2bc3151e5f5b3151fc236)
       }),
       lagrangeFirst: Honk.G1Point({
         x: uint256(0x0000000000000000000000000000000000000000000000000000000000000001),
         y: uint256(0x0000000000000000000000000000000000000000000000000000000000000002)
       }),
       lagrangeLast: Honk.G1Point({
-        x: uint256(0x23322d7d1115f6d1ee1e781cf348e56fbdf96c6853625397732a472b0711fa65),
-        y: uint256(0x0359cc7c66a45d683d935dfaac2ada72634fd94dec1136ddf9dda711219be516)
+        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, 0, 0),
+      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,7 +61,7 @@ contract MockEnclave {
         encryptionSchemeId: bytes32(0),
         e3Program: IE3Program(address(0)),
         e3ProgramParams: bytes(""),
-        customParams: bytes(""),
+        customParams: abi.encode(address(0), 0, 2, 0, 0),
         decryptionVerifier: IDecryptionVerifier(address(0)),
         committeePublicKey: committeePublicKey,
         ciphertextOutput: bytes32(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.8",
+  "version": "0.5.10",
   "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/sdk": "^0.5.8",
-    "@crisp-e3/zk-inputs": "^0.5.8"
+    "@crisp-e3/zk-inputs": "^0.5.10",
+    "@crisp-e3/sdk": "^0.5.10"
   },
   "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"