@maci-protocol/circuits 0.0.0-ci.3dedbc5 → 0.0.0-ci.3ff6873

package/circom/utils/{privToPubKey.circom → PrivateToPublicKey.circom}

@@ -9,28 +9,30 @@ include "./escalarmulfix.circom";
  * Converts a private key to a public key on the BabyJubJub curve.
  * The input private key needs to be hashed and then pruned before.
  */
-template PrivToPubKey() {
+template PrivateToPublicKey() {
     // The base point of the BabyJubJub curve.
     var BASE8[2] = [
         5299619240641551281634865583518297030282874472190772894086521144482721001553,
         16950150798460657717958625567821834550301663161624707787222815936182638968203
     ];
 
-    // Prime subgroup order 'l'.
-    var l = 2736030358979909402780800718157159386076813972158567259200215660948447373041;
+    // The prime subgroup order.
+    var SUBGROUP_ORDER = 2736030358979909402780800718157159386076813972158567259200215660948447373041;
 
-    signal input privKey;
-    signal output pubKey[2];
+    // The private key
+    signal input privateKey;
+    // The public key
+    signal output publicKey[2];
 
-    // Check if private key is in the prime subgroup order 'l'
-    var isLessThan = LessThan(251)([privKey, l]);
+    // Check if private key is in the prime subgroup order
+    var isLessThan = LessThan(251)([privateKey, SUBGROUP_ORDER]);
     isLessThan === 1;
 
     // Convert the private key to bits.
-    var computedPrivBits[253] = Num2Bits(253)(privKey);
+    var computedPrivBits[253] = Num2Bits(253)(privateKey);
 
     // Perform scalar multiplication with the basepoint.
     var computedEscalarMulFix[2] = EscalarMulFix(253, BASE8)(computedPrivBits);
 
-    pubKey <== computedEscalarMulFix;
+    publicKey <== computedEscalarMulFix;
 }

package/circom/utils/VerifySignature.circom

@@ -0,0 +1,39 @@
+pragma circom 2.0.0;
+
+// local imports
+include "./EdDSAPoseidonVerifier.circom";
+include "./PoseidonHasher.circom";
+
+/**
+ * Verifies the EdDSA signature for a given command, which has exactly four elements in the hash preimage.
+ */
+template VerifySignature() {
+    // Number of elements in the hash preimage.
+    var PRE_IMAGE_LENGTH = 4;
+
+    // Public key of the signer, consisting of two coordinates [x, y].
+    signal input publicKey[2];
+    // signaturePoint point from the signature, consisting of two coordinates [x, y]. 
+    signal input signaturePoint[2];
+    // Scalar component of the signature.
+    signal input signatureScalar;
+    // The preimage data that was hashed, an array of four elements.
+    signal input preimage[PRE_IMAGE_LENGTH];
+    // The validity of the signature.
+    signal output isValid;
+
+    // Hash the preimage using the Poseidon hashing function configured for four inputs.
+    var computedPreimage = PoseidonHasher(4)(preimage);
+
+    // Instantiate the patched EdDSA Poseidon verifier with the necessary inputs.
+    var computedIsValid = EdDSAPoseidonVerifier()(
+        publicKey[0],
+        publicKey[1],
+        signatureScalar,
+        signaturePoint[0],
+        signaturePoint[1],
+        computedPreimage
+    );
+
+    isValid <== computedIsValid;
+}

package/circom/utils/non-qv/messageValidator.circom

@@ -3,7 +3,7 @@ pragma circom 2.0.0;
 // zk-kit imports
 include "./safe-comparators.circom";
 // local imports
-include "../verifySignature.circom";
+include "../VerifySignature.circom";
 
 /**
  * Checks if a MACI message is valid or not.
@@ -28,7 +28,7 @@ template MessageValidatorNonQv() {
     // Packed command.
     signal input cmd[PACKED_CMD_LENGTH];
     // Public key of the state leaf (user).
-    signal input pubKey[2];
+    signal input publicKey[2];
     // ECDSA signature of the command (R part).
     signal input sigR8[2];
     // ECDSA signature of the command (S part).
@@ -60,7 +60,7 @@ template MessageValidatorNonQv() {
     var computedIsNonceValid = IsEqual()([originalNonce + 1, nonce]);
 
     // Check (4) - The signature must be correct.    
-    var computedIsSignatureValid = VerifySignature()(pubKey, sigR8, sigS, cmd);
+    var computedIsSignatureValid = VerifySignature()(publicKey, sigR8, sigS, cmd);
  
     // Check (5) - There must be sufficient voice credits.
     // The check ensure that currentVoiceCreditBalance + (currentVotesForOption) >= (voteWeight).

package/circom/utils/non-qv/stateLeafAndBallotTransformer.circom

@@ -85,8 +85,8 @@ template StateLeafAndBallotTransformerNonQv() {
     );
 
     // If the message is valid then we swap out the public key.
-    // This means using a Mux1() for pubKey[0] and another one
-    // for pubKey[1].
+    // This means using a Mux1() for publicKey[0] and another one
+    // for publicKey[1].
     var computedNewSlPubKey0Mux = Mux1()([slPubKey[0], cmdNewPubKey[0]], computedMessageValidator);
     var computedNewSlPubKey1Mux = Mux1()([slPubKey[1], cmdNewPubKey[1]], computedMessageValidator);
 

package/circom/utils/qv/messageValidator.circom

@@ -3,7 +3,7 @@ pragma circom 2.0.0;
 // zk-kit imports
 include "./safe-comparators.circom";
 // local imports
-include "../verifySignature.circom";
+include "../VerifySignature.circom";
 
 /**
  * Checks if a MACI message is valid or not.
@@ -28,7 +28,7 @@ template MessageValidator() {
     // Packed command.
     signal input cmd[PACKED_CMD_LENGTH];
     // Public key of the state leaf (user).
-    signal input pubKey[2];
+    signal input publicKey[2];
     // ECDSA signature of the command (R part).
     signal input sigR8[2];
     // ECDSA signature of the command (S part).
@@ -60,7 +60,7 @@ template MessageValidator() {
     var computedIsNonceValid = IsEqual()([originalNonce + 1, nonce]);
 
     // Check (4) - The signature must be correct.    
-    var computedIsSignatureValid = VerifySignature()(pubKey, sigR8, sigS, cmd);
+    var computedIsSignatureValid = VerifySignature()(publicKey, sigR8, sigS, cmd);
 
     // Check (5) - There must be sufficient voice credits.
     // The check ensure that the voteWeight is < sqrt(field size)

package/circom/utils/qv/stateLeafAndBallotTransformer.circom

@@ -85,8 +85,8 @@ template StateLeafAndBallotTransformer() {
     );
 
     // If the message is valid then we swap out the public key.
-    // This means using a Mux1() for pubKey[0] and another one
-    // for pubKey[1].
+    // This means using a Mux1() for publicKey[0] and another one
+    // for publicKey[1].
     var computedNewSlPubKey0Mux = Mux1()([slPubKey[0], cmdNewPubKey[0]], computedMessageValidator);
     var computedNewSlPubKey1Mux = Mux1()([slPubKey[1], cmdNewPubKey[1]], computedMessageValidator);
 

package/circom/utils/trees/BinaryMerkleRoot.circom

@@ -0,0 +1,62 @@
+pragma circom 2.0.0;
+
+// circomlib import
+include "./mux1.circom";
+include "./comparators.circom";
+// local import
+include "../PoseidonHasher.circom";
+
+// @note taken from @zk-kit/circuits
+// if used directly in processMessages circom complains about duplicated
+// templates (Ark, Poseidon, etc.)
+// This circuit is designed to calculate the root of a binary Merkle
+// tree given a leaf, its depth, and the necessary sibling
+// information (aka proof of membership).
+// A circuit is designed without the capability to iterate through
+// a dynamic array. To address this, a parameter with the static maximum
+// tree depth is defined (i.e. 'MAX_DEPTH'). And additionally, the circuit
+// receives a dynamic depth as an input, which is utilized in calculating the
+// true root of the Merkle tree. The actual depth of the Merkle tree
+// may be equal to or less than the static maximum depth.
+// NOTE: This circuit will successfully verify `out = 0` for `depth > MAX_DEPTH`.
+// Make sure to enforce `depth <= MAX_DEPTH` outside the circuit.
+template BinaryMerkleRoot(MAX_DEPTH) {
+    // The leaf node of the Merkle tree.
+    signal input leaf;
+    // The depth of the Merkle tree.
+    signal input depth;
+    // The indices of the leaf node in the Merkle tree.
+    signal input indices[MAX_DEPTH];
+    // The sibling nodes of the leaf node in the Merkle tree.
+    signal input siblings[MAX_DEPTH][1];
+
+    // The output of the Merkle tree root.
+    signal output out;
+
+    signal nodes[MAX_DEPTH + 1];
+    nodes[0] <== leaf;
+
+    signal roots[MAX_DEPTH];
+    var root = 0;
+
+    for (var i = 0; i < MAX_DEPTH; i++) {
+        var isDepth = IsEqual()([depth, i]);
+
+        roots[i] <== isDepth * nodes[i];
+
+        root += roots[i];
+
+        var c[2][2] = [
+            [nodes[i], siblings[i][0]],
+            [siblings[i][0], nodes[i]]
+        ];
+        
+        var childNodes[2] = MultiMux1(2)(c, indices[i]);
+
+        nodes[i + 1] <== PoseidonHasher(2)(childNodes);
+    }
+
+    var isDepth = IsEqual()([depth, MAX_DEPTH]);
+
+    out <== root + isDepth * nodes[MAX_DEPTH];
+} 

package/circom/utils/trees/CheckRoot.circom

@@ -0,0 +1,49 @@
+pragma circom 2.0.0;
+
+// local import
+include "../PoseidonHasher.circom";
+
+/**
+ * Verifies the correct construction of a Merkle tree from a set of leaves.
+ * Given a Merkle root and a list of leaves, check if the root is the
+ * correct result of inserting all the leaves into the tree (in the given order).
+ */
+template CheckRoot(levels) {
+    // The total number of leaves in the Merkle tree, calculated as 2 to the power of `levels`.
+    var TOTAL_LEVELS = 2 ** levels;
+    // The number of first-level hashers needed, equal to half the total leaves, as each hasher combines two leaves.
+    var LEAF_HASHERS = TOTAL_LEVELS / 2;
+    // The number of intermediate hashers, one less than the number of leaf hashers, 
+    // as each level of hashing reduces the number of hash elements by about half.
+    var INTERMEDIATE_HASHERS = LEAF_HASHERS - 1;
+    
+    // Array of leaf values input to the circuit.
+    signal input leaves[TOTAL_LEVELS];
+
+    // Output signal for the Merkle root that results from hashing all the input leaves.
+    signal output root;
+
+    // Total number of hashers used in constructing the tree, one less than the total number of leaves,
+    // since each level of the tree combines two elements into one.
+    var hashersLength = TOTAL_LEVELS - 1;
+    var computedLevelHashers[hashersLength];
+
+    // Initialize hashers for the leaves, each taking two adjacent leaves as inputs.
+    for (var i = 0; i < LEAF_HASHERS; i++){
+        computedLevelHashers[i] = PoseidonHasher(2)([leaves[i * 2], leaves[i * 2 + 1]]);
+    }
+
+    // Initialize hashers for intermediate levels, each taking the outputs of two hashers from the previous level.
+    var index = 0;
+
+    for (var i = LEAF_HASHERS; i < LEAF_HASHERS + INTERMEDIATE_HASHERS; i++) {
+        computedLevelHashers[i] = PoseidonHasher(2)([
+            computedLevelHashers[index * 2],
+            computedLevelHashers[index * 2 + 1]
+        ]);
+        index++;
+    }
+
+    // Connect the output of the final hasher in the array to the root output signal.
+    root <== computedLevelHashers[hashersLength - 1];
+} 

package/circom/utils/trees/LeafExists.circom

@@ -0,0 +1,27 @@
+pragma circom 2.0.0;
+
+// local import
+include "./MerkleTreeInclusionProof.circom";
+
+/**
+ * Ensures that a leaf exists within a Merkle tree with a given root.
+ */
+template LeafExists(levels) {
+  // The leaf whose existence within the tree is being verified.
+  signal input leaf;
+
+  // The elements along the path needed for the inclusion proof.
+  signal input path_elements[levels][1];
+  // The indices indicating the path taken through the tree for the leaf.
+  signal input path_index[levels];
+  // The root of the Merkle tree, against which the inclusion is verified.
+  signal input root;
+
+  var computedMerkleRoot = MerkleTreeInclusionProof(levels)(
+    leaf,
+    path_index,
+    path_elements
+  );
+
+  root === computedMerkleRoot;
+}

package/circom/utils/trees/MerkleGeneratePathIndices.circom

@@ -0,0 +1,44 @@
+pragma circom 2.0.0;
+
+// zk-kit imports
+include "./safe-comparators.circom";
+// local import
+include "../CalculateTotal.circom";
+
+/**
+ * Calculates the path indices required for Merkle proof verifications. 
+ * Given a node index within an IMT and the total tree levels, it outputs the path indices leading to that node.
+ * The template handles the modulo and division operations to break down the tree index into its constituent path indices.
+ */
+template MerkleGeneratePathIndices(levels) {
+    // The base used for the modulo and division operations, set to 2 for binary trees.
+    var BASE = 2;
+
+    // The total sum of the path indices.
+    signal input indices;
+
+    // The generated path indices.
+    signal output out[levels];
+
+    var computedIndices = indices;
+    var computedResults[levels];
+
+    for (var i = 0; i < levels; i++) {
+        // circom's best practices suggests to avoid using <-- unless you
+        // are aware of what's going on. This is the only way to do modulo operation.
+        out[i] <-- computedIndices % BASE;
+        computedIndices = computedIndices \ BASE;
+
+        // Check that each output element is less than the base.
+        var computedIsOutputElementLessThanBase = SafeLessThan(3)([out[i], BASE]);
+        computedIsOutputElementLessThanBase === 1;
+
+        // Re-compute the total sum.
+        computedResults[i] = out[i] * (BASE ** i);
+    }
+    
+    // Check that the total sum matches the index.
+    var computedCalculateTotal = CalculateTotal(levels)(computedResults);
+
+    computedCalculateTotal === indices;
+} 

package/circom/utils/trees/MerkleTreeInclusionProof.circom

@@ -0,0 +1,50 @@
+pragma circom 2.0.0;
+
+// circomlib import
+include "./mux1.circom";
+// local import
+include "../PoseidonHasher.circom";
+
+/**
+ * Recomputes a Merkle root from a given leaf and its path in a Merkle tree.
+ */
+template MerkleTreeInclusionProof(n_levels) {
+    // The leaf node from which the Merkle root is calculated.
+    signal input leaf;
+    // Indices indicating left or right child for each level of the tree.
+    signal input path_index[n_levels];
+    // Sibling node values required to compute the hash at each level.
+    signal input path_elements[n_levels][1];
+
+    // The merkle root.
+    signal output root;
+
+     // Stores the hash at each level starting from the leaf to the root.
+    signal levelHashes[n_levels + 1];
+    // Initialize the first level with the given leaf.
+    levelHashes[0] <== leaf;
+
+    for (var i = 0; i < n_levels; i++) {
+        // Validate path_index to be either 0 or 1, ensuring no other values.
+        path_index[i] * (1 - path_index[i]) === 0;
+
+        // Configure the multiplexer based on the path index for the current level.
+        var multiplexer[2][2] = [
+            [levelHashes[i], path_elements[i][0]],
+            [path_elements[i][0], levelHashes[i]]
+        ];
+
+        var multiplexerResult[2] = MultiMux1(2)(
+            multiplexer,
+            path_index[i]
+        );
+
+        var computedLevelHash = PoseidonHasher(2)([multiplexerResult[0], multiplexerResult[1]]);
+
+        // Store the resulting hash as the next level's hash.
+        levelHashes[i + 1] <== computedLevelHash;
+    }
+
+    // Set the final level hash as the root.
+    root <== levelHashes[n_levels];
+} 

package/circom/utils/trees/incrementalQuinaryTree.circom

@@ -6,8 +6,8 @@ include "./mux1.circom";
 // zk-kit import
 include "./safe-comparators.circom";
 // local imports
-include "../calculateTotal.circom";
-include "../hashers.circom";
+include "../CalculateTotal.circom";
+include "../PoseidonHasher.circom";
 
 // Incremental Quintary Merkle Tree (IQT) verification circuits.
 // Since each node contains 5 leaves, we are using PoseidonT6 for hashing them.

package/circom/voter/PollJoined.circom

@@ -0,0 +1,43 @@
+pragma circom 2.0.0;
+
+// local imports
+include "../utils/PoseidonHasher.circom";
+include "../utils/PrivateToPublicKey.circom";
+include "../utils/trees/BinaryMerkleRoot.circom";
+
+// Poll Joined Circuit
+// Allows a user to prove that they have joined a MACI poll.
+// This is to be used with the MACI offchain implementation to allow 
+// users to authenticate to the relayer service (to reduce spamming).
+template PollJoined(stateTreeDepth) {
+    // Constants defining the tree structure
+    var STATE_TREE_ARITY = 2;
+
+    // User's private key
+    signal input privateKey;
+    // User's voice credits balance
+    signal input voiceCreditsBalance;
+    // Path elements
+    signal input pathElements[stateTreeDepth][STATE_TREE_ARITY - 1];
+    // Path indices
+    signal input pathIndices[stateTreeDepth];
+    // Poll State tree root which proves the user is joined
+    signal input stateRoot;
+    // The actual tree depth (might be <= stateTreeDepth) Used in BinaryMerkleRoot
+    signal input actualStateTreeDepth;
+
+     // User private to public key
+    var derivedPublicKey[2] = PrivateToPublicKey()(privateKey);
+
+    var stateLeaf = PoseidonHasher(3)([derivedPublicKey[0], derivedPublicKey[1], voiceCreditsBalance]);
+
+    // Inclusion proof  
+    var stateLeafQip = BinaryMerkleRoot(stateTreeDepth)(
+        stateLeaf,
+        actualStateTreeDepth,
+        pathIndices,
+        pathElements
+    );
+
+    stateLeafQip === stateRoot;
+}

package/circom/voter/PollJoining.circom

@@ -0,0 +1,54 @@
+pragma circom 2.0.0;
+
+// local imports
+include "../utils/PoseidonHasher.circom";
+include "../utils/PrivateToPublicKey.circom";
+include "../utils/trees/BinaryMerkleRoot.circom";
+
+// Poll Joining Circuit
+// Allows a user to prove knowledge of a private key that is signed up to 
+// a MACI contract.
+template PollJoining(stateTreeDepth) {
+    // Constants defining the tree structure
+    var STATE_TREE_ARITY = 2;
+
+    // User's private key
+    signal input privateKey;
+    // Poll's public key
+    signal input pollPublicKey[2];
+    // Siblings
+    signal input siblings[stateTreeDepth][STATE_TREE_ARITY - 1];
+    // Indices
+    signal input indices[stateTreeDepth];
+    // User's hashed private key
+    signal input nullifier;
+    // MACI State tree root which proves the user is signed up
+    signal input stateRoot;
+    // The actual tree depth (might be <= stateTreeDepth) used in BinaryMerkleRoot
+    signal input actualStateTreeDepth;
+    // The poll id
+    signal input pollId;
+
+    // Compute the nullifier (hash of private key and poll id)
+    var computedNullifier = PoseidonHasher(2)([privateKey, pollId]);
+    nullifier === computedNullifier;
+
+    // User private to public key
+    var derivedPublicKey[2] = PrivateToPublicKey()(privateKey);
+    // Hash the public key
+    var publicKeyHash = PoseidonHasher(2)([derivedPublicKey[0], derivedPublicKey[1]]);
+
+    // Ensure the poll public key is the same as the maci one (public input)
+    derivedPublicKey[0] === pollPublicKey[0];
+    derivedPublicKey[1] === pollPublicKey[1];
+
+    // Inclusion proof  
+    var calculatedRoot = BinaryMerkleRoot(stateTreeDepth)(
+        publicKeyHash,
+        actualStateTreeDepth,
+        indices,
+        siblings
+    );
+
+    calculatedRoot === stateRoot;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maci-protocol/circuits",
-  "version": "0.0.0-ci.3dedbc5",
+  "version": "0.0.0-ci.3ff6873",
   "private": false,
   "description": "zk-SNARK circuits for MACI",
   "main": "build/ts/index.js",
@@ -28,12 +28,13 @@
     "mocha-test": "NODE_OPTIONS=--max-old-space-size=4096 ts-mocha --exit -g '^(?!.*\\[fuzz\\]).*$'",
     "test": "pnpm run mocha-test ts/__tests__/*.test.ts",
     "test:fuzz": "NODE_OPTIONS=--max-old-space-size=4096 ts-mocha --exit -g '\\[fuzz\\]' ./ts/__tests__/*.test.ts",
-    "test:hasher": "pnpm run mocha-test ts/__tests__/Hasher.test.ts",
+    "test:poseidonHasher": "pnpm run mocha-test ts/__tests__/PoseidonHasher.test.ts",
+    "test:messageHasher": "pnpm run mocha-test ts/__tests__/MessageHasher.test.ts",
     "test:slAndBallotTransformer": "pnpm run mocha-test ts/__tests__/StateLeafAndBallotTransformer.test.ts",
     "test:messageToCommand": "pnpm run mocha-test ts/__tests__/MessageToCommand.test.ts",
     "test:messageValidator": "pnpm run mocha-test ts/__tests__/MessageValidator.test.ts",
     "test:verifySignature": "pnpm run mocha-test ts/__tests__/VerifySignature.test.ts",
-    "test:privToPubKey": "pnpm run mocha-test ts/__tests__/PrivToPubKey.test.ts",
+    "test:privateToPublicKey": "pnpm run mocha-test ts/__tests__/PrivateToPublicKey.test.ts",
     "test:calculateTotal": "pnpm run mocha-test ts/__tests__/CalculateTotal.test.ts",
     "test:processMessages": "pnpm run mocha-test ts/__tests__/ProcessMessages.test.ts",
     "test:tallyVotes": "pnpm run mocha-test ts/__tests__/TallyVotes.test.ts",
@@ -43,10 +44,10 @@
     "test:pollJoined": "pnpm run mocha-test ts/__tests__/PollJoined.test.ts"
   },
   "dependencies": {
-    "@maci-protocol/core": "0.0.0-ci.3dedbc5",
-    "@maci-protocol/crypto": "0.0.0-ci.3dedbc5",
-    "@maci-protocol/domainobjs": "0.0.0-ci.3dedbc5",
-    "@maci-protocol/sdk": "0.0.0-ci.3dedbc5",
+    "@maci-protocol/core": "0.0.0-ci.3ff6873",
+    "@maci-protocol/crypto": "0.0.0-ci.3ff6873",
+    "@maci-protocol/domainobjs": "0.0.0-ci.3ff6873",
+    "@maci-protocol/sdk": "0.0.0-ci.3ff6873",
     "@zk-kit/circuits": "^0.4.0",
     "circomkit": "^0.3.2",
     "circomlib": "^2.0.5"
@@ -60,12 +61,12 @@
     "@zk-kit/baby-jubjub": "^1.0.3",
     "chai": "^4.3.10",
     "chai-as-promised": "^7.1.2",
-    "fast-check": "^4.0.0",
+    "fast-check": "^4.1.1",
     "glob": "^11.0.1",
     "mocha": "^11.1.0",
     "ts-mocha": "^11.1.0",
     "ts-node": "^10.9.1",
-    "typescript": "^5.8.2"
+    "typescript": "^5.8.3"
   },
-  "gitHead": "ef701a2ae278f54e95f8112974b77fd6742429f8"
+  "gitHead": "23a575cd7bd2acb5136aee338b252239be603c1c"
 }

package/circom/utils/hashers.circom

@@ -1,78 +0,0 @@
-pragma circom 2.0.0;
-
-// zk-kit imports
-include "./poseidon-cipher.circom";
-
-/**
- * Computes the Poseidon hash for an array of n inputs, including a default initial state 
- * of zero not counted in n. First, extends the inputs by prepending a zero, creating an array [0, inputs]. 
- * Then, the Poseidon hash of the extended inputs is calculated, with the first element of the 
- * result assigned as the output. 
- */
-template PoseidonHasher(n) {
-    signal input inputs[n];
-    signal output out;
-
-    // [0, inputs].
-    var computedExtendedInputs[n + 1];
-    computedExtendedInputs[0] = 0;
-
-    for (var i = 0; i < n; i++) {
-        computedExtendedInputs[i + 1] = inputs[i];
-    }
-
-    // Compute the Poseidon hash of the extended inputs.
-    var computedPoseidonPerm[n + 1]; 
-    computedPoseidonPerm = PoseidonPerm(n + 1)(computedExtendedInputs);
-
-    out <== computedPoseidonPerm[0];
-}
-
-/**
- * Hashes a MACI message and the public key used for message encryption. 
- * This template processes 10 message inputs and a 2-element public key
- * combining them using the Poseidon hash function. The hashing process involves two stages: 
- * 1. hashing message parts in groups of five and,
- * 2. hashing the grouped results alongside the first message input and 
- * the encryption public key to produce a final hash output. 
- */
-template MessageHasher() {
-    // The MACI message is composed of 10 parts.
-    signal input in[10];
-    // the public key used to encrypt the message.
-    signal input encPubKey[2];
-    // we output an hash.
-    signal output hash;
-
-    // Hasher4(
-    //     Hasher5_1(in[1], in[2], in[3], in[4], in[5]),
-    //     Hasher5_2(in[6], in[7], in[8], in[9], in[10])
-    //     in[11],
-    //     in[12]
-    // )
-
-    var computedHasher5_1;
-    computedHasher5_1 = PoseidonHasher(5)([
-        in[0],
-        in[1],
-        in[2],
-        in[3],
-        in[4]
-    ]);
-
-    var computedHasher5_2;
-    computedHasher5_2 = PoseidonHasher(5)([
-        in[5],        
-        in[6],
-        in[7],
-        in[8],
-        in[9]
-    ]);
-
-    hash <== PoseidonHasher(4)([
-        computedHasher5_1,
-        computedHasher5_2,
-        encPubKey[0],
-        encPubKey[1]        
-    ]);
-}