@maci-protocol/circuits 0.0.0-ci.fd7cff6 → 0.0.0-ci.ffabe48

package/circom/coordinator/non-qv/processMessages.circom

@@ -5,12 +5,18 @@ include "./mux1.circom";
 // zk-kit imports
 include "./safe-comparators.circom";
 // local imports
-include "../../utils/hashers.circom";
-include "../../utils/messageToCommand.circom";
-include "../../utils/privToPubKey.circom";
-include "../../utils/non-qv/stateLeafAndBallotTransformer.circom";
-include "../../utils/trees/incrementalMerkleTree.circom";
-include "../../utils/trees/incrementalQuinaryTree.circom";
+include "../../utils/PoseidonHasher.circom";
+include "../../utils/MessageHasher.circom";
+include "../../utils/MessageToCommand.circom";
+include "../../utils/PrivateToPublicKey.circom";
+include "../../utils/non-qv/StateLeafAndBallotTransformer.circom";
+include "../../utils/trees/MerkleTreeInclusionProof.circom";
+include "../../utils/trees/LeafExists.circom";
+include "../../utils/trees/CheckRoot.circom";
+include "../../utils/trees/MerklePathIndicesGenerator.circom";
+include "../../utils/trees/BinaryMerkleRoot.circom";
+include "../../utils/trees/QuinaryTreeInclusionProof.circom";
+include "../../utils/trees/QuinaryGeneratePathIndices.circom";
 
 /**
  * Proves the correctness of processing a batch of MACI messages.
@@ -30,32 +36,31 @@ include "../../utils/trees/incrementalQuinaryTree.circom";
     var VOTE_OPTION_TREE_ARITY = 5;
     // Default for Binary trees.
     var STATE_TREE_ARITY = 2;
-    var MSG_LENGTH = 10;
-    var PACKED_CMD_LENGTH = 4;
-    var STATE_LEAF_LENGTH = 4;
+    var MESSAGE_LENGTH = 10;
+    var PACKED_COMMAND_LENGTH = 4;
+    var STATE_LEAF_LENGTH = 3;
     var BALLOT_LENGTH = 2;
-    var BALLOT_NONCE_IDX = 0;
-    var BALLOT_VO_ROOT_IDX = 1;
-    var STATE_LEAF_PUB_X_IDX = 0;
-    var STATE_LEAF_PUB_Y_IDX = 1;
-    var STATE_LEAF_VOICE_CREDIT_BALANCE_IDX = 2;
-    var STATE_LEAF_TIMESTAMP_IDX = 3;
-    var msgTreeZeroValue = 8370432830353022751713833565135785980866757267633941821328460903436894336785;
+    var BALLOT_NONCE_INDEX = 0;
+    var BALLOT_VOTE_OPTION_ROOT_INDEX = 1;
+    var STATE_LEAF_PUBLIC_X_INDEX = 0;
+    var STATE_LEAF_PUBLIC_Y_INDEX = 1;
+    var STATE_LEAF_VOICE_CREDIT_BALANCE_INDEX = 2;
+    var MESSAGE_TREE_ZERO_VALUE = 8370432830353022751713833565135785980866757267633941821328460903436894336785;
     // Number of options for this poll.
     var maxVoteOptions = VOTE_OPTION_TREE_ARITY ** voteOptionTreeDepth;
 
     // Number of users that have completed the sign up.
-    signal input numSignUps;
+    signal input totalSignups;
     // Value of chainHash at beginning of batch
     signal input inputBatchHash;
     // Value of chainHash at end of batch
     signal input outputBatchHash;
     // The messages.
-    signal input msgs[batchSize][MSG_LENGTH];
+    signal input messages[batchSize][MESSAGE_LENGTH];
     // The coordinator's private key.
-    signal input coordPrivKey;
+    signal input coordinatorPrivateKey;
     // The ECDH public key per message.
-    signal input encPubKeys[batchSize][2];
+    signal input encryptionPublicKeys[batchSize][2];
     // The current state root (before the processing).
     signal input currentStateRoot;
     // The actual tree depth (might be <= stateTreeDepth).
@@ -109,34 +114,31 @@ include "../../utils/trees/incrementalQuinaryTree.circom";
     // signals (for processing purposes).
     signal stateRoots[batchSize + 1];
     signal ballotRoots[batchSize + 1];
-    signal tmpStateRoot1[batchSize];
-    signal tmpStateRoot2[batchSize];
-    signal tmpBallotRoot1[batchSize];
-    signal tmpBallotRoot2[batchSize];
 
     // Must verify the current sb commitment.
     var computedCurrentSbCommitment = PoseidonHasher(3)([currentStateRoot, currentBallotRoot, currentSbSalt]);
     computedCurrentSbCommitment === currentSbCommitment;
 
     //  ----------------------------------------------------------------------- 
-        // 0. Ensure that the maximum vote options signal is valid and if
+    // 0. Ensure that the maximum vote options signal is valid and if
     // the maximum users signal is valid
     var voteOptionsValid = LessEqThan(32)([voteOptions, VOTE_OPTION_TREE_ARITY ** voteOptionTreeDepth]);
     voteOptionsValid === 1;
 
-    // Check numSignUps <= the max number of users (i.e., number of state leaves
+    // Check totalSignups <= the max number of users (i.e., number of state leaves
     // that can fit the state tree).
-    var numSignUpsValid = LessEqThan(32)([numSignUps, STATE_TREE_ARITY ** stateTreeDepth]);
-    numSignUpsValid === 1;
+    var totalSignupsValid = LessEqThan(32)([totalSignups, STATE_TREE_ARITY ** stateTreeDepth]);
+    totalSignupsValid === 1;
 
     // Hash each Message to check their existence in the Message chain hash.
     var computedMessageHashers[batchSize];
     var computedChainHashes[batchSize];
     var chainHash[batchSize + 1];
     chainHash[0] = inputBatchHash;
+
     for (var i = 0; i < batchSize; i++) {
         // calculate message hash
-        computedMessageHashers[i] = MessageHasher()(msgs[i], encPubKeys[i]);
+        computedMessageHashers[i] = MessageHasher()(messages[i], encryptionPublicKeys[i]);
         // check if message is valid or not (if index of message is less than index of last valid message in batch)
         var batchStartIndexValid = SafeLessThan(32)([index + i, batchEndIndex]);
         // calculate chain hash if message is valid
@@ -161,38 +163,38 @@ include "../../utils/trees/incrementalQuinaryTree.circom";
     // Ensure that the coordinator's public key from the contract is correct
     // based on the given private key - that is, the prover knows the
     // coordinator's private key.
-    var derivedPubKey[2] = PrivToPubKey()(coordPrivKey);
-    var derivedPubKeyHash = PoseidonHasher(2)(derivedPubKey);
-    derivedPubKeyHash === coordinatorPublicKeyHash;
+    var derivedPublicKey[2] = PrivateToPublicKey()(coordinatorPrivateKey);
+    var derivedPublicKeyHash = PoseidonHasher(2)(derivedPublicKey);
+    derivedPublicKeyHash === coordinatorPublicKeyHash;
 
     // Decrypt each Message into a Command.
     // The command i-th is composed by the following fields.
     // e.g., command 0 is made of commandsStateIndex[0], 
-    // commandsNewPubKey[0], ..., commandsPackedCommandOut[0]
+    // commandsNewPublicKey[0], ..., commandsPackedCommandOut[0]
     var computedCommandsStateIndex[batchSize];
-    var computedCommandsNewPubKey[batchSize][2];
+    var computedCommandsNewPublicKey[batchSize][2];
     var computedCommandsVoteOptionIndex[batchSize];
     var computedCommandsNewVoteWeight[batchSize];
     var computedCommandsNonce[batchSize];
     var computedCommandsPollId[batchSize];
     var computedCommandsSalt[batchSize];
-    var computedCommandsSigR8[batchSize][2];
-    var computedCommandsSigS[batchSize];
-    var computedCommandsPackedCommandOut[batchSize][PACKED_CMD_LENGTH];
+    var computedCommandsSignaturePoint[batchSize][2];
+    var computedCommandsSignatureScalar[batchSize];
+    var computedCommandsPackedCommandOut[batchSize][PACKED_COMMAND_LENGTH];
 
     for (var i = 0; i < batchSize; i++) {
         (
             computedCommandsStateIndex[i],
-            computedCommandsNewPubKey[i],
+            computedCommandsNewPublicKey[i],
             computedCommandsVoteOptionIndex[i],
             computedCommandsNewVoteWeight[i],
             computedCommandsNonce[i],
             computedCommandsPollId[i],
             computedCommandsSalt[i],
-            computedCommandsSigR8[i],
-            computedCommandsSigS[i],
+            computedCommandsSignaturePoint[i],
+            computedCommandsSignatureScalar[i],
             computedCommandsPackedCommandOut[i]
-        ) = MessageToCommand()(msgs[i], coordPrivKey, encPubKeys[i]);
+        ) = MessageToCommand()(messages[i], coordinatorPrivateKey, encryptionPublicKeys[i]);
     }
 
     // Process messages in reverse order.
@@ -207,43 +209,43 @@ include "../../utils/trees/incrementalQuinaryTree.circom";
     // Start from batchSize and decrement for process in reverse order.
     for (var i = batchSize - 1; i >= 0; i--) {
         // Process as vote type message.
-        var currentStateLeavesPathElement[stateTreeDepth][STATE_TREE_ARITY - 1];
-        var currentBallotPathElement[stateTreeDepth][STATE_TREE_ARITY - 1];
-        var currentVoteWeightsPathElement[voteOptionTreeDepth][VOTE_OPTION_TREE_ARITY - 1];
+        var computedCurrentStateLeavesPathElements[stateTreeDepth][STATE_TREE_ARITY - 1];
+        var computedCurrentBallotPathElements[stateTreeDepth][STATE_TREE_ARITY - 1];
+        var computedCurrentVoteWeightsPathElements[voteOptionTreeDepth][VOTE_OPTION_TREE_ARITY - 1];
         
         for (var j = 0; j < stateTreeDepth; j++) {
             for (var k = 0; k < STATE_TREE_ARITY - 1; k++) {
-                currentStateLeavesPathElement[j][k] = currentStateLeavesPathElements[i][j][k];
-                currentBallotPathElement[j][k] = currentBallotsPathElements[i][j][k];
+                computedCurrentStateLeavesPathElements[j][k] = currentStateLeavesPathElements[i][j][k];
+                computedCurrentBallotPathElements[j][k] = currentBallotsPathElements[i][j][k];
             }
         }
 
         for (var j = 0; j < voteOptionTreeDepth; j++) {
             for (var k = 0; k < VOTE_OPTION_TREE_ARITY - 1; k++) {
-                currentVoteWeightsPathElement[j][k] = currentVoteWeightsPathElements[i][j][k];
+                computedCurrentVoteWeightsPathElements[j][k] = currentVoteWeightsPathElements[i][j][k];
             }
         }
 
         (computedNewVoteStateRoot[i], computedNewVoteBallotRoot[i]) = ProcessOneNonQv(stateTreeDepth, voteOptionTreeDepth)(
-            numSignUps,
+            totalSignups,
             stateRoots[i + 1],
             ballotRoots[i + 1],
             actualStateTreeDepth,
             currentStateLeaves[i],
-            currentStateLeavesPathElement,
+            computedCurrentStateLeavesPathElements,
             currentBallots[i],
-            currentBallotPathElement,
+            computedCurrentBallotPathElements,
             currentVoteWeights[i],
-            currentVoteWeightsPathElement,
+            computedCurrentVoteWeightsPathElements,
             computedCommandsStateIndex[i],
-            computedCommandsNewPubKey[i],
+            computedCommandsNewPublicKey[i],
             computedCommandsVoteOptionIndex[i],
             computedCommandsNewVoteWeight[i],
             computedCommandsNonce[i],
             computedCommandsPollId[i],
             computedCommandsSalt[i],
-            computedCommandsSigR8[i],
-            computedCommandsSigS[i],
+            computedCommandsSignaturePoint[i],
+            computedCommandsSignatureScalar[i],
             computedCommandsPackedCommandOut[i],
             voteOptions
         );
@@ -266,28 +268,26 @@ include "../../utils/trees/incrementalQuinaryTree.circom";
  */
 template ProcessOneNonQv(stateTreeDepth, voteOptionTreeDepth) {
     // Constants defining the structure and size of state and ballots.
-    var STATE_LEAF_LENGTH = 4;
+    var STATE_LEAF_LENGTH = 3;
     var BALLOT_LENGTH = 2;
-    var MSG_LENGTH = 10;
-    var PACKED_CMD_LENGTH = 4;
+    var MESSAGE_LENGTH = 10;
+    var PACKED_COMMAND_LENGTH = 4;
     var VOTE_OPTION_TREE_ARITY = 5;
     var STATE_TREE_ARITY = 2;
-    var BALLOT_NONCE_IDX = 0;
-    // Ballot vote option (VO) root index.
-    var BALLOT_VO_ROOT_IDX = 1;
+    var BALLOT_NONCE_INDEX = 0;
+    // Ballot vote option (vote option) root index.
+    var BALLOT_VOTE_OPTION_ROOT_INDEX = 1;
 
     // Indices for elements within a state leaf.
     // Public key.
-    var STATE_LEAF_PUB_X_IDX = 0;
-    var STATE_LEAF_PUB_Y_IDX = 1;
+    var STATE_LEAF_PUBLIC_X_INDEX = 0;
+    var STATE_LEAF_PUBLIC_Y_INDEX = 1;
     // Voice Credit balance.
-    var STATE_LEAF_VOICE_CREDIT_BALANCE_IDX = 2;
-    // Timestamp.
-    var STATE_LEAF_TIMESTAMP_IDX = 3;
-    var N_BITS = 252;
+    var STATE_LEAF_VOICE_CREDIT_BALANCE_INDEX = 2;
+    var NUMBER_BITS = 252;
 
     // Number of users that have completed the sign up.
-    signal input numSignUps;
+    signal input totalSignups;
     // The current value of the state tree root.
     signal input currentStateRoot;
     // The current value of the ballot tree root.
@@ -309,16 +309,16 @@ template ProcessOneNonQv(stateTreeDepth, voteOptionTreeDepth) {
     signal input currentVoteWeightsPathElements[voteOptionTreeDepth][VOTE_OPTION_TREE_ARITY - 1];
 
     // Inputs related to the command being processed.
-    signal input cmdStateIndex;
-    signal input cmdNewPubKey[2];
-    signal input cmdVoteOptionIndex;
-    signal input cmdNewVoteWeight;
-    signal input cmdNonce;
-    signal input cmdPollId;
-    signal input cmdSalt;
-    signal input cmdSigR8[2];
-    signal input cmdSigS;
-    signal input packedCmd[PACKED_CMD_LENGTH];
+    signal input commandStateIndex;
+    signal input commandPublicKey[2];
+    signal input commandVoteOptionIndex;
+    signal input commandNewVoteWeight;
+    signal input commandNonce;
+    signal input commandPollId;
+    signal input commandSalt;
+    signal input commandSignaturePoint[2];
+    signal input commandSignatureScalar;
+    signal input packedCommand[PACKED_COMMAND_LENGTH];
 
     // The number of valid vote options for the poll.
     signal input voteOptions;
@@ -326,38 +326,38 @@ template ProcessOneNonQv(stateTreeDepth, voteOptionTreeDepth) {
     signal output newStateRoot;
     signal output newBallotRoot;
 
-    // equal to newBallotVoRootMux (Mux1).
-    signal newBallotVoRoot;
+    // equal to newBallotVoteOptionRootMux (Mux1).
+    signal newBallotVoteOptionRoot;
 
     // 1. Transform a state leaf and a ballot with a command.
     // The result is a new state leaf, a new ballot, and an isValid signal (0 or 1).
-    var computedNewSlPubKey[2], computedNewBallotNonce, computedIsValid, computedIsStateLeafIndexValid, computedIsVoteOptionIndexValid;
-    (computedNewSlPubKey, computedNewBallotNonce, computedIsValid, computedIsStateLeafIndexValid, computedIsVoteOptionIndexValid) = StateLeafAndBallotTransformerNonQv()(
-        numSignUps,
+    var computedNewStateLeafPublicKey[2], computedNewBallotNonce, computedIsValid, computedIsStateLeafIndexValid, computedIsVoteOptionIndexValid;
+    (computedNewStateLeafPublicKey, computedNewBallotNonce, computedIsValid, computedIsStateLeafIndexValid, computedIsVoteOptionIndexValid) = StateLeafAndBallotTransformerNonQv()(
+        totalSignups,
         voteOptions,
-        [stateLeaf[STATE_LEAF_PUB_X_IDX], stateLeaf[STATE_LEAF_PUB_Y_IDX]],
-        stateLeaf[STATE_LEAF_VOICE_CREDIT_BALANCE_IDX],
-        ballot[BALLOT_NONCE_IDX],
+        [stateLeaf[STATE_LEAF_PUBLIC_X_INDEX], stateLeaf[STATE_LEAF_PUBLIC_Y_INDEX]],
+        stateLeaf[STATE_LEAF_VOICE_CREDIT_BALANCE_INDEX],
+        ballot[BALLOT_NONCE_INDEX],
         currentVoteWeight,
-        cmdStateIndex,
-        cmdNewPubKey,
-        cmdVoteOptionIndex,
-        cmdNewVoteWeight,
-        cmdNonce,
-        cmdPollId,
-        cmdSalt,
-        cmdSigR8,
-        cmdSigS,
-        packedCmd
+        commandStateIndex,
+        commandPublicKey,
+        commandVoteOptionIndex,
+        commandNewVoteWeight,
+        commandNonce,
+        commandPollId,
+        commandSalt,
+        commandSignaturePoint,
+        commandSignatureScalar,
+        packedCommand
     );
 
     // 2. If computedIsStateLeafIndexValid is equal to zero, generate indices for leaf zero.
     // Otherwise, generate indices for command.stateIndex.
-    var stateIndexMux = Mux1()([0, cmdStateIndex], computedIsStateLeafIndexValid);
-    var computedStateLeafPathIndices[stateTreeDepth] = MerkleGeneratePathIndices(stateTreeDepth)(stateIndexMux);
+    var stateIndexMux = Mux1()([0, commandStateIndex], computedIsStateLeafIndexValid);
+    var computedStateLeafPathIndices[stateTreeDepth] = MerklePathIndicesGenerator(stateTreeDepth)(stateIndexMux);
 
     // 3. Verify that the original state leaf exists in the given state root.
-    var stateLeafHash = PoseidonHasher(4)(stateLeaf);
+    var stateLeafHash = PoseidonHasher(3)(stateLeaf);
     var stateLeafQip = BinaryMerkleRoot(stateTreeDepth)(
         stateLeafHash,
         actualStateTreeDepth,
@@ -369,8 +369,8 @@ template ProcessOneNonQv(stateTreeDepth, voteOptionTreeDepth) {
 
     // 4. Verify that the original ballot exists in the given ballot root.
     var computedBallot = PoseidonHasher(2)([
-        ballot[BALLOT_NONCE_IDX], 
-        ballot[BALLOT_VO_ROOT_IDX]
+        ballot[BALLOT_NONCE_INDEX], 
+        ballot[BALLOT_VOTE_OPTION_ROOT_INDEX]
     ]);
 
     var computedBallotQip = MerkleTreeInclusionProof(stateTreeDepth)(
@@ -382,52 +382,51 @@ template ProcessOneNonQv(stateTreeDepth, voteOptionTreeDepth) {
     computedBallotQip === currentBallotRoot;
 
     // 5. Verify that currentVoteWeight exists in the ballot's vote option root
-    // at cmdVoteOptionIndex.
-    var cmdVoteOptionIndexMux = Mux1()([0, cmdVoteOptionIndex], computedIsVoteOptionIndexValid);
-    var computedCurrentVoteWeightPathIndices[voteOptionTreeDepth] = QuinGeneratePathIndices(voteOptionTreeDepth)(cmdVoteOptionIndexMux);
+    // at commandVoteOptionIndex.
+    var commandVoteOptionIndexMux = Mux1()([0, commandVoteOptionIndex], computedIsVoteOptionIndexValid);
+    var computedCurrentVoteWeightPathIndices[voteOptionTreeDepth] = QuinaryGeneratePathIndices(voteOptionTreeDepth)(commandVoteOptionIndexMux);
 
-    var computedCurrentVoteWeightQip = QuinTreeInclusionProof(voteOptionTreeDepth)(
+    var computedCurrentVoteWeightQip = QuinaryTreeInclusionProof(voteOptionTreeDepth)(
         currentVoteWeight,
         computedCurrentVoteWeightPathIndices,
         currentVoteWeightsPathElements
     );
 
-    computedCurrentVoteWeightQip === ballot[BALLOT_VO_ROOT_IDX];
+    computedCurrentVoteWeightQip === ballot[BALLOT_VOTE_OPTION_ROOT_INDEX];
 
-    var voteWeightMux = Mux1()([currentVoteWeight, cmdNewVoteWeight], computedIsValid);
+    var voteWeightMux = Mux1()([currentVoteWeight, commandNewVoteWeight], computedIsValid);
     var voiceCreditBalanceMux = Mux1()(
         [
-            stateLeaf[STATE_LEAF_VOICE_CREDIT_BALANCE_IDX],
-            stateLeaf[STATE_LEAF_VOICE_CREDIT_BALANCE_IDX] + currentVoteWeight - cmdNewVoteWeight
+            stateLeaf[STATE_LEAF_VOICE_CREDIT_BALANCE_INDEX],
+            stateLeaf[STATE_LEAF_VOICE_CREDIT_BALANCE_INDEX] + currentVoteWeight - commandNewVoteWeight
         ],
         computedIsValid
     );
 
     // 5.1. Update the ballot's vote option root with the new vote weight.
-    var computedNewVoteOptionTreeQip = QuinTreeInclusionProof(voteOptionTreeDepth)(
+    var computedNewVoteOptionTreeQip = QuinaryTreeInclusionProof(voteOptionTreeDepth)(
         voteWeightMux,
         computedCurrentVoteWeightPathIndices,
         currentVoteWeightsPathElements
     );
 
     // The new vote option root in the ballot
-    var newBallotVoRootMux = Mux1()(
-        [ballot[BALLOT_VO_ROOT_IDX], computedNewVoteOptionTreeQip],
+    var newBallotVoteOptionRootMux = Mux1()(
+        [ballot[BALLOT_VOTE_OPTION_ROOT_INDEX], computedNewVoteOptionTreeQip],
         computedIsValid
     );
 
-    newBallotVoRoot <== newBallotVoRootMux;
+    newBallotVoteOptionRoot <== newBallotVoteOptionRootMux;
 
     // 6. Generate a new state root.
-    var computedNewStateLeafhash = PoseidonHasher(4)([
-        computedNewSlPubKey[STATE_LEAF_PUB_X_IDX],
-        computedNewSlPubKey[STATE_LEAF_PUB_Y_IDX],
-        voiceCreditBalanceMux,
-        stateLeaf[STATE_LEAF_TIMESTAMP_IDX]
+    var computedNewStateLeafHash = PoseidonHasher(3)([
+        computedNewStateLeafPublicKey[STATE_LEAF_PUBLIC_X_INDEX],
+        computedNewStateLeafPublicKey[STATE_LEAF_PUBLIC_Y_INDEX],
+        voiceCreditBalanceMux
     ]);
 
     var computedNewStateLeafQip = BinaryMerkleRoot(stateTreeDepth)(
-        computedNewStateLeafhash,
+        computedNewStateLeafHash,
         actualStateTreeDepth,
         computedStateLeafPathIndices,
         stateLeafPathElements
@@ -436,7 +435,7 @@ template ProcessOneNonQv(stateTreeDepth, voteOptionTreeDepth) {
     newStateRoot <== computedNewStateLeafQip;
  
     // 7. Generate a new ballot root.    
-    var computedNewBallot = PoseidonHasher(2)([computedNewBallotNonce, newBallotVoRoot]);
+    var computedNewBallot = PoseidonHasher(2)([computedNewBallotNonce, newBallotVoteOptionRoot]);
     var computedNewBallotQip = MerkleTreeInclusionProof(stateTreeDepth)(
         computedNewBallot,
         computedStateLeafPathIndices,
@@ -445,3 +444,4 @@ template ProcessOneNonQv(stateTreeDepth, voteOptionTreeDepth) {
 
     newBallotRoot <== computedNewBallotQip;
 }
+

package/circom/coordinator/non-qv/tallyVotes.circom

@@ -5,10 +5,12 @@ include "./comparators.circom";
 // zk-kit import
 include "./unpack-element.circom";
 // local imports
-include "../../utils/trees/incrementalMerkleTree.circom";
-include "../../utils/trees/incrementalQuinaryTree.circom";
-include "../../utils/calculateTotal.circom";
-include "../../utils/hashers.circom";
+include "../../utils/trees/CheckRoot.circom";
+include "../../utils/trees/MerklePathIndicesGenerator.circom";
+include "../../utils/trees/LeafExists.circom";
+include "../../utils/trees/QuinaryCheckRoot.circom";
+include "../../utils/CalculateTotal.circom";
+include "../../utils/PoseidonHasher.circom";
 
 /**
  * Processes batches of votes and verifies their validity in a Merkle tree structure.
@@ -16,33 +18,33 @@ include "../../utils/hashers.circom";
  */
 template TallyVotesNonQv(
     stateTreeDepth,
-    intStateTreeDepth,
+    tallyProcessingStateTreeDepth,
     voteOptionTreeDepth
 ) {
     // Ensure there's at least one level in the vote option tree.
     assert(voteOptionTreeDepth > 0);
     // Ensure the intermediate state tree has at least one level.
-    assert(intStateTreeDepth > 0);
+    assert(tallyProcessingStateTreeDepth > 0);
     // The intermediate state tree must be smaller than the full state tree.
-    assert(intStateTreeDepth < stateTreeDepth); 
+    assert(tallyProcessingStateTreeDepth < stateTreeDepth); 
 
     // Number of children per node in the tree, defining the tree's branching factor.
     var TREE_ARITY = 5;
     var BALLOT_TREE_ARITY = 2;
 
     // The number of ballots processed at once, determined by the depth of the intermediate state tree.
-    var batchSize = BALLOT_TREE_ARITY ** intStateTreeDepth;
+    var batchSize = BALLOT_TREE_ARITY ** tallyProcessingStateTreeDepth;
     // Number of voting options available, determined by the depth of the vote option tree.
-    var numVoteOptions = TREE_ARITY ** voteOptionTreeDepth;
+    var totalVoteOptions = TREE_ARITY ** voteOptionTreeDepth;
 
     // Number of elements in each ballot.
     var BALLOT_LENGTH = 2;
     // Index for the nonce in the ballot array.
-    var BALLOT_NONCE_IDX = 0;
+    var BALLOT_NONCE_INDEX = 0;
     // Index for the voting option root in the ballot array.
-    var BALLOT_VO_ROOT_IDX = 1;
+    var BALLOT_VOTE_OPTION_ROOT_INDEX = 1;
     // Difference in tree depths, used in path calculations.
-    var k = stateTreeDepth - intStateTreeDepth;
+    var STATE_TREE_DEPTH_DIFFERENCE = stateTreeDepth - tallyProcessingStateTreeDepth;
 
     // Root of the state Merkle tree, representing the overall state before voting.
     signal input stateRoot;
@@ -59,13 +61,13 @@ template TallyVotesNonQv(
     // Start index of given batch
     signal input index;
     // Number of users that signup
-    signal input numSignUps;
+    signal input totalSignups;
     // Ballots and their corresponding path elements for verification in the tree.
     signal input ballots[batchSize][BALLOT_LENGTH];
-    signal input ballotPathElements[k][BALLOT_TREE_ARITY - 1];
-    signal input votes[batchSize][numVoteOptions];
+    signal input ballotPathElements[STATE_TREE_DEPTH_DIFFERENCE][BALLOT_TREE_ARITY - 1];
+    signal input votes[batchSize][totalVoteOptions];
     // Current results for each vote option.
-    signal input currentResults[numVoteOptions];
+    signal input currentResults[totalVoteOptions];
     // Salt for the root of the current results.
     signal input currentResultsRootSalt;
     // Total voice credits spent so far.
@@ -83,21 +85,21 @@ template TallyVotesNonQv(
 
 
     // Validates that the index is within the valid range of sign-ups.
-    var numSignUpsValid = LessEqThan(50)([index, numSignUps]);
-    numSignUpsValid === 1;
+    var totalSignupsValid = LessEqThan(50)([index, totalSignups]);
+    totalSignupsValid === 1;
 
     // Hashes each ballot for subroot generation, and checks the existence of the leaf in the Merkle tree.    
     var computedBallotHashers[batchSize];
     
     for (var i = 0; i < batchSize; i++) {
-        computedBallotHashers[i] = PoseidonHasher(2)([ballots[i][BALLOT_NONCE_IDX], ballots[i][BALLOT_VO_ROOT_IDX]]);
+        computedBallotHashers[i] = PoseidonHasher(2)([ballots[i][BALLOT_NONCE_INDEX], ballots[i][BALLOT_VOTE_OPTION_ROOT_INDEX]]);
     }
 
-    var computedBallotSubroot = CheckRoot(intStateTreeDepth)(computedBallotHashers);
-    var computedBallotPathIndices[k] = MerkleGeneratePathIndices(k)(index / batchSize);
+    var computedBallotSubroot = CheckRoot(tallyProcessingStateTreeDepth)(computedBallotHashers);
+    var computedBallotPathIndices[STATE_TREE_DEPTH_DIFFERENCE] = MerklePathIndicesGenerator(STATE_TREE_DEPTH_DIFFERENCE)(index / batchSize);
 
     // Verifies each ballot's existence within the ballot tree.
-    LeafExists(k)(
+    LeafExists(STATE_TREE_DEPTH_DIFFERENCE)(
         computedBallotSubroot,
         ballotPathElements,
         computedBallotPathIndices,
@@ -106,9 +108,10 @@ template TallyVotesNonQv(
 
     // Processes vote options, verifying each against its declared root.
     var computedVoteTree[batchSize];
+
     for (var i = 0; i < batchSize; i++) {
-        computedVoteTree[i] = QuinCheckRoot(voteOptionTreeDepth)(votes[i]);
-        computedVoteTree[i] === ballots[i][BALLOT_VO_ROOT_IDX];
+        computedVoteTree[i] = QuinaryCheckRoot(voteOptionTreeDepth)(votes[i]);
+        computedVoteTree[i] === ballots[i][BALLOT_VOTE_OPTION_ROOT_INDEX];
     }
 
     // Calculates new results and spent voice credits based on the current and incoming votes.
@@ -116,27 +119,30 @@ template TallyVotesNonQv(
     var computedIsZero = IsZero()(computedIsFirstBatch);
 
     // Tally the new results.
-    var computedCalculateTotalResult[numVoteOptions];
-    for (var i = 0; i < numVoteOptions; i++) {
-        var computedNumsRC[batchSize + 1];
-        computedNumsRC[batchSize] = currentResults[i] * computedIsZero;
+    var computedCalculateTotalResult[totalVoteOptions];
+
+    for (var i = 0; i < totalVoteOptions; i++) {
+        var computedVotes[batchSize + 1];
+        computedVotes[batchSize] = currentResults[i] * computedIsZero;
+
         for (var j = 0; j < batchSize; j++) {
-            computedNumsRC[j] = votes[j][i];
+            computedVotes[j] = votes[j][i];
         }
 
-        computedCalculateTotalResult[i] = CalculateTotal(batchSize + 1)(computedNumsRC);
+        computedCalculateTotalResult[i] = CalculateTotal(batchSize + 1)(computedVotes);
     }
 
     // Tally the new spent voice credit total.
-    var computedNumsSVC[batchSize * numVoteOptions + 1];
-    computedNumsSVC[batchSize * numVoteOptions] = currentSpentVoiceCreditSubtotal * computedIsZero;
+    var computedTotalVoiceCreditSpent[batchSize * totalVoteOptions + 1];
+    computedTotalVoiceCreditSpent[batchSize * totalVoteOptions] = currentSpentVoiceCreditSubtotal * computedIsZero;
+
     for (var i = 0; i < batchSize; i++) {
-        for (var j = 0; j < numVoteOptions; j++) {
-            computedNumsSVC[i * numVoteOptions + j] = votes[i][j];
+        for (var j = 0; j < totalVoteOptions; j++) {
+            computedTotalVoiceCreditSpent[i * totalVoteOptions + j] = votes[i][j];
         }
     }
 
-    var computedNewSpentVoiceCreditSubtotal = CalculateTotal(batchSize * numVoteOptions + 1)(computedNumsSVC);
+    var computedNewSpentVoiceCreditSubtotal = CalculateTotal(batchSize * totalVoteOptions + 1)(computedTotalVoiceCreditSpent);
 
     // Verifies the updated results and spent credits, ensuring consistency and correctness of tally updates.
     ResultCommitmentVerifierNonQv(voteOptionTreeDepth)(
@@ -163,7 +169,7 @@ template TallyVotesNonQv(
     // 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 numVoteOptions = TREE_ARITY ** voteOptionTreeDepth;
+    var totalVoteOptions = TREE_ARITY ** voteOptionTreeDepth;
 
     // Equal to 1 if this is the first batch, otherwise 0.
     signal input isFirstBatch;
@@ -173,12 +179,12 @@ template TallyVotesNonQv(
     signal input newTallyCommitment;
 
     // Current results for each vote option.
-    signal input currentResults[numVoteOptions];
+    signal input currentResults[totalVoteOptions];
     // Salt for the root of the current results.
     signal input currentResultsRootSalt;
 
     // New results for each vote option.
-    signal input newResults[numVoteOptions];
+    signal input newResults[totalVoteOptions];
     // Salt for the root of the new results.
     signal input newResultsRootSalt;
 
@@ -193,7 +199,7 @@ template TallyVotesNonQv(
     signal input newSpentVoiceCreditSubtotalSalt;
 
     // Compute the commitment to the current results.
-    var computedCurrentResultsRoot = QuinCheckRoot(voteOptionTreeDepth)(currentResults);
+    var computedCurrentResultsRoot = QuinaryCheckRoot(voteOptionTreeDepth)(currentResults);
 
     // Verify currentResultsCommitmentHash.
     var computedCurrentResultsCommitment = PoseidonHasher(2)([computedCurrentResultsRoot, currentResultsRootSalt]);
@@ -209,14 +215,14 @@ template TallyVotesNonQv(
     // computedIsZero.out is 0 if this is the first batch.
     var computedIsZero = IsZero()(isFirstBatch);
 
-    // hz is 0 if this is the first batch, currentTallyCommitment should be 0 if this is the first batch.
-    // hz is 1 if this is not the first batch, currentTallyCommitment should not be 0 if this is the first batch.
-    signal hz;
-    hz <== computedIsZero * computedCurrentTallyCommitment;
-    hz === currentTallyCommitment;
+    // 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 = QuinCheckRoot(voteOptionTreeDepth)(newResults);
+    var computedNewResultsRoot = QuinaryCheckRoot(voteOptionTreeDepth)(newResults);
     var computedNewResultsCommitment = PoseidonHasher(2)([computedNewResultsRoot, newResultsRootSalt]);
 
     // Compute the commitment to the new spent voice credits value.