@maci-protocol/circuits 0.0.0-ci.85bba2d → 0.0.0-ci.86ec64f

package/circom/utils/qv/ResultCommitmentVerifier.circom

@@ -0,0 +1,107 @@
+pragma circom 2.0.0;
+
+// circomlib import
+include "./comparators.circom";
+// local imports
+include "../trees/QuinaryCheckRoot.circom";
+include "../PoseidonHasher.circom";
+
+/** 
+ * Performs verifications and computations related to current voting results. 
+ * Also, computes and outputs a commitment to the new results.
+ * This template supports the Quadratic Voting (QV).
+ */
+template ResultCommitmentVerifierQv(voteOptionTreeDepth) {
+    // Number of children per node in the tree, defining the tree's branching factor.
+    var TREE_ARITY = 5;
+    // Number of voting options available, determined by the depth of the vote option tree.
+    var totalVoteOptions = TREE_ARITY ** voteOptionTreeDepth;
+
+    // Equal to 1 if this is the first batch, otherwise 0.
+    signal input isFirstBatch;
+    // Commitment to the current tally before this batch.
+    signal input currentTallyCommitment;
+    // Commitment to the new tally after processing this batch.
+    signal input newTallyCommitment;
+
+    // Current results for each vote option.
+    signal input currentResults[totalVoteOptions];
+    // Salt for the root of the current results.
+    signal input currentResultsRootSalt;
+
+    // New results for each vote option.
+    signal input newResults[totalVoteOptions];
+    // Salt for the root of the new results.
+    signal input newResultsRootSalt;
+
+    // Total voice credits spent so far.
+    signal input currentSpentVoiceCreditSubtotal;
+    // Salt for the total spent voice credits.
+    signal input currentSpentVoiceCreditSubtotalSalt;
+
+    // Total new voice credits spent.
+    signal input newSpentVoiceCreditSubtotal;
+    // Salt for the new total spent voice credits.
+    signal input newSpentVoiceCreditSubtotalSalt;
+
+    // Spent voice credits per vote option.
+    signal input currentPerVoteOptionSpentVoiceCredits[totalVoteOptions];
+    // Salt for the root of spent credits per option.
+    signal input currentPerVoteOptionSpentVoiceCreditsRootSalt;
+
+    // New spent voice credits per vote option.
+    signal input newPerVoteOptionSpentVoiceCredits[totalVoteOptions];
+    // Salt for the root of new spent credits per option.
+    signal input newPerVoteOptionSpentVoiceCreditsRootSalt;
+
+    // Compute the commitment to the current results.
+    var computedCurrentResultsRoot = QuinaryCheckRoot(voteOptionTreeDepth)(currentResults);
+
+    // Verify currentResultsCommitmentHash.
+    var computedCurrentResultsCommitment = PoseidonHasher(2)([computedCurrentResultsRoot, currentResultsRootSalt]);
+
+    // Compute the commitment to the current spent voice credits.
+    var computedCurrentSpentVoiceCreditsCommitment = PoseidonHasher(2)([currentSpentVoiceCreditSubtotal, currentSpentVoiceCreditSubtotalSalt]);
+
+    // Compute the root of the spent voice credits per vote option.
+    var computedCurrentPerVoteOptionSpentVoiceCreditsRoot = QuinaryCheckRoot(voteOptionTreeDepth)(currentPerVoteOptionSpentVoiceCredits);
+    var computedCurrentPerVoteOptionSpentVoiceCreditsCommitment = PoseidonHasher(2)([computedCurrentPerVoteOptionSpentVoiceCreditsRoot, currentPerVoteOptionSpentVoiceCreditsRootSalt]);
+
+    // Commit to the current tally.
+    var computedCurrentTallyCommitment = PoseidonHasher(3)([
+        computedCurrentResultsCommitment, 
+        computedCurrentSpentVoiceCreditsCommitment, 
+        computedCurrentPerVoteOptionSpentVoiceCreditsCommitment
+    ]);
+
+    // Check if the current tally commitment is correct only if this is not the first batch.
+    // computedIsZero.out is 1 if this is not the first batch.
+    // computedIsZero.out is 0 if this is the first batch.
+    var computedIsZero = IsZero()(isFirstBatch);
+
+    // isFirstCommitment is 0 if this is the first batch, currentTallyCommitment should be 0 if this is the first batch.
+    // isFirstCommitment is 1 if this is not the first batch, currentTallyCommitment should not be 0 if this is the first batch.
+    signal isFirstCommitment;
+    isFirstCommitment <== computedIsZero * computedCurrentTallyCommitment;
+    isFirstCommitment === currentTallyCommitment;
+
+    // Compute the root of the new results.
+    var computedNewResultsRoot = QuinaryCheckRoot(voteOptionTreeDepth)(newResults);
+    var computedNewResultsCommitment = PoseidonHasher(2)([computedNewResultsRoot, newResultsRootSalt]);
+
+    // Compute the commitment to the new spent voice credits value.
+    var computedNewSpentVoiceCreditsCommitment = PoseidonHasher(2)([newSpentVoiceCreditSubtotal, newSpentVoiceCreditSubtotalSalt]);
+
+    // Compute the root of the spent voice credits per vote option.
+    var computedNewPerVoteOptionSpentVoiceCreditsRoot = QuinaryCheckRoot(voteOptionTreeDepth)(newPerVoteOptionSpentVoiceCredits);
+    var computedNewPerVoteOptionSpentVoiceCreditsCommitment = PoseidonHasher(2)([computedNewPerVoteOptionSpentVoiceCreditsRoot, newPerVoteOptionSpentVoiceCreditsRootSalt]);
+
+    // Commit to the new tally.
+    var computedNewTallyCommitment = PoseidonHasher(3)([
+        computedNewResultsCommitment,
+        computedNewSpentVoiceCreditsCommitment,
+        computedNewPerVoteOptionSpentVoiceCreditsCommitment
+    ]);
+    
+    computedNewTallyCommitment === newTallyCommitment;
+}

package/circom/utils/qv/StateLeafAndBallotTransformer.circom

@@ -47,9 +47,9 @@ template StateLeafAndBallotTransformer() {
     signal input commandPollId;
     // Salt.
     signal input commandSalt;
-    // ECDSA signature of the command (R part).
+    // EdDSA signature of the command (R part).
     signal input commandSignaturePoint[2];
-    // ECDSA signature of the command (S part).
+    // EdDSA signature of the command (S part).
     signal input commandSignatureScalar;
     // Packed command. 
     // nb. we are assuming that the packedCommand is always valid.
@@ -68,7 +68,7 @@ template StateLeafAndBallotTransformer() {
     signal output isVoteOptionIndexValid;
 
     // Check if the command / message is valid.
-    var (computedMessageValidator, computedIsStateLeafIndexValid, computedIsVoteOptionIndexValid) = MessageValidator()(
+    var (computedIsValid, computedIsStateLeafIndexValid, computedIsVoteOptionIndexValid) = MessageValidator()(
         commandStateIndex,
         totalSignups,
         commandVoteOptionIndex,
@@ -87,19 +87,19 @@ template StateLeafAndBallotTransformer() {
     // If the message is valid then we swap out the public key.
     // This means using a Mux1() for publicKey[0] and another one
     // for publicKey[1].
-    var computedNewstateLeafPublicKey0Mux = Mux1()([stateLeafPublicKey[0], commandPublicKey[0]], computedMessageValidator);
-    var computedNewstateLeafPublicKey1Mux = Mux1()([stateLeafPublicKey[1], commandPublicKey[1]], computedMessageValidator);
+    var computedNewstateLeafPublicKey0Mux = Mux1()([stateLeafPublicKey[0], commandPublicKey[0]], computedIsValid);
+    var computedNewstateLeafPublicKey1Mux = Mux1()([stateLeafPublicKey[1], commandPublicKey[1]], computedIsValid);
 
     newStateLeafPublicKey[0] <== computedNewstateLeafPublicKey0Mux;
     newStateLeafPublicKey[1] <== computedNewstateLeafPublicKey1Mux;
 
     // If the message is valid, then we swap out the ballot nonce
     // using a Mux1().
-    var computedNewBallotNonceMux = Mux1()([ballotNonce, commandNonce], computedMessageValidator);
+    var computedNewBallotNonceMux = Mux1()([ballotNonce, commandNonce], computedIsValid);
 
     newBallotNonce <== computedNewBallotNonceMux;
 
-    isValid <== computedMessageValidator;
+    isValid <== computedIsValid;
     isStateLeafIndexValid <== computedIsStateLeafIndexValid;
     isVoteOptionIndexValid <== computedIsVoteOptionIndexValid;
 }

package/circom/utils/trees/BinaryMerkleRoot.circom

@@ -7,7 +7,7 @@ include "./comparators.circom";
 include "../PoseidonHasher.circom";
 
 // @note taken from @zk-kit/circuits
-// if used directly in processMessages circom complains about duplicated
+// if used directly in MessageProcessor 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
@@ -25,14 +25,17 @@ template BinaryMerkleRoot(MAX_DEPTH) {
     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 index of the leaf node in the Merkle tree.
+    signal input index;
     // 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;
 
+    // The indices of the leaf node in the Merkle tree.
+    signal indices[MAX_DEPTH] <== Num2Bits(MAX_DEPTH)(index);
+
     signal nodes[MAX_DEPTH + 1];
     nodes[0] <== leaf;
 

package/circom/utils/trees/LeafExists.circom

@@ -13,13 +13,13 @@ template LeafExists(levels) {
   // 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];
+  signal input path_indices[levels];
   // The root of the Merkle tree, against which the inclusion is verified.
   signal input root;
 
   var computedMerkleRoot = MerkleTreeInclusionProof(levels)(
     leaf,
-    path_index,
+    path_indices,
     path_elements
   );
 

package/circom/utils/trees/MerkleTreeInclusionProof.circom

@@ -12,7 +12,7 @@ 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];
+    signal input path_indices[n_levels];
     // Sibling node values required to compute the hash at each level.
     signal input path_elements[n_levels][1];
 
@@ -25,8 +25,8 @@ template MerkleTreeInclusionProof(n_levels) {
     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;
+        // Validate path_indices to be either 0 or 1, ensuring no other values.
+        path_indices[i] * (1 - path_indices[i]) === 0;
 
         // Configure the multiplexer based on the path index for the current level.
         var multiplexer[2][2] = [
@@ -36,7 +36,7 @@ template MerkleTreeInclusionProof(n_levels) {
 
         var multiplexerResult[2] = MultiMux1(2)(
             multiplexer,
-            path_index[i]
+            path_indices[i]
         );
 
         var computedLevelHash = PoseidonHasher(2)([multiplexerResult[0], multiplexerResult[1]]);

package/circom/utils/trees/QuinaryCheckRoot.circom

@@ -0,0 +1,54 @@
+pragma circom 2.0.0;
+
+// local imports
+include "../PoseidonHasher.circom";
+
+/**
+ * Computes the root of a quintary Merkle tree given a list of leaves.
+ * This template constructs a Merkle tree with each node having 5 children (quintary)
+ * and computes the root by hashing with Poseidon the leaves and intermediate nodes in the given order.
+ * The computation is performed by first hashing groups of 5 leaves to form the bottom layer of nodes,
+ * then recursively hashing groups of these nodes to form the next layer, and so on, until the root is computed.
+ */
+template QuinaryCheckRoot(levels) {
+    var LEAVES_PER_NODE = 5;
+    var totalLeaves = LEAVES_PER_NODE ** levels;
+    var numLeafHashers = LEAVES_PER_NODE ** (levels - 1); 
+
+    signal input leaves[totalLeaves];
+    signal output root;
+
+    // Determine the total number of hashers.
+    var numHashers = 0;
+    for (var i = 0; i < levels; i++) {
+        numHashers += LEAVES_PER_NODE ** i;
+    }
+
+    var computedHashers[numHashers]; 
+
+    // Initialize hashers for the leaves.
+    for (var i = 0; i < numLeafHashers; i++) {
+        computedHashers[i] = PoseidonHasher(5)([
+            leaves[i * LEAVES_PER_NODE + 0],
+            leaves[i * LEAVES_PER_NODE + 1],
+            leaves[i * LEAVES_PER_NODE + 2],
+            leaves[i * LEAVES_PER_NODE + 3],
+            leaves[i * LEAVES_PER_NODE + 4]
+        ]);
+    }
+
+    // Initialize hashers for intermediate nodes and compute the root.
+    var k = 0;
+    for (var i = numLeafHashers; i < numHashers; i++) {
+        computedHashers[i] = PoseidonHasher(5)([
+            computedHashers[k * LEAVES_PER_NODE + 0],
+            computedHashers[k * LEAVES_PER_NODE + 1],
+            computedHashers[k * LEAVES_PER_NODE + 2],
+            computedHashers[k * LEAVES_PER_NODE + 3],
+            computedHashers[k * LEAVES_PER_NODE + 4]
+        ]);
+        k++;
+    }
+
+    root <== computedHashers[numHashers - 1]; 
+}

package/circom/utils/trees/{MerklePathIndicesGenerator.circom → QuinaryGeneratePathIndices.circom}

@@ -1,44 +1,44 @@
 pragma circom 2.0.0;
 
-// zk-kit imports
+// zk-kit import
 include "./safe-comparators.circom";
-// local import
+// local imports
 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.
+ * Calculates the path indices required for Merkle proof verifications (e.g., QuinaryTreeInclusionProof, QuinaryLeafExists). 
+ * Given a node index within an IQT 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.
+ * e.g., if the index is 30 and the number of levels is 4, the output should be [0, 1, 1, 0].
  */
-template MerklePathIndicesGenerator(levels) {
-    // The base used for the modulo and division operations, set to 2 for binary trees.
-    var BASE = 2;
+template QuinaryGeneratePathIndices(levels) {
+    // The number of leaves per node (tree arity)
+    var LEAVES_PER_NODE = 5;
 
-    // The total sum of the path indices.
-    signal input indices;
-
-    // The generated path indices.
+    // The index within the tree
+    signal input index;
+    // The generated path indices leading to the node of the provided index
     signal output out[levels];
 
-    var computedIndices = indices;
+    var indexModulus = index;
     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;
+        out[i] <-- indexModulus % LEAVES_PER_NODE;
+        indexModulus = indexModulus \ LEAVES_PER_NODE;
 
         // Check that each output element is less than the base.
-        var computedIsOutputElementLessThanBase = SafeLessThan(3)([out[i], BASE]);
+        var computedIsOutputElementLessThanBase = SafeLessThan(3)([out[i], LEAVES_PER_NODE]);
         computedIsOutputElementLessThanBase === 1;
 
         // Re-compute the total sum.
-        computedResults[i] = out[i] * (BASE ** i);
+        computedResults[i] = out[i] * (LEAVES_PER_NODE ** i);
     }
     
     // Check that the total sum matches the index.
     var computedCalculateTotal = CalculateTotal(levels)(computedResults);
 
-    computedCalculateTotal === indices;
-} 
+    computedCalculateTotal === index;
+}

package/circom/utils/trees/QuinaryLeafExists.circom

@@ -0,0 +1,30 @@
+pragma circom 2.0.0;
+
+// local imports
+include "./QuinaryTreeInclusionProof.circom";
+
+/**
+ * Verifies if a given leaf exists within an IQT.
+ * Takes a leaf, its path to the root (specified by indices and path elements),
+ * and the root itself, to verify the leaf's inclusion within the tree.
+ */
+template QuinaryLeafExists(levels){
+    // The number of leaves per node (tree arity)
+    var LEAVES_PER_NODE = 5;
+    // Number of leaves per path level (excluding the leaf itself)
+    var LEAVES_PER_PATH_LEVEL = LEAVES_PER_NODE - 1;
+
+    // The leaf to check for inclusion
+    signal input leaf;
+    // The path indices at each level of the tree
+    signal input path_indices[levels];
+    // The sibling nodes at each level of the tree
+    signal input path_elements[levels][LEAVES_PER_PATH_LEVEL];
+    // The computed root of the tree
+    signal input root;
+
+    // Verify the Merkle path.
+    var computedRoot = QuinaryTreeInclusionProof(levels)(leaf, path_indices, path_elements);
+
+    root === computedRoot;
+}

package/circom/utils/trees/QuinarySelector.circom

@@ -0,0 +1,42 @@
+pragma circom 2.0.0;
+
+// zk-kit import
+include "./safe-comparators.circom";
+// local imports
+include "../CalculateTotal.circom";
+
+/**
+ * Selects an item from a list based on the given index.
+ * It verifies the index is within the valid range and then iterates over the inputs to find the match.
+ * For each item, it checks if its position equals the given index and if so, multiplies the item 
+ * by the result of the equality check, effectively selecting it.
+ * The sum of these results yields the selected item, ensuring only the item at the specified index be the output.
+ *
+ * nb. The number of items must be less than 8, and the index must be less than the number of items.
+ */
+template QuinarySelector(choices) {
+    // The input elements to select from.
+    signal input in[choices];
+    // The index of the element to select
+    signal input index;
+    // The selected total sum of the elements.
+    signal output out;
+    
+    // Ensure that index < choices.
+    var computedIndex = SafeLessThan(3)([index, choices]);
+    computedIndex === 1;
+
+    // Initialize an array to hold the results of equality checks.
+    var computedResults[choices];
+
+    // For each item, check whether its index equals the input index.
+    // The result is multiplied by the corresponding input value.
+    for (var i = 0; i < choices; i++) {
+        var computedIsIndexEqual = IsEqual()([i, index]);
+
+        computedResults[i] = computedIsIndexEqual * in[i];
+    }
+
+    // Calculate the total sum of the results array.
+    out <== CalculateTotal(choices)(computedResults);
+}

package/circom/utils/trees/QuinaryTreeInclusionProof.circom

@@ -0,0 +1,55 @@
+pragma circom 2.0.0;
+
+// local imports
+include "../PoseidonHasher.circom";
+include "./Splicer.circom";
+
+/**
+ * Computes the root of an IQT given a leaf, its path, and sibling nodes at each level of the tree. 
+ * It iteratively incorporates the leaf or the hash from the previous level with sibling nodes using 
+ * the Splicer to place the leaf or hash at the correct position based on path_indices. 
+ * Then, it hashes these values together with PoseidonHasher to move up the tree. 
+ * This process repeats for each level (levels) of the tree, culminating in the computation of the tree's root.
+ */
+template QuinaryTreeInclusionProof(levels) {
+    // The number of leaves per node (tree arity)
+    var LEAVES_PER_NODE = 5;
+    // Number of leaves per path level (excluding the leaf itself)
+    var LEAVES_PER_PATH_LEVEL = LEAVES_PER_NODE - 1;
+
+    // The leaf to check for inclusion
+    signal input leaf;
+    // The path indices at each level of the tree
+    signal input path_indices[levels];
+    // The sibling nodes at each level of the tree
+    signal input path_elements[levels][LEAVES_PER_PATH_LEVEL];
+    // The computed root of the tree
+    signal output root;
+
+    var currentLeaf = leaf;
+
+    // Iteratively hash each level of path_elements with the leaf or previous hash
+    for (var i = 0; i < levels; i++) {
+        var elements[LEAVES_PER_PATH_LEVEL];
+
+        for (var j = 0; j < LEAVES_PER_PATH_LEVEL; j++) {
+            elements[j] = path_elements[i][j];
+        }
+
+        var computedSplicedLeaf[LEAVES_PER_NODE] = Splicer(LEAVES_PER_PATH_LEVEL)(
+            elements, 
+            currentLeaf, 
+            path_indices[i]
+        );
+
+        currentLeaf = PoseidonHasher(5)([
+            computedSplicedLeaf[0],
+            computedSplicedLeaf[1],
+            computedSplicedLeaf[2],
+            computedSplicedLeaf[3],
+            computedSplicedLeaf[4]
+        ]);
+    }
+
+    root <== currentLeaf;
+}

package/circom/utils/trees/Splicer.circom

@@ -0,0 +1,76 @@
+pragma circom 2.0.0;
+
+// circomlib imports
+include "./mux1.circom";
+// zk-kit import
+include "./safe-comparators.circom";
+// local imports
+include "./QuinarySelector.circom";
+
+/**
+ * The output array contains the input items, with the leaf inserted at the
+ * specified index. For example, if input = [0, 20, 30, 40], index = 3, and
+ * leaf = 10, the output will be [0, 20, 30, 10, 40].
+ */
+template Splicer(numItems) {
+    // The number of output items (because only one item is inserted).
+    var NUM_OUTPUT_ITEMS = numItems + 1;
+
+    // The input items to splice.
+    signal input in[numItems];
+    // The leaf to insert.
+    signal input leaf;
+    // The index at which to insert the leaf.
+    signal input index;
+    // The output array containing the spliced items.
+    signal output out[NUM_OUTPUT_ITEMS];
+    
+    // There is a loop where the goal is to assign values to the output signal.
+    // 
+    //  | output[0] | output[1] | output[2] | ...
+    // 
+    // We can either assign the leaf, or an item from the `items` signal, to the output, using Mux1().
+    // The Mux1's selector is 0 or 1 depending on whether the index is equal to the loop counter.
+    // 
+    //  i --> [IsEqual] <-- index
+    //             |
+    //             v
+    //  leaf --> [Mux1] <-- <item from in>
+    //             |
+    //             v
+    //          output[m]
+    // 
+    // To obtain the value from <item from in>, we need to compute an item
+    // index (let it be `s`).
+    // 1. if index = 2 and i = 0, then s = 0
+    // 2. if index = 2 and i = 1, then s = 1
+    // 3. if index = 2 and i = 2, then s = 2
+    // 4. if index = 2 and i = 3, then s = 2
+    // 5. if index = 2 and i = 4, then s = 3
+    // We then wire `s`, as well as each item in `in` to a QuinarySelector.
+    // The output signal from the QuinarySelector is <item from in> and gets
+    // wired to Mux1 (as above).
+
+    var inputs[NUM_OUTPUT_ITEMS];
+
+    for (var i = 0; i < numItems; i++) {
+        inputs[i] = in[i];
+    }
+
+    inputs[NUM_OUTPUT_ITEMS - 1] = 0;
+
+    for (var i = 0; i < NUM_OUTPUT_ITEMS; i++) {
+        // Determines if current index is greater than the insertion index.
+        var computedIsIndexAfterInsertPoint = SafeGreaterThan(3)([i, index]);
+
+        // Calculates correct index for original items, adjusting for leaf insertion.
+        var computedAdjustedIndex = i - computedIsIndexAfterInsertPoint;
+
+        // Selects item from the original array or the leaf for insertion.
+        var computedQuinarySelected = QuinarySelector(NUM_OUTPUT_ITEMS)(inputs, computedAdjustedIndex);
+        var computedIsIndexEqual = IsEqual()([index, i]);
+        var mux = Mux1()([computedQuinarySelected, leaf], computedIsIndexEqual);
+
+        out[i] <== mux;
+    }
+}

package/circom/voter/PollJoined.circom

@@ -19,8 +19,8 @@ template PollJoined(stateTreeDepth) {
     signal input voiceCreditsBalance;
     // Path elements
     signal input pathElements[stateTreeDepth][STATE_TREE_ARITY - 1];
-    // Path indices
-    signal input pathIndices[stateTreeDepth];
+    // Index
+    signal input index;
     // Poll State tree root which proves the user is joined
     signal input stateRoot;
     // The actual tree depth (might be <= stateTreeDepth) Used in BinaryMerkleRoot
@@ -32,12 +32,12 @@ template PollJoined(stateTreeDepth) {
     var stateLeaf = PoseidonHasher(3)([derivedPublicKey[0], derivedPublicKey[1], voiceCreditsBalance]);
 
     // Inclusion proof  
-    var stateLeafQip = BinaryMerkleRoot(stateTreeDepth)(
+    var calculatedRoot = BinaryMerkleRoot(stateTreeDepth)(
         stateLeaf,
         actualStateTreeDepth,
-        pathIndices,
+        index,
         pathElements
     );
 
-    stateLeafQip === stateRoot;
+    calculatedRoot === stateRoot;
 }

package/circom/voter/PollJoining.circom

@@ -18,8 +18,8 @@ template PollJoining(stateTreeDepth) {
     signal input pollPublicKey[2];
     // Siblings
     signal input siblings[stateTreeDepth][STATE_TREE_ARITY - 1];
-    // Indices
-    signal input indices[stateTreeDepth];
+    // Index
+    signal input index;
     // User's hashed private key
     signal input nullifier;
     // MACI State tree root which proves the user is signed up
@@ -46,7 +46,7 @@ template PollJoining(stateTreeDepth) {
     var calculatedRoot = BinaryMerkleRoot(stateTreeDepth)(
         publicKeyHash,
         actualStateTreeDepth,
-        indices,
+        index,
         siblings
     );