@maci-protocol/circuits 0.0.0-ci.2653bc0 → 0.0.0-ci.2d2f5fb

package/circom/coordinator/qv/processMessages.circom

@@ -5,12 +5,17 @@ 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/qv/stateLeafAndBallotTransformer.circom";
+include "../../utils/PoseidonHasher.circom";
+include "../../utils/MessageHasher.circom";
+include "../../utils/MessageToCommand.circom";
+include "../../utils/PrivateToPublicKey.circom";
+include "../../utils/qv/StateLeafAndBallotTransformer.circom";
 include "../../utils/trees/incrementalQuinaryTree.circom";
-include "../../utils/trees/incrementalMerkleTree.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";
 
 /**
  * Proves the correctness of processing a batch of MACI messages.
@@ -30,32 +35,31 @@ template ProcessMessages(
     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).
@@ -118,10 +122,10 @@ template ProcessMessages(
     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 tree.
     var computedMessageHashers[batchSize];
@@ -131,7 +135,7 @@ template ProcessMessages(
 
     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
@@ -155,38 +159,38 @@ template ProcessMessages(
     // 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.
@@ -219,7 +223,7 @@ template ProcessMessages(
         }
         
         (computedNewVoteStateRoot[i], computedNewVoteBallotRoot[i]) = ProcessOne(stateTreeDepth, voteOptionTreeDepth)(
-            numSignUps,
+            totalSignups,
             stateRoots[i + 1],
             ballotRoots[i + 1],
             actualStateTreeDepth,
@@ -230,14 +234,14 @@ template ProcessMessages(
             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
         );
@@ -260,28 +264,26 @@ template ProcessMessages(
  */
 template ProcessOne(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.
@@ -303,16 +305,16 @@ template ProcessOne(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;
@@ -323,40 +325,40 @@ template ProcessOne(stateTreeDepth, voteOptionTreeDepth) {
     // Intermediate signals.
     // currentVoteWeight * currentVoteWeight.
     signal currentVoteWeightSquare;
-    // cmdNewVoteWeight * cmdNewVoteWeight.
-    signal cmdNewVoteWeightSquare;
-    // equal to newBallotVoRootMux (Mux1).
-    signal newBallotVoRoot;
+    // commandNewVoteWeight * commandNewVoteWeight.
+    signal commandNewVoteWeightSquare;
+    // 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) = StateLeafAndBallotTransformer()(
-        numSignUps,
+    var computedNewStateLeafPublicKey[2], computedNewBallotNonce, computedIsValid, computedIsStateLeafIndexValid, computedIsVoteOptionIndexValid;
+    (computedNewStateLeafPublicKey, computedNewBallotNonce, computedIsValid, computedIsStateLeafIndexValid, computedIsVoteOptionIndexValid) = StateLeafAndBallotTransformer()(
+        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,
@@ -368,8 +370,8 @@ template ProcessOne(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)(
@@ -381,12 +383,12 @@ template ProcessOne(stateTreeDepth, voteOptionTreeDepth) {
     computedBallotQip === currentBallotRoot;
 
     // 5. Verify that currentVoteWeight exists in the ballot's vote option root
-    // at cmdVoteOptionIndex.
+    // at commandVoteOptionIndex.
     currentVoteWeightSquare <== currentVoteWeight * currentVoteWeight;
-    cmdNewVoteWeightSquare <== cmdNewVoteWeight * cmdNewVoteWeight;
+    commandNewVoteWeightSquare <== commandNewVoteWeight * commandNewVoteWeight;
 
-    var cmdVoteOptionIndexMux = Mux1()([0, cmdVoteOptionIndex], computedIsVoteOptionIndexValid);
-    var computedCurrentVoteWeightPathIndices[voteOptionTreeDepth] = QuinGeneratePathIndices(voteOptionTreeDepth)(cmdVoteOptionIndexMux);
+    var commandVoteOptionIndexMux = Mux1()([0, commandVoteOptionIndex], computedIsVoteOptionIndexValid);
+    var computedCurrentVoteWeightPathIndices[voteOptionTreeDepth] = QuinGeneratePathIndices(voteOptionTreeDepth)(commandVoteOptionIndexMux);
 
     var computedCurrentVoteWeightQip = QuinTreeInclusionProof(voteOptionTreeDepth)(
         currentVoteWeight,
@@ -394,13 +396,13 @@ template ProcessOne(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] + currentVoteWeightSquare - cmdNewVoteWeightSquare
+            stateLeaf[STATE_LEAF_VOICE_CREDIT_BALANCE_INDEX],
+            stateLeaf[STATE_LEAF_VOICE_CREDIT_BALANCE_INDEX] + currentVoteWeightSquare - commandNewVoteWeightSquare
         ],
         computedIsValid
     );
@@ -413,23 +415,22 @@ template ProcessOne(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(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
@@ -438,7 +439,7 @@ template ProcessOne(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,
@@ -447,3 +448,4 @@ template ProcessOne(stateTreeDepth, voteOptionTreeDepth) {
 
     newBallotRoot <== computedNewBallotQip;
 }
+

package/circom/coordinator/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/CheckRoot.circom";
+include "../../utils/trees/MerklePathIndicesGenerator.circom";
+include "../../utils/trees/LeafExists.circom";
 include "../../utils/trees/incrementalQuinaryTree.circom";
-include "../../utils/calculateTotal.circom";
-include "../../utils/hashers.circom";
+include "../../utils/CalculateTotal.circom";
+include "../../utils/PoseidonHasher.circom";
 
 /**
  * Processes batches of votes and verifies their validity in a Merkle tree structure.
@@ -33,16 +35,16 @@ template TallyVotes(
     // 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;
@@ -59,13 +61,13 @@ template TallyVotes(
     // 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.
@@ -73,13 +75,13 @@ template TallyVotes(
     // Salt for the total spent voice credits.
     signal input currentSpentVoiceCreditSubtotalSalt;
     // Spent voice credits per vote option.
-    signal input currentPerVOSpentVoiceCredits[numVoteOptions];
+    signal input currentPerVoteOptionSpentVoiceCredits[totalVoteOptions];
     // Salt for the root of spent credits per option.
-    signal input currentPerVOSpentVoiceCreditsRootSalt;
+    signal input currentPerVoteOptionSpentVoiceCreditsRootSalt;
     // Salt for the root of the new results.
     signal input newResultsRootSalt;
     // Salt for the new spent credits per vote option root.
-    signal input newPerVOSpentVoiceCreditsRootSalt;
+    signal input newPerVoteOptionSpentVoiceCreditsRootSalt;
     // Salt for the new total spent voice credits root. 
     signal input newSpentVoiceCreditSubtotalSalt;
 
@@ -88,21 +90,21 @@ template TallyVotes(
     computedSbCommitment === sbCommitment;
 
     // 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,
@@ -113,7 +115,7 @@ template TallyVotes(
     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.
@@ -121,8 +123,8 @@ template TallyVotes(
     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 numsRC[batchSize + 1];
         numsRC[batchSize] = currentResults[i] * computedIsZero;
         for (var j = 0; j < batchSize; j++) {
@@ -133,27 +135,27 @@ template TallyVotes(
     }
 
     // Tally the new spent voice credit total.
-    var numsSVC[batchSize * numVoteOptions + 1];
-    numsSVC[batchSize * numVoteOptions] = currentSpentVoiceCreditSubtotal * computedIsZero;
+    var numsSVC[batchSize * totalVoteOptions + 1];
+    numsSVC[batchSize * totalVoteOptions] = currentSpentVoiceCreditSubtotal * computedIsZero;
     for (var i = 0; i < batchSize; i++) {
-        for (var j = 0; j < numVoteOptions; j++) {
-            numsSVC[i * numVoteOptions + j] = votes[i][j] * votes[i][j];
+        for (var j = 0; j < totalVoteOptions; j++) {
+            numsSVC[i * totalVoteOptions + j] = votes[i][j] * votes[i][j];
         }
     }
 
-    var computedNewSpentVoiceCreditSubtotal = CalculateTotal(batchSize * numVoteOptions + 1)(numsSVC);
+    var computedNewSpentVoiceCreditSubtotal = CalculateTotal(batchSize * totalVoteOptions + 1)(numsSVC);
 
     // Tally the spent voice credits per vote option.
-    var computedNewPerVOSpentVoiceCredits[numVoteOptions];
+    var computedNewPerVOSpentVoiceCredits[totalVoteOptions];
 
-    for (var i = 0; i < numVoteOptions; i++) {
-        var computedNumsSVC[batchSize + 1];
-        computedNumsSVC[batchSize] = currentPerVOSpentVoiceCredits[i] * computedIsZero;
+    for (var i = 0; i < totalVoteOptions; i++) {
+        var computedTotalVoiceCreditSpent[batchSize + 1];
+        computedTotalVoiceCreditSpent[batchSize] = currentPerVoteOptionSpentVoiceCredits[i] * computedIsZero;
         for (var j = 0; j < batchSize; j++) {
-            computedNumsSVC[j] = votes[j][i] * votes[j][i];
+            computedTotalVoiceCreditSpent[j] = votes[j][i] * votes[j][i];
         }
 
-        computedNewPerVOSpentVoiceCredits[i] = CalculateTotal(batchSize + 1)(computedNumsSVC);
+        computedNewPerVOSpentVoiceCredits[i] = CalculateTotal(batchSize + 1)(computedTotalVoiceCreditSpent);
     }
     
     // Verifies the updated results and spent credits, ensuring consistency and correctness of tally updates.
@@ -169,10 +171,10 @@ template TallyVotes(
         currentSpentVoiceCreditSubtotalSalt,
         computedNewSpentVoiceCreditSubtotal,
         newSpentVoiceCreditSubtotalSalt,
-        currentPerVOSpentVoiceCredits,
-        currentPerVOSpentVoiceCreditsRootSalt,
+        currentPerVoteOptionSpentVoiceCredits,
+        currentPerVoteOptionSpentVoiceCreditsRootSalt,
         computedNewPerVOSpentVoiceCredits,
-        newPerVOSpentVoiceCreditsRootSalt        
+        newPerVoteOptionSpentVoiceCreditsRootSalt        
     );
 }
 
@@ -185,7 +187,7 @@ template ResultCommitmentVerifier(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 numVoteOptions = TREE_ARITY ** voteOptionTreeDepth;
+    var totalVoteOptions = TREE_ARITY ** voteOptionTreeDepth;
 
     // Equal to 1 if this is the first batch, otherwise 0.
     signal input isFirstBatch;
@@ -195,12 +197,12 @@ template ResultCommitmentVerifier(voteOptionTreeDepth) {
     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;
 
@@ -215,14 +217,14 @@ template ResultCommitmentVerifier(voteOptionTreeDepth) {
     signal input newSpentVoiceCreditSubtotalSalt;
 
     // Spent voice credits per vote option.
-    signal input currentPerVOSpentVoiceCredits[numVoteOptions];
+    signal input currentPerVoteOptionSpentVoiceCredits[totalVoteOptions];
     // Salt for the root of spent credits per option.
-    signal input currentPerVOSpentVoiceCreditsRootSalt;
+    signal input currentPerVoteOptionSpentVoiceCreditsRootSalt;
 
     // New spent voice credits per vote option.
-    signal input newPerVOSpentVoiceCredits[numVoteOptions];
+    signal input newPerVoteOptionSpentVoiceCredits[totalVoteOptions];
     // Salt for the root of new spent credits per option.
-    signal input newPerVOSpentVoiceCreditsRootSalt;
+    signal input newPerVoteOptionSpentVoiceCreditsRootSalt;
 
     // Compute the commitment to the current results.
     var computedCurrentResultsRoot = QuinCheckRoot(voteOptionTreeDepth)(currentResults);
@@ -234,14 +236,14 @@ template ResultCommitmentVerifier(voteOptionTreeDepth) {
     var computedCurrentSpentVoiceCreditsCommitment = PoseidonHasher(2)([currentSpentVoiceCreditSubtotal, currentSpentVoiceCreditSubtotalSalt]);
 
     // Compute the root of the spent voice credits per vote option.
-    var computedCurrentPerVOSpentVoiceCreditsRoot = QuinCheckRoot(voteOptionTreeDepth)(currentPerVOSpentVoiceCredits);
-    var computedCurrentPerVOSpentVoiceCreditsCommitment = PoseidonHasher(2)([computedCurrentPerVOSpentVoiceCreditsRoot, currentPerVOSpentVoiceCreditsRootSalt]);
+    var computedCurrentPerVoteOptionSpentVoiceCreditsRoot = QuinCheckRoot(voteOptionTreeDepth)(currentPerVoteOptionSpentVoiceCredits);
+    var computedCurrentPerVoteOptionSpentVoiceCreditsCommitment = PoseidonHasher(2)([computedCurrentPerVoteOptionSpentVoiceCreditsRoot, currentPerVoteOptionSpentVoiceCreditsRootSalt]);
 
     // Commit to the current tally.
     var computedCurrentTallyCommitment = PoseidonHasher(3)([
         computedCurrentResultsCommitment, 
         computedCurrentSpentVoiceCreditsCommitment, 
-        computedCurrentPerVOSpentVoiceCreditsCommitment
+        computedCurrentPerVoteOptionSpentVoiceCreditsCommitment
     ]);
 
     // Check if the current tally commitment is correct only if this is not the first batch.
@@ -249,11 +251,11 @@ template ResultCommitmentVerifier(voteOptionTreeDepth) {
     // 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);
@@ -263,14 +265,14 @@ template ResultCommitmentVerifier(voteOptionTreeDepth) {
     var computedNewSpentVoiceCreditsCommitment = PoseidonHasher(2)([newSpentVoiceCreditSubtotal, newSpentVoiceCreditSubtotalSalt]);
 
     // Compute the root of the spent voice credits per vote option.
-    var computedNewPerVOSpentVoiceCreditsRoot = QuinCheckRoot(voteOptionTreeDepth)(newPerVOSpentVoiceCredits);
-    var computedNewPerVOSpentVoiceCreditsCommitment = PoseidonHasher(2)([computedNewPerVOSpentVoiceCreditsRoot, newPerVOSpentVoiceCreditsRootSalt]);
+    var computedNewPerVoteOptionSpentVoiceCreditsRoot = QuinCheckRoot(voteOptionTreeDepth)(newPerVoteOptionSpentVoiceCredits);
+    var computedNewPerVoteOptionSpentVoiceCreditsCommitment = PoseidonHasher(2)([computedNewPerVoteOptionSpentVoiceCreditsRoot, newPerVoteOptionSpentVoiceCreditsRootSalt]);
 
     // Commit to the new tally.
     var computedNewTallyCommitment = PoseidonHasher(3)([
         computedNewResultsCommitment,
         computedNewSpentVoiceCreditsCommitment,
-        computedNewPerVOSpentVoiceCreditsCommitment
+        computedNewPerVoteOptionSpentVoiceCreditsCommitment
     ]);
     
     computedNewTallyCommitment === newTallyCommitment;