@maci-protocol/website 0.0.0-ci.85bba2d → 0.0.0-ci.86ec64f

package/versioned_docs/version-v3.x/supported-networks/deployed-contracts.md

@@ -7,14 +7,14 @@ sidebar_position: 2
 
 There are a number of MACI's smart contracts which can be re-used by different deployments. These are the following:
 
-- [VerifyingKeysRegistry](https://github.com/privacy-scaling-explorations/maci/blob/dev/contracts/contracts/VerifyingKeysRegistry.sol)
-- [PoseidonHashers](https://github.com/privacy-scaling-explorations/maci/blob/dev/contracts/contracts/crypto/Hasher.sol)
-- [PollFactory](https://github.com/privacy-scaling-explorations/maci/blob/dev/contracts/contracts/PollFactory.sol)
-- [MessageProcessorFactory](https://github.com/privacy-scaling-explorations/maci/blob/dev/contracts/contracts/MessageProcessorFactory.sol)
-- [TallyFactory](https://github.com/privacy-scaling-explorations/maci/blob/dev/contracts/contracts/TallyFactory.sol)
-- [Verifier](https://github.com/privacy-scaling-explorations/maci/blob/dev/contracts/contracts/crypto/Verifier.sol)
+- [VerifyingKeysRegistry](https://github.com/privacy-scaling-explorations/maci/blob/main/packages/contracts/contracts/VerifyingKeysRegistry.sol)
+- [PoseidonHashers](https://github.com/privacy-scaling-explorations/maci/blob/main/packages/contracts/contracts/crypto/Hasher.sol)
+- [PollFactory](https://github.com/privacy-scaling-explorations/maci/blob/main/packages/contracts/contracts/PollFactory.sol)
+- [MessageProcessorFactory](https://github.com/privacy-scaling-explorations/maci/blob/main/packages/contracts/contracts/MessageProcessorFactory.sol)
+- [TallyFactory](https://github.com/privacy-scaling-explorations/maci/blob/main/packages/contracts/contracts/TallyFactory.sol)
+- [Verifier](https://github.com/privacy-scaling-explorations/maci/blob/main/packages/contracts/contracts/crypto/Verifier.sol)
 - [FreeForAllPolicy](https://github.com/privacy-scaling-explorations/excubiae/tree/main/packages/contracts/contracts/extensions/freeForAll)
-- [ConstantInitialVoiceCreditProxy](https://github.com/privacy-scaling-explorations/maci/blob/dev/contracts/contracts/initialVoiceCreditProxy/ConstantInitialVoiceCreditProxy.sol) - if you are happy to work with a fixed amount of credits
+- [ConstantInitialVoiceCreditProxy](https://github.com/privacy-scaling-explorations/maci/blob/main/packages/contracts/contracts/initialVoiceCreditProxy/ConstantInitialVoiceCreditProxy.sol) - if you are happy to work with a fixed amount of credits
 
 VkRegistries can be re-used by different protocols to share the same set of verifying keys. Please be advised that you should be verifying that those verifying keys are the ones that have undergone a trusted setup ceremony.
 
@@ -25,7 +25,7 @@ In order to verify you will need the following:
 - run checkVerifyingKeys with the cli (see below)
 
 ```bash
-cd cli && node build/ts/index.js checkVerifyingKeys -q false -vk 0x74569d524a193daC0D3Df17B9E207C916174745b -s 6 -i 2 -m 9 -v 3 -b 2 -p ./zkeys/ProcessMessages_6-9-2-3/processMessages_6-9-2-3.zkey -t ./zkeys/TallyVotes_6-2-3/tallyVotes_6-2-3.zkey
+cd cli && node build/ts/index.js checkVerifyingKeys -q false -vk 0x74569d524a193daC0D3Df17B9E207C916174745b -s 6 -i 2 -m 9 -v 3 -b 2 -p ./zkeys/MessageProcessorQv_6-9-2-3/MessageProcessorQv_6-9-2-3.zkey -t ./zkeys/VoteTallyQv_6-2-3/tallyVotes_6-2-3.zkey
 ```
 
 :::info

package/versioned_docs/version-v3.x/supported-networks/supported-networks.md

@@ -23,6 +23,14 @@ MACI has been tested on the following EVM networks:
 - Gnosis Chiado
 - Polygon
 - Polygon Amoy
+- Scroll
+- Scroll Sepolia
+- Linea
+- Linea Sepolia
+- Zksync Era
+- Zksync Sepolia
+- Polygon Zkevm
+- Polygon Cardona Zkevm
 
 We recommend using either Optimism, Arbitrum or Base. Please open an issue/PR if you intend to use other EVM networks and would like to contribute to this record of deployed and verified contracts as well as benchmarks, that would be greatly appreciated.
 
@@ -42,6 +50,14 @@ For better UX, MACI clients should be sending votes (messages) in batches. Depen
 | Gnosis Chiado    | 50             | 15921753 | 0.0000188313 ETH ($0.05)                        |
 | Polygon          | 85             | 26915773 | 0.0002193417259598 ETH ($0.54)                  |
 | Polygon Amoy     | 89             | 28192368 | 0.00017069180975304 ETH ($0.43)                 |
+| Scroll           | 62             | 19447318 | 0.000233368 ETH ($0.61)                         |
+| Scroll Sepolia   | 62             | 19447318 | 0.000233368 ETH ($0.61)                         |
+| Linea            | 14             | 4438205  | 0.00005325846 ETH ($0.1382)                     |
+| Linea Sepolia    | 14             | 4438205  | 0.00005325846 ETH ($0.1382)                     |
+| Zksync Era       | 2              | 24000690 | 0.00028801 ETH ($0.75)                          |
+| Zksync Sepolia   | 2              | 24000690 | 0.00028801 ETH ($0.75)                          |
+| Polygon Zkevm    | 6              | 1917872  | 0.00006904 ETH ($0.18)                          |
+| Polygon Cardona  | 6              | 1917872  | 0.00006904 ETH ($0.18)                          |
 
 ## Test yourself
 

package/versioned_docs/version-v3.x/technical-references/smart-contracts/MACI.md

@@ -6,7 +6,7 @@ sidebar_position: 1
 ---
 
 :::info
-Code location: [MACI.sol](https://github.com/privacy-scaling-explorations/maci/blob/dev/contracts/contracts/MACI.sol)
+Code location: [MACI.sol](https://github.com/privacy-scaling-explorations/maci/blob/main/packages/contracts/contracts/MACI.sol)
 :::
 
 `MACI.sol` is the core contract of the project, as it provides the base layer for user signups and Polls to be created.
@@ -149,7 +149,7 @@ Polls require the following information:
 - `coordinatorPubKey`: the public key of the poll's coordinator
 - `verifier`: the address of the zk-SNARK verifier contract
 - `vkRegistry`: the address of the vk registry contract
-- `mode`: the mode of the poll, to set whether it supports quadratic voting or non quadratic voting
+- `mode`: the mode of the poll, to set whether it supports quadratic voting, non quadratic voting, full credits voting
 - `signUpPolicy`: the address of the sign up policy contract
 - `initialVoiceCreditProxy`: the address of the initial voice credit proxy contract
 - `relayers`: the addresses of the relayers for the poll (if offchain voting is enabled)

package/versioned_docs/version-v3.x/technical-references/smart-contracts/MessageProcessor.md

@@ -6,7 +6,7 @@ sidebar_position: 4
 ---
 
 :::info
-Code location: [MessageProcessor.sol](https://github.com/privacy-scaling-explorations/maci/blob/dev/contracts/contracts/MessageProcessor.sol)
+Code location: [MessageProcessor.sol](https://github.com/privacy-scaling-explorations/maci/blob/main/packages/contracts/contracts/MessageProcessor.sol)
 :::
 
 This contract is used to prepare parameters for the zk-SNARK circuits as well as for verifying proofs. It should be deployed alongside a `Poll`.

package/versioned_docs/version-v3.x/technical-references/smart-contracts/Params.md

@@ -6,7 +6,7 @@ sidebar_position: 9
 ---
 
 :::info
-Code location: [Params.sol](https://github.com/privacy-scaling-explorations/maci/blob/dev/contracts/contracts/utils/Params.sol)
+Code location: [Params.sol](https://github.com/privacy-scaling-explorations/maci/blob/main/packages/contracts/contracts/utilities/Params.sol)
 :::
 
 A contract holding three structs:
@@ -14,7 +14,7 @@ A contract holding three structs:
 ```ts
 /// @notice A struct holding the depths of the merkle trees
 struct TreeDepths {
-  uint8 intStateTreeDepth;
+  uint8 tallyProcessingStateTreeDepth;
   uint8 voteOptionTreeDepth;
 }
 

package/versioned_docs/version-v3.x/technical-references/smart-contracts/Policies.md

@@ -21,7 +21,7 @@ The MACI repository comes with several out-of-the-box options:
 - `HatsPolicy` - This allows gatekeeping signups to only users who have a specific [Hat](https://www.hatsprotocol.xyz/).
 - `GitcoinPassportPolicy` - This allows gatekeeping signups to only users who have a specific [Gitcoin Passport](https://passport.gitcoin.co/) score.
 - `ZupassPolicy` - This allows gatekeeping signups only to users who have a valid [Zupass PCD ticket](https://github.com/proofcarryingdata/zupass).
-- `SemaphorePolicy` - This allows gatekeeping signups only to users who can prove they are part of a [Semaphore](https://semaphore.pse.dev/) group.
+- `SemaphorePolicy` - This allows gatekeeping signups only to users who can prove they are part of a [Semaphore](https://semaphore.pse.main/) group.
 
 You can find all of the latest policy contracts here:
 https://github.com/privacy-scaling-explorations/excubiae/tree/main/packages/contracts/contracts/extensions

package/versioned_docs/version-v3.x/technical-references/smart-contracts/Poll.md

@@ -6,7 +6,7 @@ sidebar_position: 2
 ---
 
 :::info
-Code location: [Poll.sol](https://github.com/privacy-scaling-explorations/maci/blob/dev/contracts/contracts/Poll.sol)
+Code location: [Poll.sol](https://github.com/privacy-scaling-explorations/maci/blob/main/packages/contracts/contracts/Poll.sol)
 :::
 
 This contract allows users to submit their votes.

package/versioned_docs/version-v3.x/technical-references/smart-contracts/PollFactory.md

@@ -6,7 +6,7 @@ sidebar_position: 3
 ---
 
 :::info
-Code location: [PollFactory.sol](https://github.com/privacy-scaling-explorations/maci/blob/dev/contracts/contracts/PollFactory.sol)
+Code location: [PollFactory.sol](https://github.com/privacy-scaling-explorations/maci/blob/main/packages/contracts/contracts/PollFactory.sol)
 :::
 
 `PollFactory` is a smart contract that is used to deploy new Polls. This is used by MACI inside the `deployPoll` function.

package/versioned_docs/version-v3.x/technical-references/smart-contracts/Tally.md

@@ -6,7 +6,7 @@ sidebar_position: 5
 ---
 
 :::info
-Code location: [Tally.sol](https://github.com/privacy-scaling-explorations/maci/blob/dev/contracts/contracts/Tally.sol)
+Code location: [Tally.sol](https://github.com/privacy-scaling-explorations/maci/blob/main/packages/contracts/contracts/Tally.sol)
 :::
 
 The `Tally` contract is used by the coordinator to submit commitments to the tally results via the `tallyVotes` function. This is done in batches and the final commitment can be used by the users to verify the validity of the results.
@@ -34,7 +34,7 @@ This contract should be deployed alongside a `Poll`, with the the constructor ac
 - `vkRegistry` - The address of the vkRegistry contract
 - `poll` - The address of the poll contract
 - `messageProcessor` - The address of the messageProcessor contract
-- `mode` - The mode of the tally contract - depending on this, the commitments will be processed differently, and it must equal the Poll mode (quadratic vs non quadratic voting)
+- `mode` - The mode of the tally contract - depending on this, the commitments will be processed differently, and it must equal the Poll mode (quadratic vs non quadratic vs full credits voting)
 
 Users can use the verification functions to verify the Tally results. These are as follows:
 

package/versioned_docs/version-v3.x/technical-references/smart-contracts/VkRegistry.md

@@ -6,19 +6,19 @@ sidebar_position: 8
 ---
 
 :::info
-Code location: [VerifyingKeysRegistry.sol](https://github.com/privacy-scaling-explorations/maci/blob/dev/contracts/contracts/VerifyingKeysRegistry.sol)
+Code location: [VerifyingKeysRegistry.sol](https://github.com/privacy-scaling-explorations/maci/blob/main/packages/contracts/contracts/VerifyingKeysRegistry.sol)
 :::
 
 The VerifyingKeysRegistry is a contract that holds the verifying keys for the zk-SNARK circuits. It holds four different sets of keys:
 
-- `processVks` - The keys for the processMessages circuit
-- `tallyVks` - The keys for the tallyVotes circuit
+- `processVks` - The keys for the MessageProcessor circuit
+- `tallyVks` - The keys for the VoteTally circuit
 - `pollJoiningVk` - The key for the poll joining circuit
 - `pollJoinedVk` - The key for the poll joined circuit
 
 Each circuit will have a signature which is its compile-time constants represented as a uint256.
 
-Please note that each Verifying Key should be set with the corresponding mode. Available modes are quadratic voting and non quadratic voting.
+Please note that each Verifying Key should be set with the corresponding mode. Available modes are quadratic, non quadratic and full credits voting.
 
 The contract owner can set them using the `setVerifyingKeysBatch` function:
 

package/versioned_docs/version-v3.x/technical-references/smart-contracts/VoiceCreditProxy.md

@@ -6,7 +6,7 @@ sidebar_position: 7
 ---
 
 :::info
-Code location: [InitialVoiceCreditProxy](https://github.com/privacy-scaling-explorations/maci/tree/dev/contracts/contracts/initialVoiceCreditProxy)
+Code location: [InitialVoiceCreditProxy](https://github.com/privacy-scaling-explorations/maci/tree/main/contracts/contracts/initialVoiceCreditProxy)
 :::
 
 The VoiceCreditProxy contract is used to assign voice credits to users. Whichever implementation should the MACI deployers use, this must implement a view function that returns the balance for a user, such as the one below:

package/versioned_docs/version-v3.x/technical-references/technical-references.md

@@ -19,7 +19,7 @@ The MACI smart contracts handle the on-chain aspects - both the functionality an
 
 The MACI smart contracts are written in [Solidity](https://soliditylang.org/).
 
-Contracts are released through the [`@maci-contracts`](https://www.npmjs.com/package/maci-contracts) NPM package.
+Contracts are released through the [`@maci-protocol/contracts`](https://www.npmjs.com/package/@maci-protocol/contracts) NPM package.
 
 [Learn more about MACI contracts](/docs/technical-references/smart-contracts/)
 
@@ -29,12 +29,12 @@ The TypeScript libraries manage the business logic between the smart contracts a
 
 The MACI [TypeScript](https://www.typescriptlang.org/) libraries are released through the following NPM packages:
 
-- [`@maci-cli`](https://www.npmjs.com/package/maci-cli)
-- [`@maci-core`](https://www.npmjs.com/package/maci-core)
-- [`@maci-crypto`](https://www.npmjs.com/package/maci-crypto)
-- [`@maci-domainobjs`](https://www.npmjs.com/package/maci-domainobjs)
-- [`@maci-integrationtests`](https://www.npmjs.com/package/maci-integrationtests)
-- [`@maci-sdk`](https://www.npmjs.com/package/maci-sdk)
+- [`@maci-protocol/cli`](https://www.npmjs.com/package/@maci-protocol/cli)
+- [`@maci-protocol/core`](https://www.npmjs.com/package/@maci-protocol/core)
+- [`@maci-protocol/crypto`](https://www.npmjs.com/package/@maci-protocol/crypto)
+- [`@maci-protocol/domainobjs`](https://www.npmjs.com/package/@maci-protocol/domainobjs)
+- [`@maci-protocol/integrationtests`](https://www.npmjs.com/package/@maci-protocol/integrationtests)
+- [`@maci-protocol/sdk`](https://www.npmjs.com/package/@maci-protocol/sdk)
 
 ## Circuits
 
@@ -43,6 +43,6 @@ MACI has multiple circuits that ensure all off-chain computation is completed co
 The circuits for these zero-knowledge proofs are written
 in [Circom](https://iden3.io/circom).
 
-The MACI circuits are released through the [`@maci-circuits`](https://www.npmjs.com/package/maci-circuits) NPM package.
+The MACI circuits are released through the [`@maci-protocol/circuits`](https://www.npmjs.com/package/@maci-protocol/circuits) NPM package.
 
 [Learn more about MACI circuits](/docs/technical-references/zk-snark-circuits/)

package/versioned_docs/version-v3.x/technical-references/zk-snark-circuits/joinPoll.md

@@ -5,7 +5,7 @@ sidebar_label: Join Poll Circuit
 sidebar_position: 6
 ---
 
-[**Repo link**](https://github.com/privacy-scaling-explorations/maci/blob/dev/circuits/circom/voter)
+[**Repo link**](https://github.com/privacy-scaling-explorations/maci/blob/main/circuits/circom/voter)
 
 ## PollJoining
 

package/versioned_docs/version-v3.x/technical-references/zk-snark-circuits/processMessages.md

@@ -5,11 +5,11 @@ sidebar_label: Process Messages Circuit
 sidebar_position: 3
 ---
 
-[**Repo link**](https://github.com/privacy-scaling-explorations/maci/blob/dev/circuits/circom/core)
+[**Repo link**](https://github.com/privacy-scaling-explorations/maci/blob/main/circuits/circom/coordinator)
 
 This circuit allows the coordinator to prove that they have correctly processed each message in reverse order, in a consecutive batch of 5 ^ messageBatchDepth messages to the respective state leaf within the state tree. Coordinators would use this circuit to prove correct execution at the end of each Poll.
 
-The [`processMessages`](https://github.com/privacy-scaling-explorations/maci/blob/dev/circuits/circom/core/qv/processMessages.circom) circuit will try to decrypt the messages, and based on the content of the message, update within itself the trees, to generate a proof that the coordinator's off-chain processing was done correctly. In other words, the circuit takes a final state, an initial state, and the leaves (messages and user signups) - it processes these messages via the different state transitions to finally check that the expected state is correct.
+The [`MessageProcessorQv`](https://github.com/privacy-scaling-explorations/maci/blob/main/circuits/circom/coordinator/qv/MessageProcessor.circom) circuit will try to decrypt the messages, and based on the content of the message, update within itself the trees, to generate a proof that the coordinator's off-chain processing was done correctly. In other words, the circuit takes a final state, an initial state, and the leaves (messages and user signups) - it processes these messages via the different state transitions to finally check that the expected state is correct.
 The pre-requisites for this circuit are:
 
 - the related Poll has ended
@@ -18,10 +18,74 @@ The pre-requisites for this circuit are:
 
 This circuit requires the coordinator's private key, hence a proof for this circuit can only be generated by the coordinator. The private key is needed in order to generate the ECDH shared key used to decrypt the messages.
 
-![ProcessMessages](/img/circuits/processMessages_2_0.svg)
+```mermaid
+flowchart LR
+        parameters(["MessageProcessorQv - Parameters"])
+        parameters --> stateTreeDepth["stateTreeDepth"]
+        parameters --> batchSize["batchSize"]
+        parameters --> voteOptionTreeDepth["voteOptionTreeDepth"]
+
+        stateTreeDepth & batchSize & voteOptionTreeDepth --> publicInputs["Public inputs"]
+
+        subgraph publicInputs
+            direction LR
+            totalSignups ~~~ index
+            batchEndIndex ~~~ currentSbCommitment
+            newSbCommitment ~~~ outputBatchHash
+            actualStateTreeDepth ~~~ coordinatorPublicKeyHash
+            voteOptions
+        end
+
+        publicInputs --> privateInputs
+
+        subgraph privateInputs
+            direction LR
+            inputBatchHash ~~~ messages
+            coordinatorPrivateKey ~~~ encryptionPublicKeys
+            currentStateRoot ~~~ currentStateLeaves
+            currentStateLeavesPathElements ~~~ currentSbSalt
+            newSbSalt ~~~ currentBallotRoot
+            currentBallots ~~~ currentBallotsPathElements
+            currentVoteWeights ~~~ currentVoteWeightsPathElements
+        end
+
+        privateInputs --> step1["1 - Verify currentSbCommitment"]
+        step1 --> step1B["hash(currentStateRoot, currentBallotRoot, currentSbSalt)"]
+
+        privateInputs --> step2["2 – Check voteOptions upper-bound"]
+        step2 --> step2B["voteOptions <= 5 ** voteOptionTreeDepth"]
+
+        privateInputs --> step3["3 – Ensure totalSignups within capacity"]
+        step3 --> step3B["totalSignups <= 2 ** stateTreeDepth"]
+
+        privateInputs --> step4["4 – Hash each message + pub-key"]
+        step4 --> step4B["MessageHasher template loop"]
+
+        privateInputs --> step5["5 – Build and verify chainHash"]
+        step5 --> step5B["PoseidonHasher template loop + Mux1"]
+
+        privateInputs --> step6["6 – Derive & verify coordinator pubKey"]
+        step6 --> step6B["PrivateToPublicKey -> derivedPublicKeyHash == coordinatorPublicKeyHash"]
+
+        privateInputs --> step7["7 – Decrypt each message to a command using MessageToCommand"]
+        step7 --> step7B["MessageToCommand template loop"]
+
+        privateInputs --> step8["8 – Process messages in reverse order"]
+        step8 --> step8B["SingleMessageProcessorQv template loop"]
+
+        privateInputs --> step9["9 – Compute newSbCommitment"]
+        step9 --> step9B["hash(stateRoot, ballotRoot, newSbSalt)"]
+
+        privateInputs --> step10["10 – Verify provided newSbCommitment"]
+        step10 --> step10B["equality with computed commitment"]
+```
+
+:::info
+A version working with non quadratic voting (non-qv) is also [available](https://github.com/privacy-scaling-explorations/maci/blob/main/circuits/circom/coordinator/non-qv/MessageProcessor.circom). This version is called `MessageProcessorNonQV` and is to be used when the Poll is not using the quadratic voting feature. Note that by default MACI works with quadratic voting.
+:::
 
 :::info
-A version working with non quadratic voting (non-qv) is also [available](https://github.com/privacy-scaling-explorations/maci/blob/dev/circuits/circom/core/non-qv/processMessages.circom). This version is called `processMessagesNonQV` and is to be used when the Poll is not using the quadratic voting feature. Note that by default MACI works with quadratic voting.
+A version working with full credits voting (full) is also [available](https://github.com/privacy-scaling-explorations/maci/blob/main/circuits/circom/coordinator/full/MessageProcessor.circom). This version is called `MessageProcessorFull` and is to be used when the Poll is not using the quadratic or non quadratic voting features. Note that by default MACI works with quadratic voting.
 :::
 
 #### Parameters
@@ -92,7 +156,7 @@ A simplified example using a tree of arity 2:
 
 To prove that `a...d` are leaves of the tree with root `r`, we prove that the leaves have the subroot `s` with depth 2, and _then_ prove that `s` is a member of `r` at depth 1.
 
-The implementation for this is in the `QuinBatchLeavesExists` circuit in `https://github.com/privacy-scaling-explorations/maci/blob/dev/circuits/circom/trees/incrementalQuinTree.circom`.
+The implementation for this is in the `QuinBatchLeavesExists` circuit in `https://github.com/privacy-scaling-explorations/maci/blob/main/circuits/circom/trees/incrementalQuinTree.circom`.
 
 This method requires fewer circuit constraints than if we verified a Merkle proof for each leaf.
 

package/versioned_docs/version-v3.x/technical-references/zk-snark-circuits/setup.md

@@ -37,7 +37,7 @@ MACI's circuits are parameterized, and thus can be configured to support differe
 - **STATE_TREE_DEPTH** = how many users the system supports
 - **VOTE_OPTIONS_TREE_DEPTH** = how many vote options the system supports
 - **MESSAGE_BATCH_SIZE** = how many messages in a batch the circuit should process
-- **INT_STATE_TREE_DEPTH** = how many ballots can be processed per batch when tallying the results (`5 ** INT_STATE_TREE_DEPTH` ballots)
+- **TALLY_PROCESSING_STATE_TREE_DEPTH** = how many ballots can be processed per batch when tallying the results (`2 ** TALLY_PROCESSING_STATE_TREE_DEPTH` ballots)
 
 Please refer to the individual circuit documentation for more details on the inner working of each circuit and where parameters fit.
 
@@ -90,7 +90,7 @@ To test the circuits package, please use `pnpm run test`. This will run all of t
 
 To run individual tests, you can use the following commands (for all other circuits please refer to the `package.json` scripts section):
 
-- `pnpm run test:processMessages` to run the tests for the `processMessages` circuit.
-- `pnpm run test:tallyVotes` to run the tests for the `tallyVotes` circuit.
+- `pnpm run test:messageProcessor` to run the tests for the `MessageProcessor` circuit.
+- `pnpm run test:voteTally` to run the tests for the `VoteTally` circuit.
 
 More details on testing are provided in the [testing section](/docs/guides/testing/testing-introduction) of the documentation.

package/versioned_docs/version-v3.x/technical-references/zk-snark-circuits/tallyVotes.md

@@ -5,7 +5,7 @@ sidebar_label: Tally Votes Circuit
 sidebar_position: 4
 ---
 
-[**Repo link**](https://github.com/privacy-scaling-explorations/maci/blob/dev/circuits/circom/core)
+[**Repo link**](https://github.com/privacy-scaling-explorations/maci/blob/main/circuits/circom/core)
 
 #### Parameters
 
@@ -15,10 +15,10 @@ sidebar_position: 4
 | 1   | State leaf batch depth | Allows $(5^{n})$ users' votes to be processed per batch. |
 | 2   | Vote option tree depth | Allows $(5^{n})$ vote options.                           |
 
-![TallyVotes](/img/circuits/tallyVotes.svg)
+![VoteTally](/img/circuits/tallyVotes.svg)
 
 :::info
-A version working with non quadratic voting (non-qv) is also [available](https://github.com/privacy-scaling-explorations/maci/blob/dev/circuits/circom/core/non-qv/tallyVotes.circom). This version is called `tallyVotesNonQv` and is to be used when the Poll is not using the quadratic voting feature. Note that by default MACI works with quadratic voting.
+A version working with non quadratic and full credits voting (non-qv, full) is also [available](https://github.com/privacy-scaling-explorations/maci/blob/main/circuits/circom/coordinator/non-qv/VoteTally.circom). This version is called `tallyVotes` and is to be used when the Poll is not using the quadratic voting feature. Note that by default MACI works with quadratic voting.
 :::
 
 #### Input signals
@@ -73,7 +73,7 @@ $poseidon_3([tc_r, tc_t, tc_p])$
 
 1. That the coordinator knows the preimage of `sbCommitment`
 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 ** intStateTreeDepth)`
+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/technical-references/zk-snark-circuits/utilities.md

@@ -7,7 +7,7 @@ sidebar_position: 5
 
 #### Process Messages Input Hasher
 
-A utility circuit used by the main `processMessages` circuit to hash its inputs.
+A utility circuit used by the main `MessageProcessor` circuit to hash its inputs.
 
 ![ProcessMessagesInputHasher](/img/circuits/processMessagesInputHasher.svg)
 
@@ -35,15 +35,15 @@ It outputs one field element, which is the SHA256 hash of the following inputs:
 
 #### ResultsCommitmentVerifier
 
-A utility circuit used by the main `tallyVotes` circuit to verify that the results commitment is correct.
+A utility circuit used by the main `VoteTally` circuit to verify that the results commitment is correct.
 
 ![ResultsCommitmentVerifier](/img/circuits/resultsCommitmentVerifier.svg)
 
-#### QuinCheckRoot
+#### QuinaryCheckRoot
 
 Utility circuit that given a quin Merkle root and a list of leaves, check if the root is the correct result of inserting all the leaves into the tree in the given order.
 
-![QuinCheckRoot](/img/circuits/quinCheckRoot.svg)
+![QuinaryCheckRoot](/img/circuits/quinCheckRoot.svg)
 
 #### CalculateTotal
 
@@ -100,11 +100,11 @@ Utility circuit used to unpack an input element.
 
 ![UnpackElement](/img/circuits/unpackElement.svg)
 
-#### QuinSelector
+#### QuinarySelector
 
 Utility circuit used to select one element from an array of n elements at a given index.
 
-![QuinSelector](/img/circuits/quinSelector.svg)
+![QuinarySelector](/img/circuits/quinSelector.svg)
 
 #### Splicer
 
@@ -118,11 +118,11 @@ Utility circuit used to check if a batch of leaves exists in a quinary tree.
 
 ![QuinBatchLeavesExists](/img/circuits/quinBatchLeavesExists.svg)
 
-#### QuinGeneratePathIndices
+#### QuinaryGeneratePathIndices
 
 Utility circuit used to generate the indices needed to traverse the tree until we find the leaf we are looking for.
 
-![QuinGeneratePathIndices](/img/circuits/quinGeneratePathIndices.svg)
+![QuinaryGeneratePathIndices](/img/circuits/quinGeneratePathIndices.svg)
 
 #### ProcessOne
 

package/versioned_docs/version-v3.x/technical-references/zk-snark-circuits/zk-snark-circuits.md

@@ -5,10 +5,10 @@ sidebar_label: zk-SNARK Circuits
 sidebar_position: 1
 ---
 
-MACI has three main zk-SNARK [circuits](https://github.com/privacy-scaling-explorations/maci/tree/dev/circuits):
+MACI has three main zk-SNARK [circuits](https://github.com/privacy-scaling-explorations/maci/tree/main/packages/circuits):
 
-1. ProcessMessages.circom, which takes a batch of encrypted messages, decrypts them, and generates a proof that the coordinator's local processing was performed correctly. [QV](https://github.com/privacy-scaling-explorations/maci/blob/dev/circuits/circom/core/qv/processMessages.circom) and [non-QV](https://github.com/privacy-scaling-explorations/maci/blob/dev/circuits/circom/core/non-qv/processMessages.circom) versions are available.
-2. TallyVotes.circom, which counts votes from users' ballots, batch by batch. [QV](https://github.com/privacy-scaling-explorations/maci/blob/dev/circuits/circom/core/qv/tallyVotes.circom) and [non-QV](https://github.com/privacy-scaling-explorations/maci/blob/dev/circuits/circom/core/non-qv/tallyVotes.circom) versions are available.
+1. ProcessMessages.circom, which takes a batch of encrypted messages, decrypts them, and generates a proof that the coordinator's local processing was performed correctly. [QV](https://github.com/privacy-scaling-explorations/maci/blob/main/circuits/circom/coordinator/qv/MessageProcessor.circom), [non-QV](https://github.com/privacy-scaling-explorations/maci/blob/main/circuits/circom/coordinator/non-qv/MessageProcessor.circom), [Full](https://github.com/privacy-scaling-explorations/maci/blob/main/circuits/circom/coordinator/full/MessageProcessor.circom) versions are available.
+2. TallyVotes.circom, which counts votes from users' ballots, batch by batch. [QV](https://github.com/privacy-scaling-explorations/maci/blob/main/circuits/circom/coordinator/qv/VoteTally.circom) and [non-QV](https://github.com/privacy-scaling-explorations/maci/blob/main/circuits/circom/coordinator/non-qv/VoteTally.circom) versions are available.
 3. PollJoining.circom, which allows users to prove they know a private key for a public key signed up to the MACI smart contract, and to register to a specific poll.
 
 The rest of the circuits are utilities templates that are required for the main circuits to work correctly. These include utilities such as float math, conversion of private keys, and Poseidon hashing/encryption.