@maci-protocol/circuits 0.0.0-ci.fb960ed → 0.0.0-ci.fd5247e

package/circom/circuits.json

@@ -16,7 +16,7 @@
     "template": "ProcessMessages",
     "params": [10, 20, 2],
     "pubs": [
-      "numSignUps",
+      "totalSignups",
       "index",
       "batchEndIndex",
       "currentSbCommitment",
@@ -32,7 +32,7 @@
     "template": "ProcessMessagesNonQv",
     "params": [10, 20, 2],
     "pubs": [
-      "numSignUps",
+      "totalSignups",
       "index",
       "batchEndIndex",
       "currentSbCommitment",
@@ -47,12 +47,12 @@
     "file": "./coordinator/qv/tallyVotes",
     "template": "TallyVotes",
     "params": [10, 1, 2],
-    "pubs": ["index", "numSignUps", "sbCommitment", "currentTallyCommitment", "newTallyCommitment"]
+    "pubs": ["index", "totalSignups", "sbCommitment", "currentTallyCommitment", "newTallyCommitment"]
   },
   "TallyVotesNonQv_10-1-2_test": {
     "file": "./coordinator/non-qv/tallyVotes",
     "template": "TallyVotesNonQv",
     "params": [10, 1, 2],
-    "pubs": ["index", "numSignUps", "sbCommitment", "currentTallyCommitment", "newTallyCommitment"]
+    "pubs": ["index", "totalSignups", "sbCommitment", "currentTallyCommitment", "newTallyCommitment"]
   }
 }

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

@@ -9,11 +9,11 @@ include "../../utils/PoseidonHasher.circom";
 include "../../utils/MessageHasher.circom";
 include "../../utils/MessageToCommand.circom";
 include "../../utils/PrivateToPublicKey.circom";
-include "../../utils/non-qv/stateLeafAndBallotTransformer.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/MerkleGeneratePathIndices.circom";
+include "../../utils/trees/MerklePathIndicesGenerator.circom";
 include "../../utils/trees/BinaryMerkleRoot.circom";
 include "../../utils/trees/incrementalQuinaryTree.circom";
 
@@ -35,27 +35,27 @@ 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 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 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 messages[batchSize][MSG_LENGTH];
+    signal input messages[batchSize][MESSAGE_LENGTH];
     // The coordinator's private key.
     signal input coordinatorPrivateKey;
     // The ECDH public key per message.
@@ -113,31 +113,28 @@ 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()(messages[i], encryptionPublicKeys[i]);
@@ -165,36 +162,36 @@ 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] = PrivateToPublicKey()(coordinatorPrivateKey);
-    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()(messages[i], coordinatorPrivateKey, encryptionPublicKeys[i]);
     }
@@ -229,7 +226,7 @@ include "../../utils/trees/incrementalQuinaryTree.circom";
         }
 
         (computedNewVoteStateRoot[i], computedNewVoteBallotRoot[i]) = ProcessOneNonQv(stateTreeDepth, voteOptionTreeDepth)(
-            numSignUps,
+            totalSignups,
             stateRoots[i + 1],
             ballotRoots[i + 1],
             actualStateTreeDepth,
@@ -240,14 +237,14 @@ include "../../utils/trees/incrementalQuinaryTree.circom";
             currentVoteWeights[i],
             currentVoteWeightsPathElement,
             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
         );
@@ -272,24 +269,24 @@ template ProcessOneNonQv(stateTreeDepth, voteOptionTreeDepth) {
     // Constants defining the structure and size of state and ballots.
     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;
-    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.
@@ -311,16 +308,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;
@@ -328,35 +325,35 @@ 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(3)(stateLeaf);
@@ -371,8 +368,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)(
@@ -384,9 +381,9 @@ 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] = QuinGeneratePathIndices(voteOptionTreeDepth)(commandVoteOptionIndexMux);
 
     var computedCurrentVoteWeightQip = QuinTreeInclusionProof(voteOptionTreeDepth)(
         currentVoteWeight,
@@ -394,13 +391,13 @@ template ProcessOneNonQv(stateTreeDepth, voteOptionTreeDepth) {
         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
     );
@@ -413,22 +410,22 @@ template ProcessOneNonQv(stateTreeDepth, voteOptionTreeDepth) {
     );
 
     // 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(3)([
-        computedNewSlPubKey[STATE_LEAF_PUB_X_IDX],
-        computedNewSlPubKey[STATE_LEAF_PUB_Y_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
@@ -437,7 +434,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,

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

@@ -6,7 +6,7 @@ include "./comparators.circom";
 include "./unpack-element.circom";
 // local imports
 include "../../utils/trees/CheckRoot.circom";
-include "../../utils/trees/MerkleGeneratePathIndices.circom";
+include "../../utils/trees/MerklePathIndicesGenerator.circom";
 include "../../utils/trees/LeafExists.circom";
 include "../../utils/trees/incrementalQuinaryTree.circom";
 include "../../utils/CalculateTotal.circom";
@@ -35,16 +35,16 @@ template TallyVotesNonQv(
     // The number of ballots processed at once, determined by the depth of the intermediate state tree.
     var batchSize = BALLOT_TREE_ARITY ** intStateTreeDepth;
     // 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_INT_TREE_DEPTH_DIFFERENCE = stateTreeDepth - intStateTreeDepth;
 
     // Root of the state Merkle tree, representing the overall state before voting.
     signal input stateRoot;
@@ -61,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_INT_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.
@@ -85,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 computedBallotPathIndices[STATE_INT_TREE_DEPTH_DIFFERENCE] = MerklePathIndicesGenerator(STATE_INT_TREE_DEPTH_DIFFERENCE)(index / batchSize);
 
     // Verifies each ballot's existence within the ballot tree.
-    LeafExists(k)(
+    LeafExists(STATE_INT_TREE_DEPTH_DIFFERENCE)(
         computedBallotSubroot,
         ballotPathElements,
         computedBallotPathIndices,
@@ -108,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] === ballots[i][BALLOT_VOTE_OPTION_ROOT_INDEX];
     }
 
     // Calculates new results and spent voice credits based on the current and incoming votes.
@@ -118,8 +119,9 @@ template TallyVotesNonQv(
     var computedIsZero = IsZero()(computedIsFirstBatch);
 
     // Tally the new results.
-    var computedCalculateTotalResult[numVoteOptions];
-    for (var i = 0; i < numVoteOptions; i++) {
+    var computedCalculateTotalResult[totalVoteOptions];
+
+    for (var i = 0; i < totalVoteOptions; i++) {
         var computedNumsRC[batchSize + 1];
         computedNumsRC[batchSize] = currentResults[i] * computedIsZero;
         for (var j = 0; j < batchSize; j++) {
@@ -130,15 +132,16 @@ template TallyVotesNonQv(
     }
 
     // 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)(
@@ -165,7 +168,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;
@@ -175,12 +178,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;
 
@@ -211,11 +214,11 @@ 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);