@maci-protocol/circuits 0.0.0-ci.752ce71 → 0.0.0-ci.75ef321

package/circom/circuits.json

@@ -11,9 +11,9 @@
     "params": [10],
     "pubs": ["stateRoot"]
   },
-  "ProcessMessages_10-20-2_test": {
-    "file": "./coordinator/qv/processMessages",
-    "template": "ProcessMessages",
+  "MessageProcessorQv_10-20-2_test": {
+    "file": "./coordinator/qv/MessageProcessor",
+    "template": "MessageProcessorQv",
     "params": [10, 20, 2],
     "pubs": [
       "totalSignups",
@@ -27,9 +27,9 @@
       "voteOptions"
     ]
   },
-  "ProcessMessagesNonQv_10-20-2_test": {
-    "file": "./coordinator/non-qv/processMessages",
-    "template": "ProcessMessagesNonQv",
+  "MessageProcessorNonQv_10-20-2_test": {
+    "file": "./coordinator/non-qv/MessageProcessor",
+    "template": "MessageProcessorNonQv",
     "params": [10, 20, 2],
     "pubs": [
       "totalSignups",
@@ -59,15 +59,15 @@
       "voteOptions"
     ]
   },
-  "TallyVotes_10-1-2_test": {
-    "file": "./coordinator/qv/tallyVotes",
-    "template": "TallyVotes",
+  "VoteTallyQv_10-1-2_test": {
+    "file": "./coordinator/qv/VoteTally",
+    "template": "VoteTallyQv",
     "params": [10, 1, 2],
     "pubs": ["index", "totalSignups", "sbCommitment", "currentTallyCommitment", "newTallyCommitment"]
   },
-  "TallyVotesNonQv_10-1-2_test": {
-    "file": "./coordinator/non-qv/tallyVotes",
-    "template": "TallyVotesNonQv",
+  "VoteTallyNonQv_10-1-2_test": {
+    "file": "./coordinator/non-qv/VoteTally",
+    "template": "VoteTallyNonQv",
     "params": [10, 1, 2],
     "pubs": ["index", "totalSignups", "sbCommitment", "currentTallyCommitment", "newTallyCommitment"]
   }

package/circom/coordinator/full/SingleMessageProcessor.circom

@@ -5,7 +5,6 @@ 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";
@@ -112,14 +111,13 @@ template SingleMessageProcessorFull(stateTreeDepth, voteOptionTreeDepth) {
     // 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 computedStateRoot = BinaryMerkleRoot(stateTreeDepth)(
         stateLeafHash,
         actualStateTreeDepth,
-        computedStateLeafPathIndices,
+        stateIndexMux,
         stateLeafPathElements
     );
 
@@ -130,6 +128,7 @@ template SingleMessageProcessorFull(stateTreeDepth, voteOptionTreeDepth) {
         ballot[BALLOT_NONCE_INDEX], 
         ballot[BALLOT_VOTE_OPTION_ROOT_INDEX]
     ]);
+    var computedStateLeafPathIndices[stateTreeDepth] = Num2Bits(stateTreeDepth)(stateIndexMux);
 
     var computedBallotRoot = MerkleTreeInclusionProof(stateTreeDepth)(
         computedBallot,
@@ -186,7 +185,7 @@ template SingleMessageProcessorFull(stateTreeDepth, voteOptionTreeDepth) {
     var computedNewStateRoot = BinaryMerkleRoot(stateTreeDepth)(
         computedNewStateLeafhash,
         actualStateTreeDepth,
-        computedStateLeafPathIndices,
+        stateIndexMux,
         stateLeafPathElements
     );
 

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

@@ -9,20 +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/QuinaryTreeInclusionProof.circom";
-include "../../utils/trees/QuinaryGeneratePathIndices.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
@@ -226,7 +219,7 @@ include "../../utils/trees/QuinaryGeneratePathIndices.circom";
             }
         }
 
-        (computedNewVoteStateRoot[i], computedNewVoteBallotRoot[i]) = ProcessOneNonQv(stateTreeDepth, voteOptionTreeDepth)(
+        (computedNewVoteStateRoot[i], computedNewVoteBallotRoot[i]) = SingleMessageProcessorNonQv(stateTreeDepth, voteOptionTreeDepth)(
             totalSignups,
             stateRoots[i + 1],
             ballotRoots[i + 1],
@@ -257,191 +250,3 @@ include "../../utils/trees/QuinaryGeneratePathIndices.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 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/SingleMessageProcessor.circom

@@ -0,0 +1,199 @@
+pragma circom 2.0.0;
+
+// circomlib import
+include "./mux1.circom";
+// local imports
+include "../../utils/PoseidonHasher.circom";
+include "../../utils/trees/MerkleTreeInclusionProof.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);
+
+    // 3. Verify that the original state leaf exists in the given state root.
+    var stateLeafHash = PoseidonHasher(3)(stateLeaf);
+    var stateLeafQip = BinaryMerkleRoot(stateTreeDepth)(
+        stateLeafHash,
+        actualStateTreeDepth,
+        stateIndexMux,
+        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 computedStateLeafPathIndices[stateTreeDepth] = Num2Bits(stateTreeDepth)(stateIndexMux);
+
+    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,
+        stateIndexMux,
+        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,8 +5,8 @@ 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/QuinaryCheckRoot.circom";
 include "../../utils/CalculateTotal.circom";
@@ -16,7 +16,7 @@ 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,
     tallyProcessingStateTreeDepth,
     voteOptionTreeDepth
@@ -96,7 +96,7 @@ template TallyVotesNonQv(
     }
 
     var computedBallotSubroot = CheckRoot(tallyProcessingStateTreeDepth)(computedBallotHashers);
-    var computedBallotPathIndices[STATE_TREE_DEPTH_DIFFERENCE] = MerklePathIndicesGenerator(STATE_TREE_DEPTH_DIFFERENCE)(index / batchSize);
+    var computedBallotPathIndices[STATE_TREE_DEPTH_DIFFERENCE] = Num2Bits(STATE_TREE_DEPTH_DIFFERENCE)(index / batchSize); 
 
     // Verifies each ballot's existence within the ballot tree.
     LeafExists(STATE_TREE_DEPTH_DIFFERENCE)(
@@ -159,80 +159,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 = 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]);
-
-    // 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 = 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]);
-
-    // Commit to the new tally.
-    var computedNewTallyCommitment = PoseidonHasher(2)([
-        computedNewResultsCommitment,
-        computedNewSpentVoiceCreditsCommitment
-    ]);
-    
-    computedNewTallyCommitment === newTallyCommitment;
-}