@maci-protocol/circuits 0.0.0-ci.0bef05d → 0.0.0-ci.0c8f2ee

package/circom/coordinator/non-qv/{processMessages.circom → MessageProcessor.circom}

@@ -9,19 +9,13 @@ 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/incrementalQuinaryTree.circom";
+include "./SingleMessageProcessor.circom";
 
 /**
  * Proves the correctness of processing a batch of MACI messages.
  * This template does not support Quadratic Voting (QV).
  */
- template ProcessMessagesNonQv(
+ template MessageProcessorNonQv(
     stateTreeDepth,
     batchSize,
     voteOptionTreeDepth
@@ -119,7 +113,7 @@ include "../../utils/trees/incrementalQuinaryTree.circom";
     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;
@@ -208,34 +202,34 @@ 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)(
+        (computedNewVoteStateRoot[i], computedNewVoteBallotRoot[i]) = SingleMessageProcessorNonQv(stateTreeDepth, voteOptionTreeDepth)(
             totalSignups,
             stateRoots[i + 1],
             ballotRoots[i + 1],
             actualStateTreeDepth,
             currentStateLeaves[i],
-            currentStateLeavesPathElement,
+            computedCurrentStateLeavesPathElements,
             currentBallots[i],
-            currentBallotPathElement,
+            computedCurrentBallotPathElements,
             currentVoteWeights[i],
-            currentVoteWeightsPathElement,
+            computedCurrentVoteWeightsPathElements,
             computedCommandsStateIndex[i],
             computedCommandsNewPublicKey[i],
             computedCommandsVoteOptionIndex[i],
@@ -256,191 +250,3 @@ include "../../utils/trees/incrementalQuinaryTree.circom";
     var computedNewSbCommitment = PoseidonHasher(3)([stateRoots[0], ballotRoots[0], newSbSalt]);
     computedNewSbCommitment === newSbCommitment;
 }
-
-/**
- * Processes one message and updates the state accordingly. 
- * This template involves complex interactions, including transformations based on message type, 
- * validations against current states like voice credit balances or vote weights, 
- * and updates to Merkle trees representing state and ballot information. 
- * This is a critical building block for ensuring the integrity and correctness of MACI state.
- * This template does not support Quadratic Voting (QV).
- */
-template ProcessOneNonQv(stateTreeDepth, voteOptionTreeDepth) {
-    // Constants defining the structure and size of state and ballots.
-    var STATE_LEAF_LENGTH = 3;
-    var BALLOT_LENGTH = 2;
-    var MESSAGE_LENGTH = 10;
-    var PACKED_COMMAND_LENGTH = 4;
-    var VOTE_OPTION_TREE_ARITY = 5;
-    var STATE_TREE_ARITY = 2;
-    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_PUBLIC_X_INDEX = 0;
-    var STATE_LEAF_PUBLIC_Y_INDEX = 1;
-    // Voice Credit balance.
-    var STATE_LEAF_VOICE_CREDIT_BALANCE_INDEX = 2;
-    var NUMBER_BITS = 252;
-
-    // Number of users that have completed the sign up.
-    signal input totalSignups;
-    // The current value of the state tree root.
-    signal input currentStateRoot;
-    // The current value of the ballot tree root.
-    signal input currentBallotRoot;
-    // The actual tree depth (might be <= stateTreeDepth).
-    signal input actualStateTreeDepth;
-
-    // The state leaf and related path elements.
-    signal input stateLeaf[STATE_LEAF_LENGTH];
-    // Sibling nodes at each level of the state tree to verify the specific state leaf.
-    signal input stateLeafPathElements[stateTreeDepth][STATE_TREE_ARITY - 1];
-
-    // The ballot and related path elements.
-    signal input ballot[BALLOT_LENGTH];
-    signal input ballotPathElements[stateTreeDepth][STATE_TREE_ARITY - 1];
-
-    // The current vote weight and related path elements.
-    signal input currentVoteWeight;
-    signal input currentVoteWeightsPathElements[voteOptionTreeDepth][VOTE_OPTION_TREE_ARITY - 1];
-
-    // Inputs related to the command being processed.
-    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;
-
-    signal output newStateRoot;
-    signal output newBallotRoot;
-
-    // equal to newBallotVoteOptionRootMux (Mux1).
-    signal newBallotVoRoot;
-
-    // 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 computedNewstateLeafPublicKey[2], computedNewBallotNonce, computedIsValid, computedIsStateLeafIndexValid, computedIsVoteOptionIndexValid;
-    (computedNewstateLeafPublicKey, computedNewBallotNonce, computedIsValid, computedIsStateLeafIndexValid, computedIsVoteOptionIndexValid) = StateLeafAndBallotTransformerNonQv()(
-        totalSignups,
-        voteOptions,
-        [stateLeaf[STATE_LEAF_PUBLIC_X_INDEX], stateLeaf[STATE_LEAF_PUBLIC_Y_INDEX]],
-        stateLeaf[STATE_LEAF_VOICE_CREDIT_BALANCE_INDEX],
-        ballot[BALLOT_NONCE_INDEX],
-        currentVoteWeight,
-        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, commandStateIndex], computedIsStateLeafIndexValid);
-    var computedStateLeafPathIndices[stateTreeDepth] = MerklePathIndicesGenerator(stateTreeDepth)(stateIndexMux);
-
-    // 3. Verify that the original state leaf exists in the given state root.
-    var stateLeafHash = PoseidonHasher(3)(stateLeaf);
-    var stateLeafQip = BinaryMerkleRoot(stateTreeDepth)(
-        stateLeafHash,
-        actualStateTreeDepth,
-        computedStateLeafPathIndices,
-        stateLeafPathElements
-    );
-
-    stateLeafQip === currentStateRoot;
-
-    // 4. Verify that the original ballot exists in the given ballot root.
-    var computedBallot = PoseidonHasher(2)([
-        ballot[BALLOT_NONCE_INDEX], 
-        ballot[BALLOT_VOTE_OPTION_ROOT_INDEX]
-    ]);
-
-    var computedBallotQip = MerkleTreeInclusionProof(stateTreeDepth)(
-        computedBallot,
-        computedStateLeafPathIndices,
-        ballotPathElements
-    );
-
-    computedBallotQip === currentBallotRoot;
-
-    // 5. Verify that currentVoteWeight exists in the ballot's vote option root
-    // at commandVoteOptionIndex.
-    var commandVoteOptionIndexMux = Mux1()([0, commandVoteOptionIndex], computedIsVoteOptionIndexValid);
-    var computedCurrentVoteWeightPathIndices[voteOptionTreeDepth] = QuinGeneratePathIndices(voteOptionTreeDepth)(commandVoteOptionIndexMux);
-
-    var computedCurrentVoteWeightQip = QuinTreeInclusionProof(voteOptionTreeDepth)(
-        currentVoteWeight,
-        computedCurrentVoteWeightPathIndices,
-        currentVoteWeightsPathElements
-    );
-
-    computedCurrentVoteWeightQip === ballot[BALLOT_VOTE_OPTION_ROOT_INDEX];
-
-    var voteWeightMux = Mux1()([currentVoteWeight, commandNewVoteWeight], computedIsValid);
-    var voiceCreditBalanceMux = Mux1()(
-        [
-            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)(
-        voteWeightMux,
-        computedCurrentVoteWeightPathIndices,
-        currentVoteWeightsPathElements
-    );
-
-    // The new vote option root in the ballot
-    var newBallotVoteOptionRootMux = Mux1()(
-        [ballot[BALLOT_VOTE_OPTION_ROOT_INDEX], computedNewVoteOptionTreeQip],
-        computedIsValid
-    );
-
-    newBallotVoRoot <== newBallotVoteOptionRootMux;
-
-    // 6. Generate a new state root.
-    var computedNewStateLeafhash = PoseidonHasher(3)([
-        computedNewstateLeafPublicKey[STATE_LEAF_PUBLIC_X_INDEX],
-        computedNewstateLeafPublicKey[STATE_LEAF_PUBLIC_Y_INDEX],
-        voiceCreditBalanceMux
-    ]);
-
-    var computedNewStateLeafQip = BinaryMerkleRoot(stateTreeDepth)(
-        computedNewStateLeafhash,
-        actualStateTreeDepth,
-        computedStateLeafPathIndices,
-        stateLeafPathElements
-    );
-
-    newStateRoot <== computedNewStateLeafQip;
- 
-    // 7. Generate a new ballot root.    
-    var computedNewBallot = PoseidonHasher(2)([computedNewBallotNonce, newBallotVoRoot]);
-    var computedNewBallotQip = MerkleTreeInclusionProof(stateTreeDepth)(
-        computedNewBallot,
-        computedStateLeafPathIndices,
-        ballotPathElements
-    );
-
-    newBallotRoot <== computedNewBallotQip;
-}
-

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

@@ -0,0 +1,200 @@
+pragma circom 2.0.0;
+
+// circomlib import
+include "./mux1.circom";
+// local imports
+include "../../utils/PoseidonHasher.circom";
+include "../../utils/trees/MerkleTreeInclusionProof.circom";
+include "../../utils/trees/MerklePathIndicesGenerator.circom";
+include "../../utils/trees/BinaryMerkleRoot.circom";
+include "../../utils/trees/QuinaryTreeInclusionProof.circom";
+include "../../utils/trees/QuinaryGeneratePathIndices.circom";
+include "../../utils/non-qv/StateLeafAndBallotTransformer.circom";
+
+
+/**
+ * Processes one message and updates the state accordingly. 
+ * This template involves complex interactions, including transformations based on message type, 
+ * validations against current states like voice credit balances or vote weights, 
+ * and updates to Merkle trees representing state and ballot information. 
+ * This is a critical building block for ensuring the integrity and correctness of MACI state.
+ * This template does not support Quadratic Voting (QV).
+ */
+template SingleMessageProcessorNonQv(stateTreeDepth, voteOptionTreeDepth) {
+    // Constants defining the structure and size of state and ballots.
+    var STATE_LEAF_LENGTH = 3;
+    var BALLOT_LENGTH = 2;
+    var MESSAGE_LENGTH = 10;
+    var PACKED_COMMAND_LENGTH = 4;
+    var VOTE_OPTION_TREE_ARITY = 5;
+    var STATE_TREE_ARITY = 2;
+    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_PUBLIC_X_INDEX = 0;
+    var STATE_LEAF_PUBLIC_Y_INDEX = 1;
+    // Voice Credit balance.
+    var STATE_LEAF_VOICE_CREDIT_BALANCE_INDEX = 2;
+    var NUMBER_BITS = 252;
+
+    // Number of users that have completed the sign up.
+    signal input totalSignups;
+    // The current value of the state tree root.
+    signal input currentStateRoot;
+    // The current value of the ballot tree root.
+    signal input currentBallotRoot;
+    // The actual tree depth (might be <= stateTreeDepth).
+    signal input actualStateTreeDepth;
+
+    // The state leaf and related path elements.
+    signal input stateLeaf[STATE_LEAF_LENGTH];
+    // Sibling nodes at each level of the state tree to verify the specific state leaf.
+    signal input stateLeafPathElements[stateTreeDepth][STATE_TREE_ARITY - 1];
+
+    // The ballot and related path elements.
+    signal input ballot[BALLOT_LENGTH];
+    signal input ballotPathElements[stateTreeDepth][STATE_TREE_ARITY - 1];
+
+    // The current vote weight and related path elements.
+    signal input currentVoteWeight;
+    signal input currentVoteWeightsPathElements[voteOptionTreeDepth][VOTE_OPTION_TREE_ARITY - 1];
+
+    // Inputs related to the command being processed.
+    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;
+
+    signal output newStateRoot;
+    signal output newBallotRoot;
+
+    // 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 computedNewStateLeafPublicKey[2], computedNewBallotNonce, computedIsValid, computedIsStateLeafIndexValid, computedIsVoteOptionIndexValid;
+    (computedNewStateLeafPublicKey, computedNewBallotNonce, computedIsValid, computedIsStateLeafIndexValid, computedIsVoteOptionIndexValid) = StateLeafAndBallotTransformerNonQv()(
+        totalSignups,
+        voteOptions,
+        [stateLeaf[STATE_LEAF_PUBLIC_X_INDEX], stateLeaf[STATE_LEAF_PUBLIC_Y_INDEX]],
+        stateLeaf[STATE_LEAF_VOICE_CREDIT_BALANCE_INDEX],
+        ballot[BALLOT_NONCE_INDEX],
+        currentVoteWeight,
+        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, commandStateIndex], computedIsStateLeafIndexValid);
+    var computedStateLeafPathIndices[stateTreeDepth] = MerklePathIndicesGenerator(stateTreeDepth)(stateIndexMux);
+
+    // 3. Verify that the original state leaf exists in the given state root.
+    var stateLeafHash = PoseidonHasher(3)(stateLeaf);
+    var stateLeafQip = BinaryMerkleRoot(stateTreeDepth)(
+        stateLeafHash,
+        actualStateTreeDepth,
+        computedStateLeafPathIndices,
+        stateLeafPathElements
+    );
+
+    stateLeafQip === currentStateRoot;
+
+    // 4. Verify that the original ballot exists in the given ballot root.
+    var computedBallot = PoseidonHasher(2)([
+        ballot[BALLOT_NONCE_INDEX], 
+        ballot[BALLOT_VOTE_OPTION_ROOT_INDEX]
+    ]);
+
+    var computedBallotQip = MerkleTreeInclusionProof(stateTreeDepth)(
+        computedBallot,
+        computedStateLeafPathIndices,
+        ballotPathElements
+    );
+
+    computedBallotQip === currentBallotRoot;
+
+    // 5. Verify that currentVoteWeight exists in the ballot's vote option root
+    // at commandVoteOptionIndex.
+    var commandVoteOptionIndexMux = Mux1()([0, commandVoteOptionIndex], computedIsVoteOptionIndexValid);
+    var computedCurrentVoteWeightPathIndices[voteOptionTreeDepth] = QuinaryGeneratePathIndices(voteOptionTreeDepth)(commandVoteOptionIndexMux);
+
+    var computedCurrentVoteWeightQip = QuinaryTreeInclusionProof(voteOptionTreeDepth)(
+        currentVoteWeight,
+        computedCurrentVoteWeightPathIndices,
+        currentVoteWeightsPathElements
+    );
+
+    computedCurrentVoteWeightQip === ballot[BALLOT_VOTE_OPTION_ROOT_INDEX];
+
+    var voteWeightMux = Mux1()([currentVoteWeight, commandNewVoteWeight], computedIsValid);
+    var voiceCreditBalanceMux = Mux1()(
+        [
+            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 = QuinaryTreeInclusionProof(voteOptionTreeDepth)(
+        voteWeightMux,
+        computedCurrentVoteWeightPathIndices,
+        currentVoteWeightsPathElements
+    );
+
+    // The new vote option root in the ballot
+    var newBallotVoteOptionRootMux = Mux1()(
+        [ballot[BALLOT_VOTE_OPTION_ROOT_INDEX], computedNewVoteOptionTreeQip],
+        computedIsValid
+    );
+
+    newBallotVoteOptionRoot <== newBallotVoteOptionRootMux;
+
+    // 6. Generate a new state root.
+    var computedNewStateLeafHash = PoseidonHasher(3)([
+        computedNewStateLeafPublicKey[STATE_LEAF_PUBLIC_X_INDEX],
+        computedNewStateLeafPublicKey[STATE_LEAF_PUBLIC_Y_INDEX],
+        voiceCreditBalanceMux
+    ]);
+
+    var computedNewStateLeafQip = BinaryMerkleRoot(stateTreeDepth)(
+        computedNewStateLeafHash,
+        actualStateTreeDepth,
+        computedStateLeafPathIndices,
+        stateLeafPathElements
+    );
+
+    newStateRoot <== computedNewStateLeafQip;
+ 
+    // 7. Generate a new ballot root.    
+    var computedNewBallot = PoseidonHasher(2)([computedNewBallotNonce, newBallotVoteOptionRoot]);
+    var computedNewBallotQip = MerkleTreeInclusionProof(stateTreeDepth)(
+        computedNewBallot,
+        computedStateLeafPathIndices,
+        ballotPathElements
+    );
+
+    newBallotRoot <== computedNewBallotQip;
+}

package/circom/coordinator/non-qv/{tallyVotes.circom → VoteTally.circom}

@@ -5,10 +5,11 @@ include "./comparators.circom";
 // zk-kit import
 include "./unpack-element.circom";
 // local imports
+include "../../utils/non-qv/ResultCommitmentVerifier.circom";
 include "../../utils/trees/CheckRoot.circom";
 include "../../utils/trees/MerklePathIndicesGenerator.circom";
 include "../../utils/trees/LeafExists.circom";
-include "../../utils/trees/incrementalQuinaryTree.circom";
+include "../../utils/trees/QuinaryCheckRoot.circom";
 include "../../utils/CalculateTotal.circom";
 include "../../utils/PoseidonHasher.circom";
 
@@ -16,24 +17,24 @@ include "../../utils/PoseidonHasher.circom";
  * Processes batches of votes and verifies their validity in a Merkle tree structure.
  * This template does not support Quadratic Voting (QV).
  */
-template TallyVotesNonQv(
+template VoteTallyNonQv(
     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 totalVoteOptions = TREE_ARITY ** voteOptionTreeDepth;
 
@@ -44,7 +45,7 @@ template TallyVotesNonQv(
     // Index for the voting option root in the ballot array.
     var BALLOT_VOTE_OPTION_ROOT_INDEX = 1;
     // Difference in tree depths, used in path calculations.
-    var STATE_INT_TREE_DEPTH_DIFFERENCE = stateTreeDepth - intStateTreeDepth;
+    var STATE_TREE_DEPTH_DIFFERENCE = stateTreeDepth - tallyProcessingStateTreeDepth;
 
     // Root of the state Merkle tree, representing the overall state before voting.
     signal input stateRoot;
@@ -64,7 +65,7 @@ template TallyVotesNonQv(
     signal input totalSignups;
     // Ballots and their corresponding path elements for verification in the tree.
     signal input ballots[batchSize][BALLOT_LENGTH];
-    signal input ballotPathElements[STATE_INT_TREE_DEPTH_DIFFERENCE][BALLOT_TREE_ARITY - 1];
+    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[totalVoteOptions];
@@ -95,11 +96,11 @@ template TallyVotesNonQv(
         computedBallotHashers[i] = PoseidonHasher(2)([ballots[i][BALLOT_NONCE_INDEX], ballots[i][BALLOT_VOTE_OPTION_ROOT_INDEX]]);
     }
 
-    var computedBallotSubroot = CheckRoot(intStateTreeDepth)(computedBallotHashers);
-    var computedBallotPathIndices[STATE_INT_TREE_DEPTH_DIFFERENCE] = MerklePathIndicesGenerator(STATE_INT_TREE_DEPTH_DIFFERENCE)(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(STATE_INT_TREE_DEPTH_DIFFERENCE)(
+    LeafExists(STATE_TREE_DEPTH_DIFFERENCE)(
         computedBallotSubroot,
         ballotPathElements,
         computedBallotPathIndices,
@@ -110,7 +111,7 @@ template TallyVotesNonQv(
     var computedVoteTree[batchSize];
 
     for (var i = 0; i < batchSize; i++) {
-        computedVoteTree[i] = QuinCheckRoot(voteOptionTreeDepth)(votes[i]);
+        computedVoteTree[i] = QuinaryCheckRoot(voteOptionTreeDepth)(votes[i]);
         computedVoteTree[i] === ballots[i][BALLOT_VOTE_OPTION_ROOT_INDEX];
     }
 
@@ -122,26 +123,27 @@ template TallyVotesNonQv(
     var computedCalculateTotalResult[totalVoteOptions];
 
     for (var i = 0; i < totalVoteOptions; i++) {
-        var computedNumsRC[batchSize + 1];
-        computedNumsRC[batchSize] = currentResults[i] * computedIsZero;
+        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 * totalVoteOptions + 1];
-    computedNumsSVC[batchSize * totalVoteOptions] = currentSpentVoiceCreditSubtotal * computedIsZero;
+    var computedTotalVoiceCreditSpent[batchSize * totalVoteOptions + 1];
+    computedTotalVoiceCreditSpent[batchSize * totalVoteOptions] = currentSpentVoiceCreditSubtotal * computedIsZero;
 
     for (var i = 0; i < batchSize; i++) {
         for (var j = 0; j < totalVoteOptions; j++) {
-            computedNumsSVC[i * totalVoteOptions + j] = votes[i][j];
+            computedTotalVoiceCreditSpent[i * totalVoteOptions + j] = votes[i][j];
         }
     }
 
-    var computedNewSpentVoiceCreditSubtotal = CalculateTotal(batchSize * totalVoteOptions + 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)(
@@ -158,81 +160,3 @@ template TallyVotesNonQv(
         newSpentVoiceCreditSubtotalSalt        
     );
 }
-
-/** 
- * Performs verifications and computations related to current voting results. 
- * Also, computes and outputs a commitment to the new results.
- * This template does not support Quadratic Voting (QV).
- */
- template ResultCommitmentVerifierNonQv(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;
-
-    // Compute the commitment to the current results.
-    var computedCurrentResultsRoot = QuinCheckRoot(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]);
-
-    // Commit to the current tally
-    var computedCurrentTallyCommitment = PoseidonHasher(2)([computedCurrentResultsCommitment, computedCurrentSpentVoiceCreditsCommitment]);
-
-    // 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 = QuinCheckRoot(voteOptionTreeDepth)(newResults);
-    var computedNewResultsCommitment = PoseidonHasher(2)([computedNewResultsRoot, newResultsRootSalt]);
-
-    // Compute the commitment to the new spent voice credits value.
-    var computedNewSpentVoiceCreditsCommitment = PoseidonHasher(2)([newSpentVoiceCreditSubtotal, newSpentVoiceCreditSubtotalSalt]);
-
-    // Commit to the new tally.
-    var computedNewTallyCommitment = PoseidonHasher(2)([
-        computedNewResultsCommitment,
-        computedNewSpentVoiceCreditsCommitment
-    ]);
-    
-    computedNewTallyCommitment === newTallyCommitment;
-}
-