@maci-protocol/website 0.0.0-ci.fd7cff6 → 0.0.0-ci.ffabe48

package/versioned_docs/version-v3.x/core-concepts/spec.md

@@ -86,7 +86,7 @@ while true:
     if rand >= min:
         break
 
-privKey = rand % p
+privateKey = rand % p
 ```
 
 #### 1.3. Private key formatting
@@ -412,13 +412,13 @@ $sl = \mathsf{poseidon_4}([sl_{A_x}, sl_{A_y}, sl_{v}, sl_{t}])$
 
 A blank state leaf $sl_B$ has the following value:
 
-$6769006970205099520508948723718471724660867171122235270773600567925038008762$
+$11672248758340751985123309654953904206381780234474872690580702076708041504880$
 
 This value is computed as such:
 
 $A_{b_x} = 10457101036533406547632367118273992217979173478358440826365724437999023779287$
 $A_{b_y} = 19824078218392094440610104313265183977899662750282163392862422243483260492317$
-$sl_B = \mathsf{poseidon_4}([A_{b0}, A_{b1}, 0, 0])$
+$sl_B = \mathsf{poseidon_3}([A_{b0}, A_{b1}, 0])$
 
 The code to derive $A_{b_x}$ and $A_{b_y}$ is [here](https://github.com/iden3/circomlib/blob/d5ed1c3ce4ca137a6b3ca48bec4ac12c1b38957a/src/pedersen_printbases.js). The function call required is `pedersenHash.getBasePoint('blake', 0)`
 
@@ -550,88 +550,22 @@ To make these processes easy to use, we provide command-line interface tools.
 
 The integration tests and shell scripts in the `cli` directory provide examples of the order in which to execute them.
 
-| Command            | Description                                              | Notes                                                                                                                                        |
-| ------------------ | -------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
-| `genMaciPubkey`    | Generate a MACI public key from a private key            | Only the coordinator needs to run this, as users should generate their keys in the browser and should be automated by the client application |
-| `genMaciKeypair`   | Generates a MACI private key and public key              | Only the coordinator needs to run this, as users should generate their keys in the browser and should be automated by the client application |
-| `deployVkRegistry` | Deploy the `VkRegistry` contract                         | Executed only the coordinator                                                                                                                |
-| `setVerifyingKeys` | Set verifying keys to the `VkRegistry`                   | Executed only the coordinator                                                                                                                |
-| `create`           | Deploy a new instance of MACI                            | Executed only the coordinator                                                                                                                |
-| `deployPoll`       | Deploy a new poll on a MACI instance                     | Executed only the coordinator                                                                                                                |
-| `signup`           | Sign up a user                                           | Mainly for testing; as users are more likely to use the client application instead of the CLI                                                |
-| `publish`          | Submit a message to a poll                               | Mainly for testing; as users are more likely to use the client application instead of the CLI                                                |
-| `mergeMessages`    | Must be executed before generating proofs                | Executed only the coordinator                                                                                                                |
-| `mergeSignups`     | Must be executed before generating proofs                | Executed only the coordinator                                                                                                                |
-| `genProofs`        | Generate all message processing and vote tallying proofs | Executed only the coordinator                                                                                                                |
-| `proveOnChain`     | Submit proofs to the `PollProcessorAndTallyer` contract  | Executed only the coordinator                                                                                                                |
-
-## 5. Ethereum contracts
-
-### 5.1. MACI
-
-| Function                                                                                                   | Permissions                                                         | Notes                                                                        |
-| ---------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------- | ---------------------------------------------------------------------------- |
-| `init(VkRegistry _vkRegistry, MessageAqFactory _messageAqFactory)`                                         | Coordinator only                                                    | Initialise factory, helper and registry contracts that share equal ownership |
-| `signUp(PubKey memory _pubKey, bytes memory _signUpPolicyData, bytes memory _initialVoiceCreditProxyData)` | Executable only during the sign-up period and after initialisation  | Participant registration and voice credit assignment                         |
-| `mergeStateAqSubRoots(uint256 _numSrQueueOps, uint256 _pollId)`                                            | Executable only by poll contract `_pollId` and after initialisation | Merge queued state leaves to form the state tree subroots                    |
-| `mergeStateAq(uint256 _pollId)`                                                                            | Executable only by poll contract `_pollId` and after initialisation | Merge the state subroots to form the state root                              |
-| `getStateTreeRoot()`                                                                                       | Non-applicable                                                      | Query the state root                                                         |
-| `deployPoll(uint256 _duration, TreeDepths memory _treeDepths, PubKey memory _coordinatorPubKey)`           | Executable only after initialisation                                | Create a new poll                                                            |
-| `getPoll(uint256 _pollId)`                                                                                 | Non-applicable                                                      | Query a poll address                                                         |
-
-### 5.2. Poll
-
-| Function                                                                     | Permissions                                                                            | Notes                                                                                           |
-| ---------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------- |
-| `getDeployTimeAndDuration()`                                                 | Non-applicable                                                                         | Query the deployment timestamp and duration                                                     |
-| `numSignUpsAndMessages()`                                                    | Non-applicable                                                                         | Query the number of participants and messages cast                                              |
-| `currentSbAndTallyCommitments()`                                             | Non-applicable                                                                         | Query the current state-ballot and tally commitments hashes                                     |
-| `publishMessage(Message memory _message, PubKey memory _encPubKey)`          | Executable only during the voting period and if the message limit has not been not met | Submit a message (whether valid or not) to the message queue                                    |
-| `hashMessageAndEncPubKey(Message memory _message, PubKey memory _encPubKey)` | Non-applicable                                                                         | Query a hash of a message and public key coordinates                                            |
-| `mergeMaciStateAqSubRoots( uint256 _numSrQueueOps, uint256 _pollId)`         | Executable only by the coordinator and after the voting period                         | Merge queued state leaves to form the state subroots                                            |
-| `mergeMaciStateAq(uint256 _pollId)`                                          | Executable only by the coordinator and after the voting period                         | Merge the state subroots to form the state root and initialise the state-ballot commitment hash |
-| `mergeMessageAqSubRoots(uint256 _numSrQueueOps)`                             | Executable only by the coordinator and after the voting period                         | Merge the queued message leaves to form the message tree subroots                               |
-| `mergeMessageAq()`                                                           | Executable only by the coordinator and after the voting period                         | Merge the message tree subroots to form the message tree root                                   |
-| `batchEnqueueMessage(uint256 _messageSubRoot)`                               | Executable only by the coordinator and after the voting period                         | Submit a batch of messages to the queue                                                         |
-
-### 5.3. PollFactory
-
-| Function                                                                                                                                                                             | Permissions      | Notes                                   |
-| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------- | --------------------------------------- |
-| `setMessageAqFactory(MessageAqFactory _messageAqFactory)`                                                                                                                            | Coordinator only | Initialise the message factory contract |
-| `deploy(uint256 _duration, TreeDepths memory _treeDepths, BatchSizes memory _batchSizes, PubKey memory _coordinatorPubKey, VkRegistry _vkRegistry, IMACI _maci, address _pollOwner)` | Coordinator only | Create a new poll                       |
-
-### 5.4. VkRegistry
-
-| Function                                                                                                                                                                                                                   | Permissions      | Notes                                                                                                                                |
-| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------ |
-| `isProcessVkSet(uint256 _sig)`                                                                                                                                                                                             | Non-applicable   | Query whether a signature is valid for message processing                                                                            |
-| `isTallyVkSet(uint256 _sig)`                                                                                                                                                                                               | Non-applicable   | Query whether a signature valid for tallying votes                                                                                   |
-| `genProcessVkSig(uint256 _stateTreeDepth, uint256 _messageTreeDepth, uint256 _voteOptionTreeDepth, uint256 _messageBatchSize)`                                                                                             | Non-applicable   | Generate a signature (used for verifying key mapping lookups) for message processing by compressing parameters into a singular value |
-| `genTallyVkSig(uint256 _stateTreeDepth, uint256 _intStateTreeDepth, uint256 _voteOptionTreeDepth)`                                                                                                                         | Non-applicable   | Generate a signature (used for verifying key mapping lookups) for vote tallying by compressing parameters into a singular value      |
-| `setVerifyingKeys( uint256 _stateTreeDepth, uint256 _intStateTreeDepth, uint256 _messageTreeDepth, uint256 _voteOptionTreeDepth, uint256 _messageBatchSize, VerifyingKey memory _processVk, VerifyingKey memory _tallyVk)` | Coordinator only | Initialise verifying keys for processing and tallying to the contract alongside specifying each tree depth                           |
-| `hasProcessVk(uint256 _stateTreeDepth, uint256 _messageTreeDepth, uint256 _voteOptionTreeDepth, uint256 _messageBatchSize)`                                                                                                | Non-applicable   | Query whether the signature of the parameters is valid for message processing                                                        |
-| `getProcessVkBySig(uint256 _sig)`                                                                                                                                                                                          | Non-applicable   | Query a processing verifying key by providing a valid signature                                                                      |
-| `getProcessVk(uint256 _stateTreeDepth, uint256 _messageTreeDepth, uint256 _voteOptionTreeDepth, uint256 _messageBatchSize)`                                                                                                | Non-applicable   | Query a processing verifying key by providing parameters to generate a valid signature                                               |
-| `hasTallyVk(uint256 _stateTreeDepth, uint256 _intStateTreeDepth, uint256 _voteOptionTreeDepth)`                                                                                                                            | Non-applicable   | Query whether the signature of the parameters is valid for vote tallying                                                             |
-| `getTallyVkBySig(uint256 _sig)`                                                                                                                                                                                            | Non-applicable   | Query a tallying verifying key by providing a valid signature                                                                        |
-| `getTallyVk(uint256 _stateTreeDepth, uint256 _intStateTreeDepth, uint256 _voteOptionTreeDepth)`                                                                                                                            | Non-applicable   | Query a tallying verifying key by providing parameters to generate a valid signature                                                 |
-
-### 5.5. PollProcessorAndTallyer
-
-| Function                                                                                                                                                                              | Permissions                                                    | Notes                                                                                                        |
-| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------ |
-| `sha256Hash(uint256[] memory array)`                                                                                                                                                  | Non-applicable                                                 | Hash an array of values (using SHA256) moduluo the snark field size                                          |
-| `processMessages(Poll _poll, uint256 _newSbCommitment, uint256[8] memory _proof)`                                                                                                     | Executable only by the coordinator and after the voting period | Process state messages relative to a new state-ballot commitment given that the proof is valid               |
-| `verifyProcessProof(Poll _poll, uint256 _currentMessageBatchIndex, uint256 _messageRoot, uint256 _currentSbCommitment, uint256 _newSbCommitment, uint256[8] memory _proof)`           | Non-applicable                                                 | Query whether a message processing proof is valid                                                            |
-| `genProcessMessagesPublicInputHash(Poll _poll, uint256 _currentMessageBatchIndex, uint256 _messageRoot, uint256 _numSignUps, uint256 _currentSbCommitment, uint256 _newSbCommitment)` | Non-applicable                                                 | Hash of the coordinators public key, `packedVals`, current state-ballot commitment and message root          |
-| `genProcessMessagesPackedVals( Poll _poll, uint256 _currentMessageBatchIndex, uint256 _numSignUps)`                                                                                   | Non-applicable                                                 | Generate a packed 250-bit value `packedVals` for message processing                                          |
-| `genTallyVotesPackedVals( uint256 _numSignUps, uint256 _batchStartIndex, uint256 _tallyBatchSize)`                                                                                    | Non-applicable                                                 | Generate a packed 100-bit value `packedVals` for vote tallying                                               |
-| `genTallyVotesPublicInputHash( uint256 _numSignUps, uint256 _batchStartIndex, uint256 _tallyBatchSize, uint256 _newTallyCommitment )`                                                 | Non-applicable                                                 | Hash of the current tally commitment, the new tally commitment, `packedVals` and the state-ballot commitment |
-| `tallyVotes(Poll _poll, uint256 _newTallyCommitment, uint256[8] memory _proof)`                                                                                                       | Executable only by the coordinator and after the voting period | Tally votes relative to a new tally commitment given that the proof is valid                                 |
-| `verifyTallyProof(Poll _poll, uint256[8] memory _proof, uint256 _numSignUps, uint256 _batchStartIndex, uint256 _tallyBatchSize, uint256 _newTallyCommitment)`                         | Non-applicable                                                 | Query whether a vote tallying proof is valid                                                                 |
-
-## 6. zk-SNARKs
+| Command                       | Description                                                   | Notes                                                                                                                                        |
+| ----------------------------- | ------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
+| `generateMaciPublicKey`       | Generate a MACI public key from a private key                 | Only the coordinator needs to run this, as users should generate their keys in the browser and should be automated by the client application |
+| `generateMaciKeypair`         | Generates a MACI private key and public key                   | Only the coordinator needs to run this, as users should generate their keys in the browser and should be automated by the client application |
+| `deployVerifyingKeysRegistry` | Deploy the `deployVerifyingKeysRegistry` contract             | Executed only the coordinator                                                                                                                |
+| `setVerifyingKeys`            | Set verifying keys to the `deployVerifyingKeysRegistry`       | Executed only the coordinator                                                                                                                |
+| `create`                      | Deploy a new instance of MACI                                 | Executed only the coordinator                                                                                                                |
+| `deployPoll`                  | Deploy a new poll on a MACI instance                          | Executed only the coordinator                                                                                                                |
+| `signup`                      | Sign up a user                                                | Mainly for testing; as users are more likely to use the client application instead of the CLI                                                |
+| `publish`                     | Submit a message to a poll                                    | Mainly for testing; as users are more likely to use the client application instead of the CLI                                                |
+| `mergeMessages`               | Must be executed before generating proofs                     | Executed only the coordinator                                                                                                                |
+| `mergeSignups`                | Must be executed before generating proofs                     | Executed only the coordinator                                                                                                                |
+| `generateProofs`              | Generate all message processing and vote tallying proofs      | Executed only the coordinator                                                                                                                |
+| `proveOnChain`                | Submit proofs to the `MessageProcessor` and `Tally` contracts | Executed only the coordinator                                                                                                                |
+
+## 5. zk-SNARKs
 
 The zk-SNARK circuits in MACI are written in the [circom](https://github.com/iden3/circom) language. Proofs are [Groth16](https://eprint.iacr.org/2016/260.pdf) and are generated using the [`rapidsnark`](https://github.com/iden3/rapidsnark) prover.
 
@@ -646,15 +580,15 @@ Please note that MACI requires the coordinator to generate proofs on an x86 mach
 
 ### 6.1. Message processing circuit
 
-The message processing circuit, defined in `circuits/circom/processMessages.circom`, allows the coordinator to prove that they have correctly applied each message in reverse order, in a consecutive batch of `5 ^ msgBatchDepth` messages to the respective state leaf within the state tree.
+The message processing circuit, defined in `circuits/circom/processMessages.circom`, allows the coordinator to prove that they have correctly applied each message in reverse order, in a consecutive batch of `5 ^ messageBatchDepth` messages to the respective state leaf within the state tree.
 
 #### Parameters
 
 | Parameter             | Description                                                                                                                                                   |
 | --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `stateTreeDepth`      | Depth of the state tree, this value must be equal to `10`                                                                                                     |
-| `msgTreeDepth`        | Depth of the message tree, this must be the same value passed to the `deployPoll()` contract function of `MACI.sol`                                           |
-| `msgBatchDepth`       | Depth of a tree that exactly fits the number of messages in a batch, this must be the same value passed to the `deployPoll()` contract function of `MACI.sol` |
+| `messageTreeDepth`    | Depth of the message tree, this must be the same value passed to the `deployPoll()` contract function of `MACI.sol`                                           |
+| `messageBatchDepth`   | Depth of a tree that exactly fits the number of messages in a batch, this must be the same value passed to the `deployPoll()` contract function of `MACI.sol` |
 | `voteOptionTreeDepth` | Depth of the vote option tree, this must be the same value passed to the `deployPoll()` contract function of `MACI.sol`                                       |
 
 The state tree, message tree, and vote option trees all have an arity of 5. As such, it is possible to calculate the maximum number of signups, messages per poll, and vote options per poll.
@@ -663,17 +597,17 @@ The state tree, message tree, and vote option trees all have an arity of 5. As s
 
 | Input signal                     | Description                                                                             |
 | -------------------------------- | --------------------------------------------------------------------------------------- |
-| `numSignUps`                     | Number of users that have completed the sign up                                         |
+| `totalSignups`                   | Number of users that have completed the sign up                                         |
 | `index`                          | The batch index of current message batch                                                |
 | `pollEndTimestamp`               | The Unix timestamp at which the poll ends                                               |
-| `msgRoot`                        | The root of the message tree                                                            |
-| `msgs`                           | The batch of messages as an array of arrays                                             |
-| `msgSubrootPathElements`         | As described below                                                                      |
+| `messageRoot`                    | The root of the message tree                                                            |
+| `messages`                       | The batch of messages as an array of arrays                                             |
+| `messageSubrootPathElements`     | As described below                                                                      |
 | `coordinatorPublicKeyHash`       | $\mathsf{poseidon_2}([cPk_x, cPk_y])$                                                   |
 | `newSbCommitment`                | As described below                                                                      |
-| `coordPrivKey`                   | The coordinator's private key                                                           |
+| `coordinatorPrivateKey`          | The coordinator's private key                                                           |
 | `batchEndIndex`                  | The last batch index                                                                    |
-| `encPubKeys`                     | The public keys used to generate shared ECDH encryption keys to encrypt the messages    |
+| `encryptionPublicKeys`           | The public keys used to generate shared ECDH encryption keys to encrypt the messages    |
 | `currentStateRoot`               | The state root before the commands are applied                                          |
 | `currentStateLeaves`             | The state leaves upon which messages are applied                                        |
 | `currentStateLeavesPathElements` | The Merkle path to each incremental state root                                          |
@@ -701,9 +635,9 @@ The salt used to produce `currentSbCommitment` (see above).
 
 The salt used to produce `newSbCommitment` (see above).
 
-##### `msgSubrootPathElements`
+##### `messageSubrootPathElements`
 
-The index of each message in `msgs` is consecutive. As such, in order to prove that each message in `msgs` is indeed a leaf of the message tree, we compute the subtree root of `msgs`, and then verify that the subtree root is indeed a subroot of `msgRoot`.
+The index of each message in `messages` is consecutive. As such, in order to prove that each message in `messages` is indeed a leaf of the message tree, we compute the subtree root of `messages`, and then verify that the subtree root is indeed a subroot of `messageRoot`.
 
 A simplified example using a tree of arity 2:
 
@@ -727,9 +661,9 @@ This method requires fewer circuit constraints than if we verified a Merkle proo
 
 1. That the prover knows the preimage to `currentSbCommitment` (that is, the state root, ballot root, and `currentSbSalt`)
 2. That `maxVoteOptions <= (5 ^ voteOptionTreeDepth)`
-3. That `numSignUps <== (5 ^ stateTreeDepth)`
-4. That `coordinatorPublicKeyHash` is a hash of public key that is correctly derived from `coordPrivKey`
-5. That each message in `msgs` exists in the message tree
+3. That `totalSignups <== (5 ^ stateTreeDepth)`
+4. That `coordinatorPublicKeyHash` is a hash of public key that is correctly derived from `coordinatorPrivateKey`
+5. That each message in `messages` exists in the message tree
 6. That after decrypting and applying each message, in reverse order, to the corresponding state and ballot leaves, the new state root, new ballot root, and `newSbSalt` are the preimage to `newSbCommitment`
 
 #### How messages are decrypted and applied
@@ -817,17 +751,17 @@ The coordinator uses the ballot tallying circuit (`tallyVotes.circom`) to genera
 
 #### Parameters
 
-| Parameter             | Description                                                                                                             |
-| --------------------- | ----------------------------------------------------------------------------------------------------------------------- |
-| `stateTreeDepth`      | Depth of the state tree, this value must be equal to `10`                                                               |
-| `intStateTreeDepth`   | Depth of the intermediate state tree, `5 ** intStateTreeDepth` is the batch size                                        |
-| `voteOptionTreeDepth` | Depth of the vote option tree, this must be the same value passed to the `deployPoll()` contract function of `MACI.sol` |
+| Parameter                       | Description                                                                                                             |
+| ------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
+| `stateTreeDepth`                | Depth of the state tree, this value must be equal to `10`                                                               |
+| `tallyProcessingStateTreeDepth` | Depth of the intermediate state tree, `5 ** tallyProcessingStateTreeDepth` is the batch size                            |
+| `voteOptionTreeDepth`           | Depth of the vote option tree, this must be the same value passed to the `deployPoll()` contract function of `MACI.sol` |
 
 #### Input signals
 
 | Input signal                            | Description                                                      |
 | --------------------------------------- | ---------------------------------------------------------------- |
-| `numSignUps`                            | The number of users that signup                                  |
+| `totalSignups`                          | The number of users that signup                                  |
 | `index`                                 | Start index of given batch                                       |
 | `sbCommitment`                          | As described below                                               |
 | `currentTallyCommitment`                | As described below                                               |
@@ -874,8 +808,8 @@ $\mathsf{poseidon_3}([tc_r, tc_t, tc_p])$
 #### Statements that the circuit proves
 
 1. That the coordinator knows the preimage of `sbCommitment` (see above)
-2. That `index` is less than or equal to `numSignUps`
-3. That each ballot in `ballots` is in a member of the ballot tree with the Merkle root `ballotRoot` at indices `batchStartIndex` to `batchStartIndex + (5 ** intStateTreeDepth)`
+2. That `index` is less than or equal to `totalSignups`
+3. That each ballot in `ballots` is in a member of the ballot tree with the Merkle root `ballotRoot` at indices `batchStartIndex` to `batchStartIndex + (5 ** tallyProcessingStateTreeDepth)`
 4. That each set of votes (`votes[i]`) has the Merkle root $blt_r$ whose value equals `ballots[i][1]`
 5. That the tally is valid, which is:
    - That the sum of votes per vote option is correct

package/versioned_docs/version-v3.x/core-concepts/state-leaf.md

@@ -24,13 +24,13 @@ $sl = poseidon_4([sl_{A_x}, sl_{A_y}, sl_{v}, sl_{t}])$
 
 A blank state leaf $sl_B$ has the following value:
 
-$6769006970205099520508948723718471724660867171122235270773600567925038008762$
+$11672248758340751985123309654953904206381780234474872690580702076708041504880$
 
 This value is computed as such:
 
 $A_{b_x} = 10457101036533406547632367118273992217979173478358440826365724437999023779287$
 $A_{b_y} = 19824078218392094440610104313265183977899662750282163392862422243483260492317$
-$sl_B = poseidon_4([A_{b0}, A_{b1}, 0, 0])$
+$sl_B = poseidon_3([A_{b0}, A_{b1}, 0])$
 
 The code to derive $A_{b_x}$ and $A_{b_y}$ is [here](https://github.com/iden3/circomlib/blob/d5ed1c3ce4ca137a6b3ca48bec4ac12c1b38957a/src/pedersen_printbases.js). The function call required is `pedersenHash.getBasePoint('blake', 0)`
 

package/versioned_docs/version-v3.x/guides/compile-circuits.md

@@ -77,28 +77,28 @@ Remember that if on a ARM64 chip, you will not be able to compile the c++ witnes
 
 ### Configure circomkit
 
-Edit `circuits/circom/circuits` to include the circuits you would like to compile. This comes already configured with the two main coordinator circuits, in both qv and non qv variants, as well as the client side circuit. The parameters are designed to support testing use cases:
+Edit `circuits/circom/circuits` to include the circuits you would like to compile. This comes already configured with the main coordinator circuits, in qv, non qv and full credits variants, as well as the client side circuit. The parameters are designed to support testing use cases:
 
 ```json
 {
   "PollJoining_10_test": {
-    "file": "./anon/poll",
+    "file": "./voter/PollJoining",
     "template": "PollJoining",
     "params": [10],
-    "pubs": ["nullifier", "stateRoot", "pollPubKey", "pollId"]
+    "pubs": ["nullifier", "stateRoot", "pollPublicKey", "pollId"]
   },
   "PollJoined_10_test": {
-    "file": "./anon/poll",
+    "file": "./voter/PollJoined",
     "template": "PollJoined",
     "params": [10],
     "pubs": ["stateRoot"]
   },
   "ProcessMessages_10-20-2_test": {
-    "file": "./core/qv/processMessages",
+    "file": "./coordinator/qv/processMessages",
     "template": "ProcessMessages",
     "params": [10, 20, 2],
     "pubs": [
-      "numSignUps",
+      "totalSignups",
       "index",
       "batchEndIndex",
       "currentSbCommitment",
@@ -110,11 +110,27 @@ Edit `circuits/circom/circuits` to include the circuits you would like to compil
     ]
   },
   "ProcessMessagesNonQv_10-20-2_test": {
-    "file": "./core/non-qv/processMessages",
+    "file": "./coordinator/non-qv/processMessages",
     "template": "ProcessMessagesNonQv",
     "params": [10, 20, 2],
     "pubs": [
-      "numSignUps",
+      "totalSignups",
+      "index",
+      "batchEndIndex",
+      "currentSbCommitment",
+      "newSbCommitment",
+      "outputBatchHash",
+      "actualStateTreeDepth",
+      "coordinatorPublicKeyHash",
+      "voteOptions"
+    ]
+  },
+  "ProcessMessagesFull_10-20-2_test": {
+    "file": "./coordinator/non-qv/MessageProcessor",
+    "template": "MessageProcessorFull",
+    "params": [10, 20, 2],
+    "pubs": [
+      "totalSignups",
       "index",
       "batchEndIndex",
       "currentSbCommitment",
@@ -126,16 +142,16 @@ Edit `circuits/circom/circuits` to include the circuits you would like to compil
     ]
   },
   "TallyVotes_10-1-2_test": {
-    "file": "./core/qv/tallyVotes",
+    "file": "./coordinator/qv/tallyVotes",
     "template": "TallyVotes",
     "params": [10, 1, 2],
-    "pubs": ["index", "numSignUps", "sbCommitment", "currentTallyCommitment", "newTallyCommitment"]
+    "pubs": ["index", "totalSignups", "sbCommitment", "currentTallyCommitment", "newTallyCommitment"]
   },
   "TallyVotesNonQv_10-1-2_test": {
-    "file": "./core/non-qv/tallyVotes",
+    "file": "./coordinator/non-qv/tallyVotes",
     "template": "TallyVotesNonQv",
     "params": [10, 1, 2],
-    "pubs": ["index", "numSignUps", "sbCommitment", "currentTallyCommitment", "newTallyCommitment"]
+    "pubs": ["index", "totalSignups", "sbCommitment", "currentTallyCommitment", "newTallyCommitment"]
   }
 }
 ```

package/versioned_docs/version-v3.x/guides/integrating.md

@@ -17,12 +17,12 @@ As an example, a [contract](https://github.com/ctrlc03/minimalQF/blob/main/contr
 
 ```javascript
 /// @inheritdoc IMACI
-function signUp(PubKey memory _pubKey, bytes memory _signUpPolicyData) public virtual {
+function signUp(PublicKey memory _publicKey, bytes memory _signUpPolicyData) public virtual {
   // ensure we do not have more signups than what the circuits support
   if (leanIMTData.size >= maxSignups) revert TooManySignups();
 
   // ensure that the public key is on the baby jubjub curve
-  if (!CurveBabyJubJub.isOnCurve(_pubKey.x, _pubKey.y)) {
+  if (!CurveBabyJubJub.isOnCurve(_publicKey.x, _publicKey.y)) {
     revert InvalidPubKey();
   }
 
@@ -31,19 +31,19 @@ function signUp(PubKey memory _pubKey, bytes memory _signUpPolicyData) public vi
   signUpPolicy.enforce(msg.sender, _signUpPolicyData);
 
   // Hash the public key and insert it into the tree.
-  uint256 pubKeyHash = hashLeftRight(_pubKey.x, _pubKey.y);
+  uint256 pubKeyHash = hashLeftRight(_publicKey.x, _publicKey.y);
   uint256 stateRoot = InternalLeanIMT._insert(leanIMTData, pubKeyHash);
 
   // Store the current state tree root in the array
   stateRootsOnSignUp.push(stateRoot);
 
-  emit SignUp(leanIMTData.size - 1, block.timestamp, _pubKey.x, _pubKey.y);
+  emit SignUp(leanIMTData.size - 1, block.timestamp, _publicKey.x, _publicKey.y);
 }
 ```
 
 ## InitialVoiceCreditProxy
 
-If you'd like to extend the functionality of how votes are distributed among users, you need to extend [InitialVoiceCreditProxy](https://github.com/privacy-scaling-explorations/maci/blob/dev/contracts/contracts/initialVoiceCreditProxy/InitialVoiceCreditProxy.sol) contract. You can see our [basic example](https://github.com/privacy-scaling-explorations/maci/blob/dev/contracts/contracts/initialVoiceCreditProxy/ConstantInitialVoiceCreditProxy.sol) how it's implemented for constant distribution.
+If you'd like to extend the functionality of how votes are distributed among users, you'll need to build you own initial voice credit proxy contract by following the [IInitialVoiceCreditProxy interface](https://github.com/privacy-scaling-explorations/maci/blob/dev/packages/contracts/contracts/interfaces/IInitialVoiceCreditProxy.sol). You can see our [basic example](https://github.com/privacy-scaling-explorations/maci/blob/dev/packages/contracts/contracts/initialVoiceCreditProxy/ConstantInitialVoiceCreditProxy.sol) how it's implemented for constant distribution.
 
 ```ts
 contract ConstantInitialVoiceCreditProxy is InitialVoiceCreditProxy {
@@ -71,7 +71,7 @@ On the other hand, the Poll contract can be inherited to expand functionality su
 ```javascript
 function joinPoll(
   uint256 _nullifier,
-  PubKey calldata _pubKey,
+  PublicKey calldata _publicKey,
   uint256 _stateRootIndex,
   uint256[8] calldata _proof,
   bytes memory _signUpPolicyData,
@@ -86,7 +86,7 @@ function joinPoll(
   pollNullifiers[_nullifier] = true;
 
   // Verify user's proof
-  if (!verifyJoiningPollProof(_nullifier, _stateRootIndex, _pubKey, _proof)) {
+  if (!verifyJoiningPollProof(_nullifier, _stateRootIndex, _publicKey, _proof)) {
     revert InvalidPollProof();
   }
 
@@ -100,7 +100,7 @@ function joinPoll(
   );
 
   // Store user in the pollStateTree
-  uint256 stateLeaf = hashStateLeaf(StateLeaf(_pubKey, voiceCreditBalance, block.timestamp));
+  uint256 stateLeaf = hashStateLeaf(StateLeaf(_publicKey, voiceCreditBalance, block.timestamp));
 
   uint256 stateRoot = InternalLazyIMT._insert(pollStateTree, stateLeaf);
 
@@ -108,7 +108,7 @@ function joinPoll(
   pollStateRootsOnJoin.push(stateRoot);
 
   uint256 pollStateIndex = pollStateTree.numberOfLeaves - 1;
-  emit PollJoined(_pubKey.x, _pubKey.y, voiceCreditBalance, block.timestamp, _nullifier, pollStateIndex);
+  emit PollJoined(_publicKey.x, _publicKey.y, voiceCreditBalance, block.timestamp, _nullifier, pollStateIndex);
 }
 ```
 

package/versioned_docs/version-v3.x/guides/testing/testing-in-detail.md

@@ -176,7 +176,7 @@ This script contains a number of actions which touch all of the parts of MACI, a
 
 Looking at this in more details we do the following:
 
-1. Deploy a `VkRegistry` contract
+1. Deploy a `VerifyingKeysRegistry` contract
 2. Set the verification keys on this smart contract
 3. Deploy a `MACI` contract (and associated utility contracts)
 4. Deploy a Poll from the MACI contract.

package/versioned_docs/version-v3.x/guides/testing/testing-introduction.md

@@ -74,7 +74,7 @@ or download them. Please remember to not use these testing `.zkey` files in prod
 MACI has two main zk-SNARK circuits, `processMessages` and `tallyVotes`.
 
 :::info
-The `processMessages` and `tallyVotes` circuits are also provided in a non-quadratic voting (non-QV) version. Currently these new versions have not undergone a trusted setup ceremony.
+The `processMessages` and `tallyVotes` circuits are also provided in a non-quadratic voting (non-QV) and in a full credits voting (full) versions. Currently these new versions have not undergone a trusted setup ceremony.
 :::
 
 Each circuit is parameterised and there should be one
@@ -151,6 +151,12 @@ To run e2e tests with normal voting (not quadratic voting):
 pnpm run test:e2e-non-qv
 ```
 
+To run e2e tests with full credits voting (full):
+
+```bash
+pnpm run test:e2e-full
+```
+
 To run integration tests:
 
 ```bash

package/versioned_docs/version-v3.x/guides/troubleshooting.md

@@ -7,14 +7,14 @@ sidebar_position: 5
 
 # Troubleshooting
 
-## cli: `genProofs` command failure
+## cli: `generateProofs` command failure
 
 ### Case: missing `.dat` files
 
 If your logs look like the following, then make sure you have `ProcessMessages_10-2-1-2_test.dat` and `TallyVotes_10-1-2_test.dat` files in the same directory as your zkeys:
 
 ```
-node build/ts/index.js genProofs -x 0xf204a4Ef082f5c04bB89F7D5E6568B796096735a \
+node build/ts/index.js generateProofs -x 0xf204a4Ef082f5c04bB89F7D5E6568B796096735a \
 >     -sk macisk.49953af3585856f539d194b46c82f4ed54ec508fb9b882940cbe68bbc57e59e \
 >     -o 0 \
 >     -r ~/rapidsnark/build/prover \
@@ -38,10 +38,10 @@ Aborted (core dumped)
 Error: could not generate proof.
 Error: Error executing ./zkeys/ProcessMessages_10-2-1-2_test /tmp/tmp-9904-zG0k8YPTATWB/input.json /tmp/tmp-9904-zG0k8YPTATWB/output.wtns
     at genProof (/home/ubuntu/maci/circuits/ts/index.ts:44:15)
-    at /home/ubuntu/maci/cli/ts/genProofs.ts:339:25
-    at step (/home/ubuntu/maci/cli/build/genProofs.js:33:23)
-    at Object.next (/home/ubuntu/maci/cli/build/genProofs.js:14:53)
-    at fulfilled (/home/ubuntu/maci/cli/build/genProofs.js:5:58)
+    at /home/ubuntu/maci/cli/ts/generateProofs.ts:339:25
+    at step (/home/ubuntu/maci/cli/build/generateProofs.js:33:23)
+    at Object.next (/home/ubuntu/maci/cli/build/generateProofs.js:14:53)
+    at fulfilled (/home/ubuntu/maci/cli/build/generateProofs.js:5:58)
 ```
 
 You can generate the missing `.dat` files using the following command:
@@ -54,7 +54,7 @@ pnpm build:circuits-c -- --outPath ../cli/zkeys
 
 ### Case `Commitment mismatch`
 
-If your log looks like the following, that's because you have already run the `prove` command. You can access the `cli` and attempt again by executing the `genProofs` command.
+If your log looks like the following, that's because you have already run the `prove` command. You can access the `cli` and attempt again by executing the `generateProofs` command.
 
 ```
 Error: commitment mismatch
@@ -69,7 +69,7 @@ Error: commitment mismatch
  ELIFECYCLE  Command failed with exit code 1.
 ```
 
-This is because commitments are generated using random salts, thus will differ at each `genProofs` run.
+This is because commitments are generated using random salts, thus will differ at each `generateProofs` run.
 
 In [core/Poll.ts](https://github.com/privacy-scaling-explorations/maci/blob/dev/packages/core/ts/Poll.ts):
 
@@ -84,7 +84,7 @@ while (this.sbSalts[this.currentMessageBatchIndex!] === newSbSalt) {
 
 ### Case `AssertionError`
 
-This could happen when you run `prove` in the `contracts` package, or run `genProofs` in the `cli` package. If your log looks like the following, there are two possible reasons:
+This could happen when you run `prove` in the `contracts` package, or run `generateProofs` in the `cli` package. If your log looks like the following, there are two possible reasons:
 
 1. If your MACI keypair for the coordinator was generated based on a previous version, it may have been generated incorrectly due to a breaking change in a third-party package (`zk-kit/eddsa-poseidon`). Please generate a new pair and run the whole process again.
 2. The provided private key is unmatched to the public key which deployed the poll, you will need to input the correct private key.
@@ -130,7 +130,7 @@ TypeError: cannot filter non-indexed parameters; must be null (argument="contrac
 }
 ```
 
-This could happen during running `genProofs` in `cli` package, or running `prove` in `contracts` package.
+This could happen during running `generateProofs` in `cli` package, or running `prove` in `contracts` package.
 Be aware that we updated several parameters to `indexed`:
 
 ```javascript
@@ -144,7 +144,7 @@ Please remember to pull the latest MACI repo updates(`git fetch origin && git pu
 
 ### Verifier contract found the proof invalid
 
-If your log looks like the following, that's because the zkey and wasm files added to the [`VkRegistry` contract](/docs/technical-references/smart-contracts/VkRegistry) are different from what you use to run the **prove** command. Check if you're using the correct zkey and wasm files.
+If your log looks like the following, that's because the zkey and wasm files added to the [`VerifyingKeysRegistry` contract](/docs/technical-references/smart-contracts/VerifyingKeysRegistry) are different from what you use to run the **prove** command. Check if you're using the correct zkey and wasm files.
 
 ```
 Error: The verifier contract found the proof invalid.