npm - @maci-protocol/website - Versions diffs - 0.0.0-ci.a577366 → 0.0.0-ci.a73cfa9 - Mend

@maci-protocol/website 0.0.0-ci.a577366 → 0.0.0-ci.a73cfa9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (104) hide show

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

@@ -86,7 +86,7 @@ while true:
     if rand >= min:
         break
-privKey = rand % p
+privateKey = rand % p
 ```
 #### 1.3. Private key formatting
@@ -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/coordinator/qv/MessageProcessor.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
@@ -813,21 +747,21 @@ The final tally should be:
 2. Total voice credits per vote option: `[3, 9, 19, 33, 26]`
 3. Total spent voice credits: `66`
-The coordinator uses the ballot tallying circuit (`tallyVotes.circom`) to generate proofs that they have correctly computed the tally. As there are many ballots to tally, each proof only computes the tally for a batch of ballots. Each proof is chained to the previous one such that each proof is also a proof of knowledge of the preimage of the previous tally commitment.
+The coordinator uses the ballot tallying circuit (`VoteTally.circom`) to generate proofs that they have correctly computed the tally. As there are many ballots to tally, each proof only computes the tally for a batch of ballots. Each proof is chained to the previous one such that each proof is also a proof of knowledge of the preimage of the previous tally commitment.
 #### 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/workflow.md CHANGED Viewed

@@ -66,7 +66,7 @@ Therefore, even if a coordinator is corrupt, they are unable to change a user’
 To explain the MACI workflow, let's give a quick overview of the key smart contracts.
-See our [smart contract docs](/docs/category/smart-contracts) or our [contract source code](https://github.com/privacy-scaling-explorations/maci/tree/dev/contracts/contracts) for a more in-depth explanation of all smart contracts.
+See our [smart contract docs](/docs/category/smart-contracts) or our [contract source code](https://github.com/privacy-scaling-explorations/maci/tree/main/contracts/contracts) for a more in-depth explanation of all smart contracts.
 ### MACI.sol
@@ -133,7 +133,7 @@ The `MessageProcessor` contract will send the proof to a separate verifier contr
 #### Tally Results
-Finally, once all messages have been processed, the coordinator tallies the votes of the valid messages (off-chain). The coordinator creates a zk-SNARK proving that the valid messages in the state tree (proved in Process Messages step) contain votes that sum to the given tally result. Then, they call [`Tally.tallyVotes()`](/docs/technical-references/smart-contracts/solidity-docs/Tally#tallyvotes) with a hash of the correct tally results and the zk-SNARK proof. Similarly to the processMessages function, the `tallyVotes` function will send the proof to a verifier contract to ensure that it is valid.
+Finally, once all messages have been processed, the coordinator tallies the votes of the valid messages (off-chain). The coordinator creates a zk-SNARK proving that the valid messages in the state tree (proved in Process Messages step) contain votes that sum to the given tally result. Then, they call [`Tally.tallyVotes()`](/docs/technical-references/smart-contracts/solidity-docs/Tally#tallyvotes) with a hash of the correct tally results and the zk-SNARK proof. Similarly to the `processMessages` function, the `tallyVotes` function will send the proof to a verifier contract to ensure that it is valid.
 <!-- "hash of the correct tally results" - so are the final results actually put on chain? or just a hash?? -->

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

@@ -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",
-    "template": "ProcessMessages",
+  "MessageProcessorQv_10-20-2_test": {
+    "file": "./coordinator/qv/MessageProcessor",
+    "template": "MessageProcessorQv",
     "params": [10, 20, 2],
     "pubs": [
-      "numSignUps",
+      "totalSignups",
       "index",
       "batchEndIndex",
       "currentSbCommitment",
@@ -109,12 +109,12 @@ Edit `circuits/circom/circuits` to include the circuits you would like to compil
       "voteOptions"
     ]
   },
-  "ProcessMessagesNonQv_10-20-2_test": {
-    "file": "./core/non-qv/processMessages",
-    "template": "ProcessMessagesNonQv",
+  "MessageProcessorNonQv_10-20-2_test": {
+    "file": "./coordinator/non-qv/MessageProcessor",
+    "template": "MessageProcessorNonQv",
     "params": [10, 20, 2],
     "pubs": [
-      "numSignUps",
+      "totalSignups",
       "index",
       "batchEndIndex",
       "currentSbCommitment",
@@ -125,17 +125,33 @@ Edit `circuits/circom/circuits` to include the circuits you would like to compil
       "voteOptions"
     ]
   },
-  "TallyVotes_10-1-2_test": {
-    "file": "./core/qv/tallyVotes",
-    "template": "TallyVotes",
+  "ProcessMessagesFull_10-20-2_test": {
+    "file": "./coordinator/non-qv/MessageProcessor",
+    "template": "MessageProcessorFull",
+    "params": [10, 20, 2],
+    "pubs": [
+      "totalSignups",
+      "index",
+      "batchEndIndex",
+      "currentSbCommitment",
+      "newSbCommitment",
+      "outputBatchHash",
+      "actualStateTreeDepth",
+      "coordinatorPublicKeyHash",
+      "voteOptions"
+    ]
+  },
+  "VoteTallyQv_10-1-2_test": {
+    "file": "./coordinator/qv/VoteTally",
+    "template": "VoteTallyQv",
     "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",
-    "template": "TallyVotesNonQv",
+  "VoteTallyNonQv_10-1-2_test": {
+    "file": "./coordinator/non-qv/VoteTally",
+    "template": "VoteTallyNonQv",
     "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 CHANGED Viewed

@@ -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/main/packages/contracts/contracts/interfaces/IInitialVoiceCreditProxy.sol). You can see our [basic example](https://github.com/privacy-scaling-explorations/maci/blob/main/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);
 }
 ```
@@ -118,7 +118,7 @@ Given the verification functions being exposed by the Tally contract, quadratic
 ## SDK
-Another important component of MACI is the [SDK](https://github.com/privacy-scaling-explorations/maci/tree/dev/packages/sdk). This is a TypeScript library that allows you to interact with MACI.
+Another important component of MACI is the [SDK](https://github.com/privacy-scaling-explorations/maci/tree/main/packages/sdk). This is a TypeScript library that allows you to interact with MACI.
 You can find the following subdirectories, where functions are organised as follows:

package/versioned_docs/version-v3.x/guides/sdk.md ADDED Viewed

@@ -0,0 +1,121 @@
+---
+title: MACI SDK
+description: How to use the MACI SDK
+sidebar_label: MACI SDK
+sidebar_position: 6
+---
+In this guide we will be looking at how to use the MACI SDK to interact with the MACI protocol.
+## Installation
+```bash
+npm install @maci-protocol/sdk
+```
+## Browser compatibility
+As the SDK imports functions from the `@maci-protocol/contracts` package which uses hardhat, certain functionality is not browser compatible.
+However, all it takes to use browser compatible functions is to import from `@maci-protocol/sdk/browser`.
+As an example, we can import the `signUp` function from the `@maci-protocol/sdk/browser` package.
+```typescript
+import { signUp } from "@maci-protocol/sdk/browser";
+```
+Let's take a look at an example of how to use the `joinPoll` function to register a user to a poll.
+### JoinPoll
+This step is required to register a user to a specific poll for which they want to vote. In short, it requires the user to generate a zk-SNARK proof that they know the private key to a public key registered to the MACI contract (proving they passed the initial gatekeeping requirements). This forces them to join with the same MACI key to each poll, greatly increasing the value of the key. Should they have been allowed to join with a throwaway key, they could simply sell their key for polls they do not care about.
+**How does the flow look like?**
+1. Reconstruct the MACI state tree by pulling all public keys from the MACI contract (events from RPC or from Subgraph)
+2. Generate a merkle tree inclusion proof for the user's public key
+3. Generate a zk-SNARK proof that the user knows the private key to the public key in the merkle tree inclusion proof
+4. Call the `joinPoll` function on the Poll smart contract
+**How to use the SDK for this?**
+> This example is browser specific, as it uses the `@maci-protocol/sdk/browser` package and WASM for witness generation
+Option 1: Use the `joinPoll` function from the `@maci-protocol/sdk/browser` package.
+1. Download the `pollJoining` zk artifacts using [downloadPollJoiningArtifactsBrowser](https://github.com/privacy-scaling-explorations/maci/blob/main/packages/sdk/ts/proof/download.ts#L46)
+```typescript
+import { downloadPollJoiningArtifactsBrowser } from "@maci-protocol/sdk/browser";
+const artifacts = await downloadPollJoiningArtifactsBrowser({
+  testing: true,
+  stateTreeDepth: 10,
+});
+```
+2. Use the `joinPoll` function to join the poll
+```typescript
+import { joinPoll } from "@maci-protocol/sdk/browser";
+const joinedPollData = await joinPoll({
+  maciAddress: PUBLIC_MACI_ADDRESS,
+  privateKey: maciKeypair.privateKey.serialize(),
+  signer,
+  pollId,
+  inclusionProof,
+  pollJoiningZkey: artifacts.zKey as unknown as string,
+  pollWasm: artifacts.wasm as unknown as string,
+  sgDataArg: DEFAULT_SG_DATA,
+  ivcpDataArg: DEFAULT_IVCP_DATA,
+  blocksPerBatch: 1000,
+});
+```
+This is not really efficient, as we are using the user RPC to fetch events, which can be quite slow and prone to errors. A better approach is to use a Subgraph to fetch the events.
+Option 2: Fetch the MACI keys using a subgraph and reconstruct the state tree locally.
+1. Deploy the subgraph - instructions [here](/guides/subgraph)
+2. Fetch the MACI keys
+```typescript
+import { MaciSubgraph } from "@maci-protocol/sdk/browser";
+const subgraph = new MaciSubgraph("https://api.studio.thegraph.com/query/x/maci/version/latest");
+const keys = await subgraph.getKeys();
+```
+3. Generate the merkle tree
+```typescript
+import { generateSignUpTreeFromKeys } from "@maci-protocol/sdk/browser";
+const signUpTree = generateSignUpTreeFromKeys(keys);
+```
+4. Generate the inclusion proof - you will need to know the index of the user's public key in the merkle tree
+```typescript
+const inclusionProof = signUpTree.generateProof(publicKeyIndex);
+```
+5. Generate the zk-SNARK proof and join the poll
+```typescript
+import { joinPoll } from "@maci-protocol/sdk/browser";
+const joinedPollData = await joinPoll({
+  maciAddress: PUBLIC_MACI_ADDRESS,
+  privateKey: maciKeypair.privateKey.serialize(),
+  signer,
+  pollId,
+  inclusionProof,
+  pollJoiningZkey: artifacts.zKey as unknown as string,
+  pollWasm: artifacts.wasm as unknown as string,
+  sgDataArg: DEFAULT_SG_DATA,
+  ivcpDataArg: DEFAULT_IVCP_DATA,
+});
+```

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

@@ -154,7 +154,7 @@ Within the circuits folder, there are a number of tests that are used to verify
 These tests often use mock data from the `core` package. For instance, when testing the `processMessages` circuit, we are required to generate the parameters from the `core` packing, using the `Poll:processMessages` function. The same applies to vote tallying, where we need the `Poll:tally` function to be run first with mock users and vote messages.
-All of the tests run using test parameters, usually `10, 20, 2`, aside from the tests inside: [`ceremonyParam`](https://github.com/privacy-scaling-explorations/maci/blob/dev/circuits/ts/__tests__/CeremonyParams.test.ts) which use the parameters of the latest MACI ceremony. More details on the trusted setup can be found [here](/docs/security/trusted-setup).
+All of the tests run using test parameters, usually `10, 20, 2`, aside from the tests inside: [`ceremonyParam`](https://github.com/privacy-scaling-explorations/maci/blob/main/circuits/ts/__tests__/CeremonyParams.test.ts) which use the parameters of the latest MACI ceremony. More details on the trusted setup can be found [here](/docs/security/trusted-setup).
 ### Core
@@ -162,7 +162,7 @@ The core package contains a number of tests that are used to verify that the cor
 These tests interact with the crypto and dombinobjs packages, where mock data comes from. Their main goal is to ensure that the core functions work as expected, and that the state is as expected after a series of operations.
-Currently, there is a blend of e2e and unit tests, where e2e tests are used to verify that the entire MACI local processing works as expected (users signup, publish votes, messages are processed and finally these votes are tallied). Unit tests on the other hand are used to verify that the core functions work as expected, such as `processMessage` and `tallyVotes`. You will find them in separate files, with e2e being [here](https://github.com/privacy-scaling-explorations/maci/blob/dev/core/ts/__tests__/e2e.test.ts) and unit tests in the other files.
+Currently, there is a blend of e2e and unit tests, where e2e tests are used to verify that the entire MACI local processing works as expected (users signup, publish votes, messages are processed and finally these votes are tallied). Unit tests on the other hand are used to verify that the core functions work as expected, such as `MessageProcessor` and `VoteTally`. You will find them in separate files, with e2e being [here](https://github.com/privacy-scaling-explorations/maci/blob/main/core/ts/__tests__/e2e.test.ts) and unit tests in the other files.
 ### Domainobjs/Crypto tests
@@ -170,13 +170,13 @@ These tests are used to verify that MACI's primitives such as private keys work
 ## "Manual" Testing
-To ensure that the MACI stack works as expected, without having to run the entire test suite (or even just the e2e tests), there is a [bash script](https://github.com/privacy-scaling-explorations/maci/blob/dev/packages/contracts/testScriptLocalhost.sh) inside the contracts folder which can be used.
+To ensure that the MACI stack works as expected, without having to run the entire test suite (or even just the e2e tests), there is a [bash script](https://github.com/privacy-scaling-explorations/maci/blob/main/packages/contracts/testScriptLocalhost.sh) inside the contracts folder which can be used.
 This script contains a number of actions which touch all of the parts of MACI, and resemble exactly what other e2e tests do.
 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.