@maci-protocol/circuits 0.0.0-ci.2df0337 → 0.0.0-ci.2ea88a0

package/circom/coordinator/qv/VoteTallyWithIndividualCounts.circom

@@ -0,0 +1,226 @@
+pragma circom 2.0.0;
+
+// circomlib import
+include "./comparators.circom";
+// zk-kit import
+include "./unpack-element.circom";
+// local imports
+include "../../utils/trees/CheckRoot.circom";
+include "../../utils/trees/LeafExists.circom";
+include "../../utils/trees/QuinaryCheckRoot.circom";
+include "../../utils/qv/ResultCommitmentVerifier.circom";
+include "../../utils/CalculateTotal.circom";
+include "../../utils/PoseidonHasher.circom";
+
+/**
+ * Processes batches of votes and verifies their validity in a Merkle tree structure.
+ * This template supports Quadratic Voting (QV) with individual vote counting.
+ * Note: this circuit is not using right now, this is a part of individual vote counts functionality.
+ * Not finished yet, don't use it in production. It is kept here for future use.
+ */
+template VoteTallyWithIndividualCountsQv(
+    stateTreeDepth,
+    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(tallyProcessingStateTreeDepth > 0);
+    // The intermediate state tree must be smaller than the full state tree.
+    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;
+    var VOTE_COUNTS_TREE_ARITY = 2;
+
+    // The number of ballots processed at once, determined by the depth of the intermediate state tree.
+    var ballotBatchSize = BALLOT_TREE_ARITY ** tallyProcessingStateTreeDepth;
+    var voteCountsBatchSize = VOTE_COUNTS_TREE_ARITY ** tallyProcessingStateTreeDepth;
+    // Number of voting options available, determined by the depth of the vote option tree.
+    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_INDEX = 0;
+    // 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_TREE_DEPTH_DIFFERENCE = stateTreeDepth - tallyProcessingStateTreeDepth;
+    // Number of elements in each vote count leaf.
+    var VOTE_COUNTS_LENGTH = 2;
+    // Index for the voting option index.
+    var VOTE_COUNTS_NONCE_INDEX = 0;
+    // Index for root of the vote count per option.
+    var VOTE_COUNTS_ROOT_INDEX = 1;
+
+    // Root of the state Merkle tree, representing the overall state before voting.
+    signal input stateRoot;
+    // Root of the ballot Merkle tree, representing the submitted ballots.
+    signal input ballotRoot;
+    // Root of the vote counts Merkle tree, representing the counts of votes for each option.
+    signal input voteCountsRoot;
+    // Salt used in commitment to secure the ballot data.
+    signal input sbSalt;
+    // Commitment to the state and ballots.
+    signal input sbCommitment;
+    // Commitment to the current tally before this batch.
+    signal input currentTallyCommitment;
+    // Commitment to the new tally after processing this batch.
+    signal input newTallyCommitment;
+    // Start index of given batch
+    signal input index;
+    // Number of users that signup
+    signal input totalSignups;
+    // Ballots and their corresponding path elements for verification in the tree.
+    signal input ballots[ballotBatchSize][BALLOT_LENGTH];
+    signal input ballotPathElements[STATE_TREE_DEPTH_DIFFERENCE][BALLOT_TREE_ARITY - 1];
+    signal input votes[ballotBatchSize][totalVoteOptions];
+    // Individual vote count tree and their corresponding path elements for verification in the tree.
+    signal input voteCounts[voteCountsBatchSize][VOTE_COUNTS_LENGTH];
+    signal input voteCountsPathElements[STATE_TREE_DEPTH_DIFFERENCE][VOTE_COUNTS_TREE_ARITY - 1];
+    signal input voteCountsData[voteCountsBatchSize][totalVoteOptions];
+    // Current results for each vote option.
+    signal input currentResults[totalVoteOptions];
+    // Salt for the root of the current results.
+    signal input currentResultsRootSalt;
+    // Total voice credits spent so far.
+    signal input currentSpentVoiceCreditSubtotal;
+    // Salt for the total spent voice credits.
+    signal input currentSpentVoiceCreditSubtotalSalt;
+    // Spent voice credits per vote option.
+    signal input currentPerVoteOptionSpentVoiceCredits[totalVoteOptions];
+    // Salt for the root of spent credits per option.
+    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 newPerVoteOptionSpentVoiceCreditsRootSalt;
+    // Salt for the new total spent voice credits root. 
+    signal input newSpentVoiceCreditSubtotalSalt;
+
+    // Verify sbCommitment.
+    var computedSbCommitment = PoseidonHasher(3)([stateRoot, ballotRoot, sbSalt]);
+    computedSbCommitment === sbCommitment;
+
+    // Validates that the index is within the valid range of sign-ups.
+    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[ballotBatchSize];
+    var computedVoteCountsHashers[voteCountsBatchSize];
+    
+    for (var i = 0; i < ballotBatchSize; i++) {
+        computedBallotHashers[i] = PoseidonHasher(2)([
+            ballots[i][BALLOT_NONCE_INDEX],
+            ballots[i][BALLOT_VOTE_OPTION_ROOT_INDEX]
+        ]);
+    }
+
+    for (var i = 0; i < voteCountsBatchSize; i++) {
+        computedVoteCountsHashers[i] = PoseidonHasher(2)([
+            voteCounts[i][VOTE_COUNTS_NONCE_INDEX],
+            voteCounts[i][VOTE_COUNTS_ROOT_INDEX]
+        ]);
+    }
+
+    var computedBallotSubroot = CheckRoot(tallyProcessingStateTreeDepth)(computedBallotHashers);
+    var computedBallotPathIndices[STATE_TREE_DEPTH_DIFFERENCE] = Num2Bits(STATE_TREE_DEPTH_DIFFERENCE)(index / ballotBatchSize);
+
+    var computedVoteCountsSubroot = CheckRoot(tallyProcessingStateTreeDepth)(computedVoteCountsHashers);
+    var computedVoteCountsPathIndices[STATE_TREE_DEPTH_DIFFERENCE] = Num2Bits(STATE_TREE_DEPTH_DIFFERENCE)(index / voteCountsBatchSize);
+
+    // Verifies each ballot's existence within the ballot tree.
+    LeafExists(STATE_TREE_DEPTH_DIFFERENCE)(
+        computedBallotSubroot,
+        ballotPathElements,
+        computedBallotPathIndices,
+        ballotRoot
+    );
+
+    // Verifies each vote count's existence within the vote count tree.
+    LeafExists(STATE_TREE_DEPTH_DIFFERENCE)(
+        computedVoteCountsSubroot,
+        voteCountsPathElements,
+        computedVoteCountsPathIndices,
+        voteCountsRoot
+    );
+
+    // Processes vote options, verifying each against its declared root.
+    var computedVoteTree[ballotBatchSize];
+
+    for (var i = 0; i < ballotBatchSize; i++) {
+        computedVoteTree[i] = QuinaryCheckRoot(voteOptionTreeDepth)(votes[i]);
+        computedVoteTree[i] === ballots[i][BALLOT_VOTE_OPTION_ROOT_INDEX];
+    }
+
+    // Processes vote counts, verifying each against its declared root.
+    var computedVoteCountsTree[voteCountsBatchSize];
+
+    for (var i = 0; i < voteCountsBatchSize; i++) {
+        computedVoteCountsTree[i] = QuinaryCheckRoot(voteOptionTreeDepth)(voteCountsData[i]);
+        computedVoteCountsTree[i] === voteCounts[i][VOTE_COUNTS_ROOT_INDEX];
+    }
+
+    // Calculates new results and spent voice credits based on the current and incoming votes.
+    var computedIsFirstBatch = IsZero()(index);
+    var computedIsZero = IsZero()(computedIsFirstBatch);
+
+    // Tally the new results.
+    var computedCalculateTotalResult[totalVoteOptions];
+    for (var i = 0; i < totalVoteOptions; i++) {
+        var numsRC[ballotBatchSize + 1];
+        numsRC[ballotBatchSize] = currentResults[i] * computedIsZero;
+        for (var j = 0; j < ballotBatchSize; j++) {
+            numsRC[j] = votes[j][i];
+        }
+
+        computedCalculateTotalResult[i] = CalculateTotal(ballotBatchSize + 1)(numsRC);
+    }
+
+    // Tally the new spent voice credit total.
+    var numsSVC[ballotBatchSize * totalVoteOptions + 1];
+    numsSVC[ballotBatchSize * totalVoteOptions] = currentSpentVoiceCreditSubtotal * computedIsZero;
+    for (var i = 0; i < ballotBatchSize; i++) {
+        for (var j = 0; j < totalVoteOptions; j++) {
+            numsSVC[i * totalVoteOptions + j] = votes[i][j] * votes[i][j];
+        }
+    }
+
+    var computedNewSpentVoiceCreditSubtotal = CalculateTotal(ballotBatchSize * totalVoteOptions + 1)(numsSVC);
+
+    // Tally the spent voice credits per vote option.
+    var computedNewPerVOSpentVoiceCredits[totalVoteOptions];
+
+    for (var i = 0; i < totalVoteOptions; i++) {
+        var computedTotalVoiceCreditSpent[ballotBatchSize + 1];
+        computedTotalVoiceCreditSpent[ballotBatchSize] = currentPerVoteOptionSpentVoiceCredits[i] * computedIsZero;
+        for (var j = 0; j < ballotBatchSize; j++) {
+            computedTotalVoiceCreditSpent[j] = votes[j][i] * votes[j][i];
+        }
+
+        computedNewPerVOSpentVoiceCredits[i] = CalculateTotal(ballotBatchSize + 1)(computedTotalVoiceCreditSpent);
+    }
+    
+    // Verifies the updated results and spent credits, ensuring consistency and correctness of tally updates.
+    ResultCommitmentVerifierQv(voteOptionTreeDepth)(
+        computedIsFirstBatch,
+        currentTallyCommitment,
+        newTallyCommitment,
+        currentResults,
+        currentResultsRootSalt,
+        computedCalculateTotalResult,
+        newResultsRootSalt,
+        currentSpentVoiceCreditSubtotal,
+        currentSpentVoiceCreditSubtotalSalt,
+        computedNewSpentVoiceCreditSubtotal,
+        newSpentVoiceCreditSubtotalSalt,
+        currentPerVoteOptionSpentVoiceCredits,
+        currentPerVoteOptionSpentVoiceCreditsRootSalt,
+        computedNewPerVOSpentVoiceCredits,
+        newPerVoteOptionSpentVoiceCreditsRootSalt        
+    );
+}

package/circom/utils/CalculateTotal.circom

@@ -1,24 +1,24 @@
 pragma circom 2.0.0;
 
 /**
- * Computes the cumulative sum of an array of n input signals.
+ * Computes the cumulative sum of an array of length input signals.
  * It iterates through each input, aggregating the sum up to that point,
  * and outputs the total sum of all inputs. This template is useful for
  * operations requiring the total sum of multiple signals, ensuring the
  * final output reflects the cumulative total of the inputs provided.
  */
-template CalculateTotal(n) {
+template CalculateTotal(length) {
     // Array of values.
-    signal input nums[n];
+    signal input nums[length];
     // Total sum.
     signal output sum;
 
-    signal sums[n];
+    signal sums[length];
     sums[0] <== nums[0];
 
-    for (var i = 1; i < n; i++) {
+    for (var i = 1; i < length; i++) {
         sums[i] <== sums[i - 1] + nums[i];
     }
 
-    sum <== sums[n - 1];
+    sum <== sums[length - 1];
 }

package/circom/utils/EdDSAPoseidonVerifier.circom

@@ -9,6 +9,7 @@ include "./escalarmulany.circom";
 include "./escalarmulfix.circom";
 // local imports
 include "./PoseidonHasher.circom";
+include "./IsOnCurve.circom";
 
 /**
  * Variant of the EdDSAPoseidonVerifier template from circomlib
@@ -37,9 +38,13 @@ template EdDSAPoseidonVerifier() {
     // Output signal for the validity of the signature.
     signal output isValid;
 
+    // Verify the public key and signature point are on the BabyJubJub curve.
+    var computedIsPkOnCurve = IsOnCurve()(publicKeyX, publicKeyY);
+    var computedIsSpOnCurve = IsOnCurve()(signaturePointX, signaturePointY);
+
     // Ensure signatureScalar<Subgroup Order.
     // convert the signature scalar signatureScalar into its binary representation.
-    var computedNum2Bits[254] = Num2Bits(254)(signatureScalar);
+    var computedNum2Bits[254] = Num2Bits_strict()(signatureScalar);
 
     var computedCompConstantIn[254] = computedNum2Bits;
     computedCompConstantIn[253] = 0;
@@ -82,10 +87,10 @@ template EdDSAPoseidonVerifier() {
     // Components to handle edge cases and ensure that all conditions 
     // for a valid signature are met, including the 
     // public key not being zero and other integrity checks.
-    var computedIsAxZero = IsZero()(publicKeyX);
+    var computedIsAxZero = IsZero()(computedDouble3XOut);
     var computedIsAxEqual = IsEqual()([computedIsAxZero, 0]);
     var computedIsCcZero = IsZero()(computedCompConstant);
-    var computedIsValid = IsEqual()([computedIsLeftRightValid + computedIsAxEqual + computedIsCcZero, 3]);
+    var computedIsValid = IsEqual()([computedIsLeftRightValid + computedIsAxEqual + computedIsCcZero + computedIsPkOnCurve + computedIsSpOnCurve, 5]);
 
     isValid <== computedIsValid;
 }

package/circom/utils/IsOnCurve.circom

@@ -0,0 +1,40 @@
+pragma circom 2.0.0;
+
+// zk-kit imports
+include "./comparators.circom";
+
+/**
+ * Returns 0 or 1 depending on if the point is on the BabyJubJub curve or not. The point is on the
+ * BabyJubJub curve if the following equation is true: a*x^2 + y^2 == 1 + d*x^2*y^2
+ * This template is identical to the BabyCheck template from circomlib, but it returns 0 or 1
+ * instead of having a hard constraint.
+ * Based on: https://github.com/iden3/circomlib/blob/master/circuits/babyjub.circom
+ */
+template IsOnCurve() {
+    // x coordinate of the point on the BabyJubJub curve.
+    signal input x;
+    // y coordinate of the point on the BabyJubJub curve.
+    signal input y;
+    // True when the point (x, y) satisfies the BabyJubJub curve equation.
+    signal output isValid;
+
+    // x^2 and y^2 intermediate values.
+    signal x2;
+    signal y2;
+    // x^2 * y^2 intermediate value.
+    signal x2y2;
+
+    // BabyJubJub curve parameters.
+    var a = 168700;
+    var d = 168696;
+
+    // Compute x^2 and y^2.
+    x2 <== x * x;
+    y2 <== y * y;
+
+    // Compute x^2 * y^2.
+    x2y2 <== x2 * y2;
+
+    // Check if a*x^2 + y^2 == 1 + d*x^2*y^2.
+    isValid <== IsEqual()([a * x2 + y2, 1 + d * x2y2]);
+}

package/circom/utils/PrivateToPublicKey.circom

@@ -29,10 +29,10 @@ template PrivateToPublicKey() {
     isLessThan === 1;
 
     // Convert the private key to bits.
-    var computedPrivBits[253] = Num2Bits(253)(privateKey);
+    var computedPrivateBits[253] = Num2Bits(253)(privateKey);
 
     // Perform scalar multiplication with the basepoint.
-    var computedEscalarMulFix[2] = EscalarMulFix(253, BASE8)(computedPrivBits);
+    var computedPublicKey[2] = EscalarMulFix(253, BASE8)(computedPrivateBits);
 
-    publicKey <== computedEscalarMulFix;
+    publicKey <== computedPublicKey;
 }

package/circom/utils/full/MessageValidator.circom

@@ -0,0 +1,91 @@
+pragma circom 2.0.0;
+
+// zk-kit imports
+include "./safe-comparators.circom";
+// local imports
+include "../VerifySignature.circom";
+
+/**
+ * Checks if a MACI message is valid or not.
+ * This template supports the full mode (all credits are spent on one option)
+ */
+template MessageValidatorFull() {
+    // Length of the packed command.
+    var PACKED_COMMAND_LENGTH = 4;
+    // Number of checks to be performed.
+    var TOTAL_CHECKS = 5;
+
+    // State index of the user.
+    signal input stateTreeIndex;
+    // Number of user sign-ups in the state tree.
+    signal input totalSignups;
+    // Vote option index.
+    signal input voteOptionIndex;
+    // Number of valid vote options for the poll.
+    signal input voteOptions;
+    // Ballot nonce.
+    signal input originalNonce;
+    // Command nonce.
+    signal input commandNonce;
+    // Packed command.
+    signal input command[PACKED_COMMAND_LENGTH];
+    // Public key of the state leaf (user).
+    signal input publicKey[2];
+    // EdDSA signature of the command (R part).
+    signal input signaturePoint[2];
+    // EdDSA signature of the command (S part).
+    signal input signatureScalar;
+    // State leaf current voice credit balance.
+    signal input currentVoiceCreditBalance;
+    // Current number of votes for specific option. 
+    signal input currentVotesForOption;
+    // Vote weight.
+    signal input voteWeight;
+
+    // True when the command is valid; otherwise false.
+    signal output isValid;
+    // True if the state leaf index is valid
+    signal output isStateLeafIndexValid;
+    // True if the vote option index is valid
+    signal output isVoteOptionIndexValid;
+
+    // Check (1) - The state leaf index must be valid.
+    // The check ensure that the stateTreeIndex < totalSignups as first validation.
+    // Must be < because the stateTreeIndex is 0-based. Zero is for blank state leaf
+    // while 1 is for the first actual user.
+    var computedIsStateLeafIndexValid = SafeLessThan(252)([stateTreeIndex, totalSignups]);
+
+    // Check (2) - The vote option index must be less than the number of valid vote options (0 indexed).
+    var computedIsVoteOptionIndexValid = SafeLessThan(252)([voteOptionIndex, voteOptions]);
+
+    // Check (3) - The nonce must be correct.    
+    var computedIsNonceValid = IsEqual()([originalNonce + 1, commandNonce]);
+
+    // Check (4) - The signature must be correct.    
+    var computedIsSignatureValid = VerifySignature()(publicKey, signaturePoint, signatureScalar, command);
+ 
+    // Check (5) - There must be sufficient voice credits.
+    // The check ensure that currentVotesForOption + currentVoiceCreditBalance is equal to voteWeight.
+    var computedAreVoiceCreditsSpent = IsEqual()(
+        [
+            currentVotesForOption + currentVoiceCreditBalance,
+            voteWeight
+        ]
+    );
+
+    // When all five checks are correct, then isValid = 1.
+    var computedIsUpdateValid = IsEqual()(
+        [
+            TOTAL_CHECKS,
+            computedIsSignatureValid + 
+            computedAreVoiceCreditsSpent +
+            computedIsNonceValid +
+            computedIsStateLeafIndexValid +
+            computedIsVoteOptionIndexValid
+        ]
+    );
+
+    isValid <== computedIsUpdateValid;
+    isStateLeafIndexValid <== computedIsStateLeafIndexValid;
+    isVoteOptionIndexValid <== computedIsVoteOptionIndexValid;
+}

package/circom/utils/full/StateLeafAndBallotTransformer.circom

@@ -0,0 +1,127 @@
+pragma circom 2.0.0;
+
+// circomlib import
+include "./mux1.circom";
+// local import
+include "./MessageValidator.circom";
+
+/**
+ * Processes a command by verifying its validity and updates the state leaf and ballot accordingly. 
+ * If the message is correct, updates the public key in the state leaf and the nonce 
+ * in the ballot using multiplexer components.
+ * This template supports the full mode (all credits are spent on one option)
+ */
+template StateLeafAndBallotTransformerFull() {
+    // Length of the packed command.
+    var PACKED_COMMAND_LENGTH = 4;
+
+    // Number of user sign-ups in the state tree.
+    signal input totalSignups;
+    // Number of valid vote options for the poll.
+    signal input voteOptions;
+
+    // The following signals represents a state leaf (signed up user).
+    // Public key.
+    signal input stateLeafPublicKey[2];
+    // Current voice credit balance.
+    signal input stateLeafVoiceCreditBalance;
+
+    // The following signals represents a ballot.
+    // Nonce.
+    signal input ballotNonce;
+    // Current number of votes for specific option. 
+    signal input ballotCurrentVotesForOption;
+
+    // The following signals represents a command.
+    // State index of the user.
+    signal input commandStateIndex;
+    // Public key of the user.
+    signal input commandPublicKey[2];
+    // Vote option index.
+    signal input commandVoteOptionIndex;
+    // Vote weight.
+    signal input commandNewVoteWeight;
+    // Nonce.
+    signal input commandNonce;
+    // Poll identifier.
+    signal input commandPollId;
+    // Salt.
+    signal input commandSalt;
+    // EdDSA signature of the command (R part).
+    signal input commandSignaturePoint[2];
+    // EdDSA signature of the command (S part).
+    signal input commandSignatureScalar;
+    // Packed command. 
+    // nb. we are assuming that the packedCommand is always valid.
+    signal input packedCommand[PACKED_COMMAND_LENGTH];
+
+    // New state leaf (if the command is valid).
+    signal output newStateLeafPublicKey[2];
+    // New ballot (if the command is valid).
+    signal output newBallotNonce;
+    
+    // True when the command is valid; otherwise false.
+    signal output isValid;
+    // True if the state leaf index is valid
+    signal output isStateLeafIndexValid;
+    // True if the vote option index is valid
+    signal output isVoteOptionIndexValid;
+
+    // Check if the command / message is valid.
+    var (
+        computedIsValid,
+        computedIsStateLeafIndexValid,
+        computedIsVoteOptionIndexValid
+    ) = MessageValidatorFull()(
+        commandStateIndex,
+        totalSignups,
+        commandVoteOptionIndex,
+        voteOptions,
+        ballotNonce,
+        commandNonce,
+        packedCommand,
+        stateLeafPublicKey,
+        commandSignaturePoint,
+        commandSignatureScalar,
+        stateLeafVoiceCreditBalance,
+        ballotCurrentVotesForOption,
+        commandNewVoteWeight
+    );
+
+    // If the message is valid then we swap out the public key.
+    // This means using a Mux1() for publicKey[0] and another one
+    // for publicKey[1].
+    var computedNewstateLeafPublicKey0Mux = Mux1()(
+        [
+            stateLeafPublicKey[0],
+            commandPublicKey[0]
+        ],
+        computedIsValid
+    );
+
+    var computedNewstateLeafPublicKey1Mux = Mux1()(
+        [
+            stateLeafPublicKey[1],
+            commandPublicKey[1]
+        ],
+        computedIsValid
+    );
+
+    newStateLeafPublicKey[0] <== computedNewstateLeafPublicKey0Mux;
+    newStateLeafPublicKey[1] <== computedNewstateLeafPublicKey1Mux;
+
+    // If the message is valid, then we swap out the ballot nonce
+    // using a Mux1().
+    var computedNewBallotNonceMux = Mux1()([ballotNonce, commandNonce], computedIsValid);
+
+    newBallotNonce <== computedNewBallotNonceMux;
+
+    isValid <== computedIsValid;
+    isStateLeafIndexValid <== computedIsStateLeafIndexValid;
+    isVoteOptionIndexValid <== computedIsVoteOptionIndexValid;
+
+    // Constrain commandPollId and commandSalt using dummy squares.
+    // This binds the proof to a specific poll and salt.
+    signal commandPollIdSquare <== commandPollId * commandPollId;
+    signal commandSaltSquared <== commandSalt * commandSalt;
+}

package/circom/utils/non-qv/{messageValidator.circom → MessageValidator.circom}

@@ -11,12 +11,14 @@ include "../VerifySignature.circom";
  */
 template MessageValidatorNonQv() {
     // Length of the packed command.
-    var PACKED_CMD_LENGTH = 4;
+    var PACKED_COMMAND_LENGTH = 4;
+    // Number of checks to be performed.
+    var TOTAL_CHECKS = 5;
 
     // State index of the user.
     signal input stateTreeIndex;
     // Number of user sign-ups in the state tree.
-    signal input numSignUps;
+    signal input totalSignups;
     // Vote option index.
     signal input voteOptionIndex;
     // Number of valid vote options for the poll.
@@ -24,15 +26,15 @@ template MessageValidatorNonQv() {
     // Ballot nonce.
     signal input originalNonce;
     // Command nonce.
-    signal input nonce;
+    signal input commandNonce;
     // Packed command.
-    signal input cmd[PACKED_CMD_LENGTH];
+    signal input command[PACKED_COMMAND_LENGTH];
     // Public key of the state leaf (user).
     signal input publicKey[2];
-    // ECDSA signature of the command (R part).
-    signal input sigR8[2];
-    // ECDSA signature of the command (S part).
-    signal input sigS;
+    // EdDSA signature of the command (R part).
+    signal input signaturePoint[2];
+    // EdDSA signature of the command (S part).
+    signal input signatureScalar;
     // State leaf current voice credit balance.
     signal input currentVoiceCreditBalance;
     // Current number of votes for specific option. 
@@ -48,19 +50,19 @@ template MessageValidatorNonQv() {
     signal output isVoteOptionIndexValid;
 
     // Check (1) - The state leaf index must be valid.
-    // The check ensure that the stateTreeIndex < numSignUps as first validation.
+    // The check ensure that the stateTreeIndex < totalSignups as first validation.
     // Must be < because the stateTreeIndex is 0-based. Zero is for blank state leaf
     // while 1 is for the first actual user.
-    var computedIsStateLeafIndexValid = SafeLessThan(252)([stateTreeIndex, numSignUps]);
+    var computedIsStateLeafIndexValid = SafeLessThan(252)([stateTreeIndex, totalSignups]);
 
     // Check (2) - The vote option index must be less than the number of valid vote options (0 indexed).
     var computedIsVoteOptionIndexValid = SafeLessThan(252)([voteOptionIndex, voteOptions]);
 
     // Check (3) - The nonce must be correct.    
-    var computedIsNonceValid = IsEqual()([originalNonce + 1, nonce]);
+    var computedIsNonceValid = IsEqual()([originalNonce + 1, commandNonce]);
 
     // Check (4) - The signature must be correct.    
-    var computedIsSignatureValid = VerifySignature()(publicKey, sigR8, sigS, cmd);
+    var computedIsSignatureValid = VerifySignature()(publicKey, signaturePoint, signatureScalar, command);
  
     // Check (5) - There must be sufficient voice credits.
     // The check ensure that currentVoiceCreditBalance + (currentVotesForOption) >= (voteWeight).
@@ -74,7 +76,7 @@ template MessageValidatorNonQv() {
     // When all five checks are correct, then isValid = 1.
     var computedIsUpdateValid = IsEqual()(
         [
-            5,
+            TOTAL_CHECKS,
             computedIsSignatureValid + 
             computedAreVoiceCreditsSufficient +
             computedIsNonceValid +