@maci-protocol/circuits 0.0.0-ci.ba71b1e → 0.0.0-ci.bd42e06

package/circom/utils/full/StateLeafAndBallotTransformer.circom

@@ -0,0 +1,122 @@
+pragma circom 2.0.0;
+
+// circomlib import
+include "./mux1.circom";
+// local import
+include "./MessageValidator.circom";
+
+/**
+ * Processes a command by verifying its validity and updates the state leaf and ballot accordingly. 
+ * If the message is correct, updates the public key in the state leaf and the nonce 
+ * in the ballot using multiplexer components.
+ * This template supports the full mode (all credits are spent on one option)
+ */
+template StateLeafAndBallotTransformerFull() {
+    // Length of the packed command.
+    var PACKED_COMMAND_LENGTH = 4;
+
+    // Number of user sign-ups in the state tree.
+    signal input totalSignups;
+    // Number of valid vote options for the poll.
+    signal input voteOptions;
+
+    // The following signals represents a state leaf (signed up user).
+    // Public key.
+    signal input stateLeafPublicKey[2];
+    // Current voice credit balance.
+    signal input stateLeafVoiceCreditBalance;
+
+    // The following signals represents a ballot.
+    // Nonce.
+    signal input ballotNonce;
+    // Current number of votes for specific option. 
+    signal input ballotCurrentVotesForOption;
+
+    // The following signals represents a command.
+    // State index of the user.
+    signal input commandStateIndex;
+    // Public key of the user.
+    signal input commandPublicKey[2];
+    // Vote option index.
+    signal input commandVoteOptionIndex;
+    // Vote weight.
+    signal input commandNewVoteWeight;
+    // Nonce.
+    signal input commandNonce;
+    // Poll identifier.
+    signal input commandPollId;
+    // Salt.
+    signal input commandSalt;
+    // EdDSA signature of the command (R part).
+    signal input commandSignaturePoint[2];
+    // EdDSA signature of the command (S part).
+    signal input commandSignatureScalar;
+    // Packed command. 
+    // nb. we are assuming that the packedCommand is always valid.
+    signal input packedCommand[PACKED_COMMAND_LENGTH];
+
+    // New state leaf (if the command is valid).
+    signal output newStateLeafPublicKey[2];
+    // New ballot (if the command is valid).
+    signal output newBallotNonce;
+    
+    // True when the command is valid; otherwise false.
+    signal output isValid;
+    // True if the state leaf index is valid
+    signal output isStateLeafIndexValid;
+    // True if the vote option index is valid
+    signal output isVoteOptionIndexValid;
+
+    // Check if the command / message is valid.
+    var (
+        computedIsValid,
+        computedIsStateLeafIndexValid,
+        computedIsVoteOptionIndexValid
+    ) = MessageValidatorFull()(
+        commandStateIndex,
+        totalSignups,
+        commandVoteOptionIndex,
+        voteOptions,
+        ballotNonce,
+        commandNonce,
+        packedCommand,
+        stateLeafPublicKey,
+        commandSignaturePoint,
+        commandSignatureScalar,
+        stateLeafVoiceCreditBalance,
+        ballotCurrentVotesForOption,
+        commandNewVoteWeight
+    );
+
+    // 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]
+        ],
+        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], computedIsValid);
+
+    newBallotNonce <== computedNewBallotNonceMux;
+
+    isValid <== computedIsValid;
+    isStateLeafIndexValid <== computedIsStateLeafIndexValid;
+    isVoteOptionIndexValid <== computedIsVoteOptionIndexValid;
+}

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

@@ -26,14 +26,14 @@ template MessageValidatorNonQv() {
     // Ballot nonce.
     signal input originalNonce;
     // Command nonce.
-    signal input nonce;
+    signal input commandNonce;
     // Packed command.
     signal input command[PACKED_COMMAND_LENGTH];
     // Public key of the state leaf (user).
     signal input publicKey[2];
-    // ECDSA signature of the command (R part).
+    // EdDSA signature of the command (R part).
     signal input signaturePoint[2];
-    // ECDSA signature of the command (S part).
+    // EdDSA signature of the command (S part).
     signal input signatureScalar;
     // State leaf current voice credit balance.
     signal input currentVoiceCreditBalance;
@@ -59,7 +59,7 @@ template MessageValidatorNonQv() {
     var computedIsVoteOptionIndexValid = SafeLessThan(252)([voteOptionIndex, voteOptions]);
 
     // Check (3) - The nonce must be correct.    
-    var computedIsNonceValid = IsEqual()([originalNonce + 1, nonce]);
+    var computedIsNonceValid = IsEqual()([originalNonce + 1, commandNonce]);
 
     // Check (4) - The signature must be correct.    
     var computedIsSignatureValid = VerifySignature()(publicKey, signaturePoint, signatureScalar, command);

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

@@ -47,9 +47,9 @@ template StateLeafAndBallotTransformerNonQv() {
     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 StateLeafAndBallotTransformerNonQv() {
     signal output isVoteOptionIndexValid;
 
     // Check if the command / message is valid.
-    var (computedMessageValidator, computedIsStateLeafIndexValid, computedIsVoteOptionIndexValid) = MessageValidatorNonQv()(
+    var (computedIsValid, computedIsStateLeafIndexValid, computedIsVoteOptionIndexValid) = MessageValidatorNonQv()(
         commandStateIndex,
         totalSignups,
         commandVoteOptionIndex,
@@ -87,19 +87,19 @@ template StateLeafAndBallotTransformerNonQv() {
     // 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/qv/MessageValidator.circom

@@ -26,14 +26,14 @@ template MessageValidator() {
     // Ballot nonce.
     signal input originalNonce;
     // Command nonce.
-    signal input nonce;
+    signal input commandNonce;
     // Packed command.
     signal input command[PACKED_COMMAND_LENGTH];
     // Public key of the state leaf (user).
     signal input publicKey[2];
-    // ECDSA signature of the command (R part).
+    // EdDSA signature of the command (R part).
     signal input signaturePoint[2];
-    // ECDSA signature of the command (S part).
+    // EdDSA signature of the command (S part).
     signal input signatureScalar;
     // State leaf current voice credit balance.
     signal input currentVoiceCreditBalance;
@@ -59,7 +59,7 @@ template MessageValidator() {
     var computedIsVoteOptionIndexValid = SafeLessThan(252)([voteOptionIndex, voteOptions]);
 
     // Check (3) - The nonce must be correct.    
-    var computedIsNonceValid = IsEqual()([originalNonce + 1, nonce]);
+    var computedIsNonceValid = IsEqual()([originalNonce + 1, commandNonce]);
 
     // Check (4) - The signature must be correct.    
     var computedIsSignatureValid = VerifySignature()(publicKey, signaturePoint, signatureScalar, command);

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/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/QuinaryGeneratePathIndices.circom

@@ -0,0 +1,44 @@
+pragma circom 2.0.0;
+
+// zk-kit import
+include "./safe-comparators.circom";
+// local imports
+include "../CalculateTotal.circom";
+
+/**
+ * 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 QuinaryGeneratePathIndices(levels) {
+    // The number of leaves per node (tree arity)
+    var LEAVES_PER_NODE = 5;
+
+    // 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 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] <-- 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], LEAVES_PER_NODE]);
+        computedIsOutputElementLessThanBase === 1;
+
+        // Re-compute the total sum.
+        computedResults[i] = out[i] * (LEAVES_PER_NODE ** i);
+    }
+    
+    // Check that the total sum matches the index.
+    var computedCalculateTotal = CalculateTotal(levels)(computedResults);
+
+    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

@@ -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,
         pathElements
     );
 
-    stateLeafQip === stateRoot;
+    calculatedRoot === stateRoot;
 }