@maci-protocol/website 0.0.0-ci.9342f07 → 0.0.0-ci.9819a21

package/versioned_docs/version-v2.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/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` and ownership assigned to the coordinator.

package/versioned_docs/version-v2.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/contracts/contracts/utils/Params.sol)
 :::
 
 A contract holding three structs:

package/versioned_docs/version-v2.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/contracts/contracts/Poll.sol)
 :::
 
 This contract allows users to submit their votes.

package/versioned_docs/version-v2.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/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-v2.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/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.

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

@@ -6,7 +6,7 @@ sidebar_position: 8
 ---
 
 :::info
-Code location: [VkRegistry.sol](https://github.com/privacy-scaling-explorations/maci/blob/dev/contracts/contracts/VkRegistry.sol)
+Code location: [VkRegistry.sol](https://github.com/privacy-scaling-explorations/maci/blob/main/contracts/contracts/VkRegistry.sol)
 :::
 
 The VkRegistry is a contract that holds the verifying keys for the zk-SNARK circuits. It holds two different sets of keys:

package/versioned_docs/version-v2.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-v2.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/core)
 
 This circuit allows the coordinator to prove that they have correctly processed each message in reverse order, in a consecutive batch of 5 ^ msgBatchDepth 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 [`processMessages`](https://github.com/privacy-scaling-explorations/maci/blob/main/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 pre-requisites for this circuit are:
 
 - the related Poll has ended
@@ -21,7 +21,7 @@ This circuit requires the coordinator's private key, hence a proof for this circ
 ![ProcessMessages](/img/circuits/processMessages_2_0.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/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 non quadratic voting (non-qv) is also [available](https://github.com/privacy-scaling-explorations/maci/blob/main/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.
 :::
 
 #### Parameters
@@ -93,7 +93,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-v2.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
 
@@ -18,7 +18,7 @@ sidebar_position: 4
 ![TallyVotes](/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 voting (non-qv) is also [available](https://github.com/privacy-scaling-explorations/maci/blob/main/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.
 :::
 
 #### Input signals

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

@@ -5,10 +5,10 @@ sidebar_label: zk-SNARK Circuits
 sidebar_position: 1
 ---
 
-MACI has two main zk-SNARK [circuits](https://github.com/privacy-scaling-explorations/maci/tree/dev/circuits):
+MACI has two main zk-SNARK [circuits](https://github.com/privacy-scaling-explorations/maci/tree/main/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/core/qv/processMessages.circom) and [non-QV](https://github.com/privacy-scaling-explorations/maci/blob/main/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/main/circuits/circom/core/qv/tallyVotes.circom) and [non-QV](https://github.com/privacy-scaling-explorations/maci/blob/main/circuits/circom/core/non-qv/tallyVotes.circom) versions are available.
 
 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.
 

package/versioned_docs/version-v3.x/contributing/contributing.md

@@ -57,15 +57,21 @@ Pull requests are great if you want to add a feature or fix a bug. Here's a quic
 
 7. Make the test pass.
 
-8. Commit your changes. Please make sure your forked `dev` branch is synced as well feature/fix branch and there are no "temp" commits (like wip, fix typo/lint/types and etc). We recommend to squash the feature/fix branch commits before creating PR. You can use this command for it:
+8. Commit your changes. Please make sure your forked `main` branch is synced as well feature/fix branch and there are no "temp" commits (like wip, fix typo/lint/types and etc). We recommend to squash the feature/fix branch commits before creating PR. You can use this command for it:
 
 ```bash
-git reset $(git merge-base dev $(git rev-parse --abbrev-ref HEAD))
+git checkout main
+git pull
+git checkout your-branch
+git rebase main
+git reset $(git merge-base main $(git rev-parse --abbrev-ref HEAD))
 ```
 
-9. Push to your fork and submit a pull request on our `dev` branch. Please provide us with some explanation of why you made the changes you made. For new features make sure to explain a standard use case to us.
+9. Before creating a pull request make sure your work is ready. Do not create WIP pull requests and do not skip pre-commit hooks.
 
-10. Link any issues that the PR is addressing as described in our processes documentation.
+10. Push to your fork and submit a pull request on our `main` branch. Please provide us with some explanation of why you made the changes you made. For new features make sure to explain a standard use case to us. Do not remove our PR template and follow all the steps defined in it.
+
+11. Link any issues that the PR is addressing as described in our processes documentation.
 
 ## CI (Github Actions) Tests
 
@@ -131,7 +137,7 @@ Just as in the subject, use the imperative, present tense: "change" not "changed
 
 ### Branch rules
 
-- Branches should generally be created off of the base branch (`dev` )
+- Branches should generally be created off of the base branch (`main` )
 - Avoid long descriptive names for long-lived branches
 - Use kebab-case (no CamelCase)
 - Use grouping tokens (words) at the beginning of your branch names (in a similar way to the `type` of commit)

package/versioned_docs/version-v3.x/core-concepts/key-change.md

@@ -23,14 +23,14 @@ Reverse processing was introduced to prevent a type of attack where a briber wou
 
 Let's take as an example the following:
 
-1. Alice signs up with pub key $pub1$
-2. Bob (Briber) bribes Alice and asks her to submit a key change message to $pub2$ (owned by Bob)
-3. Bob submits a vote with $pub2$
-4. Alice submits a vote with $pub1$
+1. Alice signs up with public key $public1$
+2. Bob (Briber) bribes Alice and asks her to submit a key change message to $public2$ (owned by Bob)
+3. Bob submits a vote with $public2$
+4. Alice submits a vote with $public1$
 
 If messages were processed in the same order as they were submitted, Alice's vote would not be valid, due to it being signed with a private key $priv1$ - which now would not be valid.
 
-On the other hand, due to messages being processed in reverse order, Alice's last message would be counted as valid as the key change would have not been processed yet. Then, Bob's vote would not be counted as valid as the current key for Alice would be $pub1$.
+On the other hand, due to messages being processed in reverse order, Alice's last message would be counted as valid as the key change would have not been processed yet. Then, Bob's vote would not be counted as valid as the current key for Alice would be $public1$.
 
 > Note that a key change message should have the nonce set to 1 in order for it to be valid. We'll see a code example in the next sections.
 
@@ -47,7 +47,7 @@ Let's take a look into a code example:
 ```ts
 const user1Keypair = new Keypair();
 const user2Keypair = new Keypair();
-const secondKeyPair = new Keypair();
+const secondKeypair = new Keypair();
 ```
 
 - Votes will be
@@ -77,10 +77,10 @@ As seen above, we expect the first vote weight 9 to not be counted, but instead
 - Deploy a MaciState locally and sign up
 
 ```ts
-const maciState: MaciState = new MaciState(STATE_TREE_DEPTH);
+const maciState = new MaciState(STATE_TREE_DEPTH);
 // Sign up
-user1StateIndex = maciState.signUp(user1Keypair.pubKey, voiceCreditBalance, BigInt(Math.floor(Date.now() / 1000)));
-user2StateIndex = maciState.signUp(user2Keypair.pubKey, voiceCreditBalance, BigInt(Math.floor(Date.now() / 1000)));
+user1StateIndex = maciState.signUp(user1Keypair.publicKey, voiceCreditBalance, BigInt(Math.floor(Date.now() / 1000)));
+user2StateIndex = maciState.signUp(user2Keypair.publicKey, voiceCreditBalance, BigInt(Math.floor(Date.now() / 1000)));
 // deploy a poll
 pollId = maciState.deployPoll(
   duration,
@@ -95,61 +95,61 @@ pollId = maciState.deployPoll(
 
 ```ts
 const poll = maciState.polls[pollId];
-const command1 = new PCommand(
+const command1 = new VoteCommand(
   BigInt(user1StateIndex),
-  user1Keypair.pubKey,
+  user1Keypair.publicKey,
   user1VoteOptionIndex,
   user1VoteWeight,
   BigInt(1),
   BigInt(pollId),
 );
 
-const signature1 = command1.sign(user1Keypair.privKey);
+const signature1 = command1.sign(user1Keypair.privateKey);
 
 const ecdhKeypair1 = new Keypair();
-const sharedKey1 = Keypair.genEcdhSharedKey(ecdhKeypair1.privKey, coordinatorKeypair.pubKey);
+const sharedKey1 = Keypair.genEcdhSharedKey(ecdhKeypair1.privateKey, coordinatorKeypair.publicKey);
 
 const message1 = command1.encrypt(signature1, sharedKey1);
-poll.publishMessage(message1, ecdhKeypair1.pubKey);
+poll.publishMessage(message1, ecdhKeypair1.publicKey);
 
-const command2 = new PCommand(
+const command2 = new VoteCommand(
   BigInt(user2StateIndex),
-  user2Keypair.pubKey,
+  user2Keypair.publicKey,
   user2VoteOptionIndex,
   user2VoteWeight,
   BigInt(1),
   BigInt(pollId),
 );
 
-const signature2 = command2.sign(user2Keypair.privKey);
+const signature2 = command2.sign(user2Keypair.privateKey);
 
 const ecdhKeypair2 = new Keypair();
-const sharedKey2 = Keypair.genEcdhSharedKey(ecdhKeypair2.privKey, coordinatorKeypair.pubKey);
+const sharedKey2 = Keypair.genEcdhSharedKey(ecdhKeypair2.privateKey, coordinatorKeypair.publicKey);
 
 const message2 = command2.encrypt(signature2, sharedKey2);
-poll.publishMessage(message2, ecdhKeypair2.pubKey);
+poll.publishMessage(message2, ecdhKeypair2.publicKey);
 ```
 
 - User1 submits a key change message with the new vote
 
 ```ts
 const poll = maciState.polls[pollId];
-const command = new PCommand(
+const command = new VoteCommand(
   BigInt(user1StateIndex),
-  secondKeyPair.pubKey,
+  secondKeypair.publicKey,
   user1VoteOptionIndex,
   user1NewVoteWeight,
   BigInt(1),
   BigInt(pollId),
 );
 
-const signature = command.sign(user1Keypair.privKey);
+const signature = command.sign(user1Keypair.privateKey);
 
 const ecdhKeypair = new Keypair();
-const sharedKey = Keypair.genEcdhSharedKey(ecdhKeypair.privKey, coordinatorKeypair.pubKey);
+const sharedKey = Keypair.genEcdhSharedKey(ecdhKeypair.privateKey, coordinatorKeypair.publicKey);
 
 const message = command.encrypt(signature, sharedKey);
-poll.publishMessage(message, ecdhKeypair.pubKey);
+poll.publishMessage(message, ecdhKeypair.publicKey);
 ```
 
 - We process the votes and check that the result is as expected (`user1NewVoteWeight` was 5 and `user2VoteWeight` 3)
@@ -158,8 +158,8 @@ poll.publishMessage(message, ecdhKeypair.pubKey);
 const poll = maciState.polls[pollId];
 poll.processMessages(pollId);
 poll.tallyVotes();
-expect(poll.perVOSpentVoiceCredits[0].toString()).to.eq((user1NewVoteWeight * user1NewVoteWeight).toString());
-expect(poll.perVOSpentVoiceCredits[1].toString()).to.eq((user2VoteWeight * user2VoteWeight).toString());
+expect(poll.perVoteOptionSpentVoiceCredits[0].toString()).to.eq((user1NewVoteWeight * user1NewVoteWeight).toString());
+expect(poll.perVoteOptionSpentVoiceCredits[1].toString()).to.eq((user2VoteWeight * user2VoteWeight).toString());
 ```
 
 - Finally confirm that the keypair was changed for the user1
@@ -168,12 +168,12 @@ expect(poll.perVOSpentVoiceCredits[1].toString()).to.eq((user2VoteWeight * user2
 const poll = maciState.polls[pollId];
 const stateLeaf1 = poll.stateLeaves[user1StateIndex];
 const stateLeaf2 = poll.stateLeaves[user2StateIndex];
-expect(stateLeaf1.pubKey.equals(user1SecondKeypair.pubKey)).to.eq(true);
-expect(stateLeaf2.pubKey.equals(user2Keypair.pubKey)).to.eq(true);
+expect(stateLeaf1.publicKey.equals(user1SecondKeypair.publicKey)).to.eq(true);
+expect(stateLeaf2.publicKey.equals(user2Keypair.publicKey)).to.eq(true);
 ```
 
 We see that is important that we set the final message (the one with the new vote) with nonce 1, as this vote would be counted as the first vote.
 
 :::info
-Tests related to key changes have been added to the [core package](https://github.com/privacy-scaling-explorations/maci/blob/dev/core/ts/__tests__/) and to the [cli package](https://github.com/privacy-scaling-explorations/maci/blob/dev/cli/tests/).
+Tests related to key changes have been added to the [core package](https://github.com/privacy-scaling-explorations/maci/blob/main/core/ts/__tests__/) and to the [cli package](https://github.com/privacy-scaling-explorations/maci/blob/main/cli/tests/).
 :::

package/versioned_docs/version-v3.x/core-concepts/maci-keys.md

@@ -78,7 +78,7 @@ Serialized, these will look like **macipk.0e5194a54562ea4d440ac6a0049a41d4b600e3
 After successfully [installing](/docs/quick-start#installation) MACI, you can easily generate your MACI key pair by running:
 
 ```bash
-pnpm run genMaciKeyPair
+pnpm run generate-maci-keypair
 ```
 
 This command will create the necessary public and private keys required for running various MACI operations.

package/versioned_docs/version-v3.x/core-concepts/poll-types.md

@@ -5,25 +5,25 @@ sidebar_label: Poll types
 sidebar_position: 9
 ---
 
-MACI allows to conduct polls in both a quadratic voting and non quadratic voting fashion. One should be aware that the only distinction between the two happens when messages are processed and votes tallied. On top of that, the Tally smart contract has been split into two different ones, with the non quadratic voting version one being slightly smaller, due to the need of one less function.
+MACI allows to conduct polls in both a quadratic voting and non quadratic voting fashion. One should be aware that the only distinction between the two happens when messages are processed and votes tallied. On top of that, the Tally smart contract has been split into two different ones, with the non quadratic voting version one being slightly smaller, due to the need of one less function. Additionally, there is a variation of non quadratic voting that allows participants to cast their entire voice credit balance for a single option only.
 
 This document will explain how to use each of these options. Hardhat tasks are the currently recommended way to deploy contracts and run polls but you can also use the MACI cli.
 
 ## Quadratic Voting
 
-MACI has always worked with quadratic voting. Users signing up to MACI are assigned a number of voice credits based on certain conditions (enforced by the [initial voice credit proxy contract](https://github.com/privacy-scaling-explorations/maci/blob/dev/contracts/contracts/initialVoiceCreditProxy/InitialVoiceCreditProxy.sol)), and after each vote, the number of voice credits is reduced by the square of the weight of the vote casted. For instance, if the vote weight is 5, a user must have at least 25 voice credits to cast the vote.
+MACI has always worked with quadratic voting. Users signing up to MACI are assigned a number of voice credits based on certain conditions (enforced by the [initial voice credit proxy contract](https://github.com/privacy-scaling-explorations/maci/blob/main/packages/contracts/contracts/initialVoiceCreditProxy/ConstantInitialVoiceCreditProxy.sol)), and after each vote, the number of voice credits is reduced by the square of the weight of the vote casted. For instance, if the vote weight is 5, a user must have at least 25 voice credits to cast the vote.
 
 To run a poll with quadratic voting, the coordinator must deploy the Poll with the mode set to quadratic voting.
 
 ### Using Hardhat tasks
 
-In the deploy-config.json file set the `useQuadraticVoting` value to **true**.
+In the deploy-config.json file set the `mode` value to **qv**.
 
 ```json
 "Poll": {
     "pollDuration": 604800,
-    "coordinatorPubkey": "macipk",
-    "useQuadraticVoting": true
+    "coordinatorPublicKey": "macipk",
+    "mode": "qv"
 }
 ```
 
@@ -37,17 +37,41 @@ pnpm deploy-poll:NETWORK
 
 The non quadratic voting option is a new feature that has been added to MACI with the v1.2 release. It allows to conduct polls without the quadratic voting mechanism. This means that the number of voice credits is not reduced by the square of the weight of the vote casted. This option is useful for polls where the quadratic voting mechanism is not necessary, and it is also slightly cheaper for coordinators to tally votes, as there are less checks required in the Tally smart contract.
 
-To run a poll with non quadratic voting, the coordinator must set the `useQuadraticVoting` parameter to `false` when creating the MACI instance. This will make the MACI instance use the `TallyNonQv` smart contract, which is a smaller version of the `Tally` smart contract, as it does not require the checks for the quadratic voting mechanism.
+To run a poll with non quadratic voting, the coordinator must set the `mode` parameter to `non-qv` when creating the MACI instance. This will make the MACI instance use the `TallyNonQv` smart contract, which is a smaller version of the `Tally` smart contract, as it does not require the checks for the quadratic voting mechanism.
 
 ### Using Hardhat tasks
 
-In the deploy-config.json file set the `useQuadraticVoting` value to **false**.
+In the deploy-config.json file set the `mode` value to **non-qv**.
 
 ```json
 "Poll": {
     "pollDuration": 604800,
-    "coordinatorPubkey": "macipk",
-    "useQuadraticVoting": false
+    "coordinatorPublicKey": "macipk",
+    "mode": "non-qv"
+}
+```
+
+Then run the task to create a poll:
+
+```bash
+pnpm deploy-poll:NETWORK
+```
+
+## Full Credits Voting
+
+Full Credits Voting is a new feature introduced in MACI v3. This voting mode disables the quadratic voting mechanism and requires participants to allocate their entire voice credit balance to a single option. Unlike quadratic voting, where the cost of votes increases quadratically with the number of votes cast, Full Credits Voting uses a linear model: participants spend all their available voice credits on one chosen option. No splitting across multiple options is allowed. This option is useful for polls where the quadratic voting mechanism is not necessary and where it's important to ensure voters fully commit to a single choice—eliminating fragmented or spread-out voting behavior. It also offers a slight cost advantage for coordinators, as tallying is more efficient with fewer checks required in the Tally smart contract.
+
+To run a poll full credits voting, the coordinator must set the `mode` parameter to `full` when creating the MACI instance. This will make the MACI instance use the `TallyNonQv` smart contract, which is a smaller version of the `Tally` smart contract, as it does not require the checks for the quadratic voting mechanism.
+
+### Using Hardhat tasks
+
+In the deploy-config.json file set the `mode` value to **full**.
+
+```json
+"Poll": {
+    "pollDuration": 604800,
+    "coordinatorPublicKey": "macipk",
+    "mode": "full"
 }
 ```
 

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

@@ -11,7 +11,7 @@ Currently, you can configure the following parameters for a poll:
 
 - Poll duration, in the form of a unix timestamp for start and end times. This allows polls to be scheduled to start at a certain time, and run for a certain amount of time.
 - Vote option - how many vote options are allowed for a poll.
-- Vote mode - quadratic or non quadratic voting. One should be aware that the only distinction between the two happens when messages are processed and votes tallied.
+- Vote mode - quadratic, non quadratic, full credits voting. One should be aware that the only distinction between them happens when messages are processed and votes tallied.
 - Policy - the Excubiae policy that will be used to gate access to the poll.
 - Initial voice credit proxy - the initial voice credit proxy that will be used to assign voice credits to voters.
 - Relayer - the list of addresses that will be able to relay messages on behalf of other users (for now this is recommended to be the coordinator only)
@@ -23,7 +23,7 @@ The full configuration for a poll looks like this:
 "Poll": {
     "pollStartDate": 3600,
     "pollEndDate": 3600,
-    "coordinatorPubkey": "macipk.9a59264310d95cfd8eb7083aebeba221b5c26e77427f12b7c0f50bc1cc35e621",
+    "coordinatorPublicKey": "macipk.9a59264310d95cfd8eb7083aebeba221b5c26e77427f12b7c0f50bc1cc35e621",
     "useQuadraticVoting": false,
     "policy": "FreeForAllPolicy",
     "relayers": "0x0000000000000000000000000000000000000000",
@@ -34,19 +34,19 @@ The full configuration for a poll looks like this:
 
 ## Quadratic Voting
 
-MACI has always worked with quadratic voting. Users joining a Poll are assigned a number of voice credits based on certain conditions (enforced by the [initial voice credit proxy contract](https://github.com/privacy-scaling-explorations/maci/blob/dev/contracts/contracts/initialVoiceCreditProxy/InitialVoiceCreditProxy.sol)), and after each vote, the number of voice credits is reduced by the square of the weight of the vote casted. For instance, if the vote weight is 5, a user must have at least 25 voice credits to cast the vote.
+MACI has always worked with quadratic voting. Users joining a Poll are assigned a number of voice credits based on certain conditions (enforced by the [initial voice credit proxy contract](https://github.com/privacy-scaling-explorations/maci/blob/main/packages/contracts/contracts/initialVoiceCreditProxy/ConstantInitialVoiceCreditProxy.sol)), and after each vote, the number of voice credits is reduced by the square of the weight of the vote casted. For instance, if the vote weight is 5, a user must have at least 25 voice credits to cast the vote.
 
 To run a poll with quadratic voting, the coordinator must deploy the Poll with the mode set to quadratic voting.
 
 ### Using Hardhat tasks
 
-In the deploy-config.json file set the `useQuadraticVoting` value to **true**.
+In the deploy-config.json file set the `mode` value to **qv**.
 
 ```json
 "Poll": {
     [...]
-    "coordinatorPubkey": "macipk",
-    "useQuadraticVoting": true
+    "coordinatorPublicKey": "macipk",
+    "mode": "qv"
 }
 ```
 
@@ -60,17 +60,41 @@ pnpm deploy-poll:NETWORK
 
 The non quadratic voting option is a new feature that has been added to MACI with the v1.2 release. It allows to conduct polls without the quadratic voting mechanism. This means that the number of voice credits is not reduced by the square of the weight of the vote casted. This option is useful for polls where the quadratic voting mechanism is not necessary, and it is also slightly cheaper for coordinators to tally votes, as there are less checks required in the Tally smart contract.
 
-To run a poll with non quadratic voting, the coordinator must set the `useQuadraticVoting` parameter to `false` when creating the MACI instance.
+To run a poll with non quadratic voting, the coordinator must set the `mode` parameter to `non-qv` when creating the MACI instance.
 
 ### Using Hardhat tasks
 
-In the deploy-config.json file set the `useQuadraticVoting` value to **false**.
+In the deploy-config.json file set the `mode` value to **non-qv**.
 
 ```json
 "Poll": {
     [...]
-    "coordinatorPubkey": "macipk",
-    "useQuadraticVoting": false
+    "coordinatorPublicKey": "macipk",
+    "mode": "non-qv"
+}
+```
+
+Then run the task to create a poll:
+
+```bash
+pnpm deploy-poll:NETWORK
+```
+
+## Full Credits Voting
+
+Full Credits Voting is a new feature introduced in MACI v3. This voting mode disables the quadratic voting mechanism and requires participants to allocate their entire voice credit balance to a single option. Unlike quadratic voting, where the cost of votes increases quadratically with the number of votes cast, Full Credits Voting uses a linear model: participants spend all their available voice credits on one chosen option. No splitting across multiple options is allowed. This option is useful for polls where the quadratic voting mechanism is not necessary and where it's important to ensure voters fully commit to a single choice—eliminating fragmented or spread-out voting behavior. It also offers a slight cost advantage for coordinators, as tallying is more efficient with fewer checks required in the Tally smart contract.
+
+To run a poll with full credits voting, the coordinator must set the `mode` parameter to `full` when creating the MACI instance.
+
+### Using Hardhat tasks
+
+In the deploy-config.json file set the `mode` value to **full**.
+
+```json
+"Poll": {
+    [...]
+    "coordinatorPublicKey": "macipk",
+    "mode": "full"
 }
 ```