@maci-protocol/circuits 0.0.0-ci.f4bc8a6 → 0.0.0-ci.f5db322

package/circom/utils/{privToPubKey.circom → PrivateToPublicKey.circom}

@@ -9,28 +9,30 @@ include "./escalarmulfix.circom";
  * Converts a private key to a public key on the BabyJubJub curve.
  * The input private key needs to be hashed and then pruned before.
  */
-template PrivToPubKey() {
+template PrivateToPublicKey() {
     // The base point of the BabyJubJub curve.
     var BASE8[2] = [
         5299619240641551281634865583518297030282874472190772894086521144482721001553,
         16950150798460657717958625567821834550301663161624707787222815936182638968203
     ];
 
-    // Prime subgroup order 'l'.
-    var l = 2736030358979909402780800718157159386076813972158567259200215660948447373041;
+    // The prime subgroup order.
+    var SUBGROUP_ORDER = 2736030358979909402780800718157159386076813972158567259200215660948447373041;
 
-    signal input privKey;
-    signal output pubKey[2];
+    // The private key
+    signal input privateKey;
+    // The public key
+    signal output publicKey[2];
 
-    // Check if private key is in the prime subgroup order 'l'
-    var isLessThan = LessThan(251)([privKey, l]);
+    // Check if private key is in the prime subgroup order
+    var isLessThan = LessThan(251)([privateKey, SUBGROUP_ORDER]);
     isLessThan === 1;
 
     // Convert the private key to bits.
-    var computedPrivBits[253] = Num2Bits(253)(privKey);
+    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);
 
-    pubKey <== computedEscalarMulFix;
+    publicKey <== computedPublicKey;
 }

package/circom/utils/VerifySignature.circom

@@ -0,0 +1,39 @@
+pragma circom 2.0.0;
+
+// local imports
+include "./EdDSAPoseidonVerifier.circom";
+include "./PoseidonHasher.circom";
+
+/**
+ * Verifies the EdDSA signature for a given command, which has exactly four elements in the hash preimage.
+ */
+template VerifySignature() {
+    // Number of elements in the hash preimage.
+    var PRE_IMAGE_LENGTH = 4;
+
+    // Public key of the signer, consisting of two coordinates [x, y].
+    signal input publicKey[2];
+    // signaturePoint point from the signature, consisting of two coordinates [x, y]. 
+    signal input signaturePoint[2];
+    // Scalar component of the signature.
+    signal input signatureScalar;
+    // The preimage data that was hashed, an array of four elements.
+    signal input preimage[PRE_IMAGE_LENGTH];
+    // The validity of the signature.
+    signal output isValid;
+
+    // Hash the preimage using the Poseidon hashing function configured for four inputs.
+    var computedPreimage = PoseidonHasher(4)(preimage);
+
+    // Instantiate the patched EdDSA Poseidon verifier with the necessary inputs.
+    var computedIsValid = EdDSAPoseidonVerifier()(
+        publicKey[0],
+        publicKey[1],
+        signatureScalar,
+        signaturePoint[0],
+        signaturePoint[1],
+        computedPreimage
+    );
+
+    isValid <== computedIsValid;
+}

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 → MessageValidator.circom}

@@ -3,7 +3,7 @@ pragma circom 2.0.0;
 // zk-kit imports
 include "./safe-comparators.circom";
 // local imports
-include "../verifySignature.circom";
+include "../VerifySignature.circom";
 
 /**
  * Checks if a MACI message is valid or not.
@@ -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 pubKey[2];
-    // ECDSA signature of the command (R part).
-    signal input sigR8[2];
-    // ECDSA signature of the command (S part).
-    signal input sigS;
+    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. 
@@ -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()(pubKey, 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 +

package/circom/utils/non-qv/{stateLeafAndBallotTransformer.circom → StateLeafAndBallotTransformer.circom}

@@ -3,7 +3,7 @@ pragma circom 2.0.0;
 // circomlib import
 include "./mux1.circom";
 // local import
-include "./messageValidator.circom";
+include "./MessageValidator.circom";
 
 /**
  * Processes a command by verifying its validity and updates the state leaf and ballot accordingly. 
@@ -13,18 +13,18 @@ include "./messageValidator.circom";
  */
 template StateLeafAndBallotTransformerNonQv() {
     // Length of the packed command.
-    var PACKED_CMD_LENGTH = 4;
+    var PACKED_COMMAND_LENGTH = 4;
 
     // Number of user sign-ups in the state tree.
-    signal input numSignUps;
+    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 slPubKey[2];
+    signal input stateLeafPublicKey[2];
     // Current voice credit balance.
-    signal input slVoiceCreditBalance;
+    signal input stateLeafVoiceCreditBalance;
 
     // The following signals represents a ballot.
     // Nonce.
@@ -34,29 +34,29 @@ template StateLeafAndBallotTransformerNonQv() {
 
     // The following signals represents a command.
     // State index of the user.
-    signal input cmdStateIndex;
+    signal input commandStateIndex;
     // Public key of the user.
-    signal input cmdNewPubKey[2];
+    signal input commandPublicKey[2];
     // Vote option index.
-    signal input cmdVoteOptionIndex;
+    signal input commandVoteOptionIndex;
     // Vote weight.
-    signal input cmdNewVoteWeight;
+    signal input commandNewVoteWeight;
     // Nonce.
-    signal input cmdNonce;
+    signal input commandNonce;
     // Poll identifier.
-    signal input cmdPollId;
+    signal input commandPollId;
     // Salt.
-    signal input cmdSalt;
-    // ECDSA signature of the command (R part).
-    signal input cmdSigR8[2];
-    // ECDSA signature of the command (S part).
-    signal input cmdSigS;
+    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_CMD_LENGTH];
+    signal input packedCommand[PACKED_COMMAND_LENGTH];
 
     // New state leaf (if the command is valid).
-    signal output newSlPubKey[2];
+    signal output newStateLeafPublicKey[2];
     // New ballot (if the command is valid).
     signal output newBallotNonce;
     
@@ -68,38 +68,38 @@ template StateLeafAndBallotTransformerNonQv() {
     signal output isVoteOptionIndexValid;
 
     // Check if the command / message is valid.
-    var (computedMessageValidator, computedIsStateLeafIndexValid, computedIsVoteOptionIndexValid) = MessageValidatorNonQv()(
-        cmdStateIndex,
-        numSignUps,
-        cmdVoteOptionIndex,
+    var (computedIsValid, computedIsStateLeafIndexValid, computedIsVoteOptionIndexValid) = MessageValidatorNonQv()(
+        commandStateIndex,
+        totalSignups,
+        commandVoteOptionIndex,
         voteOptions,
         ballotNonce,
-        cmdNonce,
+        commandNonce,
         packedCommand,
-        slPubKey,
-        cmdSigR8,
-        cmdSigS,
-        slVoiceCreditBalance,
+        stateLeafPublicKey,
+        commandSignaturePoint,
+        commandSignatureScalar,
+        stateLeafVoiceCreditBalance,
         ballotCurrentVotesForOption,
-        cmdNewVoteWeight
+        commandNewVoteWeight
     );
 
     // If the message is valid then we swap out the public key.
-    // This means using a Mux1() for pubKey[0] and another one
-    // for pubKey[1].
-    var computedNewSlPubKey0Mux = Mux1()([slPubKey[0], cmdNewPubKey[0]], computedMessageValidator);
-    var computedNewSlPubKey1Mux = Mux1()([slPubKey[1], cmdNewPubKey[1]], computedMessageValidator);
+    // 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);
 
-    newSlPubKey[0] <== computedNewSlPubKey0Mux;
-    newSlPubKey[1] <== computedNewSlPubKey1Mux;
+    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, cmdNonce], computedMessageValidator);
+    var computedNewBallotNonceMux = Mux1()([ballotNonce, commandNonce], computedIsValid);
 
     newBallotNonce <== computedNewBallotNonceMux;
 
-    isValid <== computedMessageValidator;
+    isValid <== computedIsValid;
     isStateLeafIndexValid <== computedIsStateLeafIndexValid;
     isVoteOptionIndexValid <== computedIsVoteOptionIndexValid;
 }

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

@@ -3,7 +3,7 @@ pragma circom 2.0.0;
 // zk-kit imports
 include "./safe-comparators.circom";
 // local imports
-include "../verifySignature.circom";
+include "../VerifySignature.circom";
 
 /**
  * Checks if a MACI message is valid or not.
@@ -11,12 +11,14 @@ include "../verifySignature.circom";
  */
 template MessageValidator() {
     // Length of the packed command.
-    var PACKED_CMD_LENGTH = 4;
+    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 numSignUps;
+    signal input totalSignups;
     // Vote option index.
     signal input voteOptionIndex;
     // Number of valid vote options for the poll.
@@ -24,15 +26,15 @@ template MessageValidator() {
     // 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 pubKey[2];
-    // ECDSA signature of the command (R part).
-    signal input sigR8[2];
-    // ECDSA signature of the command (S part).
-    signal input sigS;
+    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. 
@@ -48,19 +50,19 @@ template MessageValidator() {
     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()(pubKey, sigR8, sigS, cmd);
+    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)
@@ -79,7 +81,7 @@ template MessageValidator() {
     // When all six checks are correct, then isValid = 1.
     var computedIsUpdateValid = IsEqual()(
         [
-            6,
+            TOTAL_CHECKS,
             computedIsSignatureValid + 
             computedAreVoiceCreditsSufficient +
             computedIsVoteWeightValid +