@maci-protocol/circuits 0.0.0-ci.00107eb

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,122 @@
+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;
+}

package/circom/utils/non-qv/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 does not support Quadratic Voting (QV).
+ */
+template MessageValidatorNonQv() {
+    // 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 currentVoiceCreditBalance + (currentVotesForOption) >= (voteWeight).
+    var computedAreVoiceCreditsSufficient = SafeGreaterEqThan(252)(
+        [
+            currentVotesForOption + currentVoiceCreditBalance,
+            voteWeight
+        ]
+    );
+
+    // When all five checks are correct, then isValid = 1.
+    var computedIsUpdateValid = IsEqual()(
+        [
+            TOTAL_CHECKS,
+            computedIsSignatureValid + 
+            computedAreVoiceCreditsSufficient +
+            computedIsNonceValid +
+            computedIsStateLeafIndexValid +
+            computedIsVoteOptionIndexValid
+        ]
+    );
+
+    isValid <== computedIsUpdateValid;
+    isStateLeafIndexValid <== computedIsStateLeafIndexValid;
+    isVoteOptionIndexValid <== computedIsVoteOptionIndexValid;
+}

package/circom/utils/non-qv/ResultCommitmentVerifier.circom

@@ -0,0 +1,84 @@
+pragma circom 2.0.0;
+
+// circomlib import
+include "./comparators.circom";
+// local imports
+include "../trees/QuinaryCheckRoot.circom";
+include "../PoseidonHasher.circom";
+
+/**
+ * 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;
+}

package/circom/utils/non-qv/StateLeafAndBallotTransformer.circom

@@ -0,0 +1,105 @@
+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 does not support Quadratic Voting (QV).
+ */
+template StateLeafAndBallotTransformerNonQv() {
+    // 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) = MessageValidatorNonQv()(
+        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;
+}

package/circom/utils/qv/MessageValidator.circom

@@ -0,0 +1,97 @@
+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 Quadratic Voting (QV).
+ */
+template MessageValidator() {
+    // Length of the packed command.
+    var PACKED_COMMAND_LENGTH = 4;
+    // Number of checks to be performed.
+    var TOTAL_CHECKS = 6;
+
+    // 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 the voteWeight is < sqrt(field size)
+    // so that voteWeight ^ 2 will not overflow.
+    var computedIsVoteWeightValid = SafeLessEqThan(252)([voteWeight, 147946756881789319005730692170996259609]);
+
+    // Check (6) - Check the current voice credit balance.
+    // The check ensure that currentVoiceCreditBalance + (currentVotesForOption ** 2) >= (voteWeight ** 2)
+    var computedAreVoiceCreditsSufficient = SafeGreaterEqThan(252)(
+        [
+            (currentVotesForOption * currentVotesForOption) + currentVoiceCreditBalance,
+            voteWeight * voteWeight
+        ]
+    );
+
+    // When all six checks are correct, then isValid = 1.
+    var computedIsUpdateValid = IsEqual()(
+        [
+            TOTAL_CHECKS,
+            computedIsSignatureValid + 
+            computedAreVoiceCreditsSufficient +
+            computedIsVoteWeightValid +
+            computedIsNonceValid +
+            computedIsStateLeafIndexValid +
+            computedIsVoteOptionIndexValid
+        ]
+    );
+
+    isValid <== computedIsUpdateValid;
+    isStateLeafIndexValid <== computedIsStateLeafIndexValid;
+    isVoteOptionIndexValid <== computedIsVoteOptionIndexValid;
+}