@maci-protocol/website 0.0.0-ci.752ce71 → 0.0.0-ci.75ef321

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,13 +57,13 @@ 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 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. 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.
 
 10. Link any issues that the PR is addressing as described in our processes documentation.
 
@@ -131,7 +131,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

@@ -175,5 +175,5 @@ 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 generateMaciKeyPair
+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

@@ -11,7 +11,7 @@ This document will explain how to use each of these options. Hardhat tasks are t
 
 ## 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/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.
+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.
 

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

@@ -34,7 +34,7 @@ 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/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.
+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.
 

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

@@ -580,7 +580,7 @@ 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 ^ messageBatchDepth` 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
 
@@ -747,7 +747,7 @@ 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
 

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

@@ -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

@@ -93,9 +93,9 @@ Edit `circuits/circom/circuits` to include the circuits you would like to compil
     "params": [10],
     "pubs": ["stateRoot"]
   },
-  "ProcessMessages_10-20-2_test": {
-    "file": "./coordinator/qv/processMessages",
-    "template": "ProcessMessages",
+  "MessageProcessorQv_10-20-2_test": {
+    "file": "./coordinator/qv/MessageProcessor",
+    "template": "MessageProcessorQv",
     "params": [10, 20, 2],
     "pubs": [
       "totalSignups",
@@ -109,9 +109,9 @@ Edit `circuits/circom/circuits` to include the circuits you would like to compil
       "voteOptions"
     ]
   },
-  "ProcessMessagesNonQv_10-20-2_test": {
-    "file": "./coordinator/non-qv/processMessages",
-    "template": "ProcessMessagesNonQv",
+  "MessageProcessorNonQv_10-20-2_test": {
+    "file": "./coordinator/non-qv/MessageProcessor",
+    "template": "MessageProcessorNonQv",
     "params": [10, 20, 2],
     "pubs": [
       "totalSignups",
@@ -141,15 +141,15 @@ Edit `circuits/circom/circuits` to include the circuits you would like to compil
       "voteOptions"
     ]
   },
-  "TallyVotes_10-1-2_test": {
-    "file": "./coordinator/qv/tallyVotes",
-    "template": "TallyVotes",
+  "VoteTallyQv_10-1-2_test": {
+    "file": "./coordinator/qv/VoteTally",
+    "template": "VoteTallyQv",
     "params": [10, 1, 2],
     "pubs": ["index", "totalSignups", "sbCommitment", "currentTallyCommitment", "newTallyCommitment"]
   },
-  "TallyVotesNonQv_10-1-2_test": {
-    "file": "./coordinator/non-qv/tallyVotes",
-    "template": "TallyVotesNonQv",
+  "VoteTallyNonQv_10-1-2_test": {
+    "file": "./coordinator/non-qv/VoteTally",
+    "template": "VoteTallyNonQv",
     "params": [10, 1, 2],
     "pubs": ["index", "totalSignups", "sbCommitment", "currentTallyCommitment", "newTallyCommitment"]
   }

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

@@ -43,7 +43,7 @@ function signUp(PublicKey memory _publicKey, bytes memory _signUpPolicyData) pub
 
 ## InitialVoiceCreditProxy
 
-If you'd like to extend the functionality of how votes are distributed among users, you'll need to build you own initial voice credit proxy contract by following the [IInitialVoiceCreditProxy interface](https://github.com/privacy-scaling-explorations/maci/blob/dev/packages/contracts/contracts/interfaces/IInitialVoiceCreditProxy.sol). You can see our [basic example](https://github.com/privacy-scaling-explorations/maci/blob/dev/packages/contracts/contracts/initialVoiceCreditProxy/ConstantInitialVoiceCreditProxy.sol) how it's implemented for constant distribution.
+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 {
@@ -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

@@ -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

@@ -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,7 +170,7 @@ 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.
 

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

@@ -53,6 +53,32 @@ To run Contracts only tests, run:
 pnpm run test
 ```
 
+To run e2e tests for hardhat tasks for `contracts` using the in-memory hardhat network:
+
+```bash
+pnpm run test:hardhat
+```
+
+You can update the `deploy-config.json` file to change policies or other deployment settings used by the test.
+
+You can enhance test reporting and gas cost estimation by adding the following variables to your `.env` file:
+
+```bash
+# CoinMarkerCap api key for prices (gas reporter)
+COINMARKETCAP_API_KEY=
+# Gas price for gas reporter
+# Allows you to manually specify the gas price (e.g. 3 gwei)
+GAS_REPORTER_PRICE=
+```
+
+These variables are used by `hardhat-gas-reporter` to show cost estimates for gas usage in the test reports.
+
+If you would like to run these E2E tests against a different [supported networks](/docs/supported-networks/), you can override the network like this:
+
+```bash
+pnpm exec hardhat test --network {NETWORK} ./tests/e2e/hardhatTasks.test.ts
+```
+
 ### Circuits
 
 To test the circuits, from the main `maci/` directory, run:
@@ -71,10 +97,10 @@ or download them. Please remember to not use these testing `.zkey` files in prod
 
 ### Download `.zkey` files or the witness generation binaries
 
-MACI has two main zk-SNARK circuits, `processMessages` and `tallyVotes`.
+MACI has two main zk-SNARK circuits, `MessageProcessor` and `VoteTally`.
 
 :::info
-The `processMessages` and `tallyVotes` circuits are also provided in a non-quadratic voting (non-QV) and in a full credits voting (full) versions. Currently these new versions have not undergone a trusted setup ceremony.
+The `MessageProcessor` and `VoteTally` circuits are also provided in a non-quadratic voting (non-QV) and in a full credits voting (full) versions. Currently these new versions have not undergone a trusted setup ceremony.
 :::
 
 Each circuit is parameterised and there should be one
@@ -86,7 +112,7 @@ circuits.
 
 Note the locations of the `.zkey` files as the smart contract tasks require them as part of the JSON configuration file.
 
-For testing purposes you can download the required artifacts using the [`download-zkeys:test`](https://github.com/privacy-scaling-explorations/maci/blob/dev/package.json#L15). The script will place all required artifacts inside the `cli/zkeys` folder.
+For testing purposes you can download the required artifacts using the [`download-zkeys:test`](https://github.com/privacy-scaling-explorations/maci/blob/main/package.json#L15). The script will place all required artifacts inside the `cli/zkeys` folder.
 
 You can run the script directly with bash or use pnpm: `pnpm run download:test-zkeys` from the monorepo root.
 

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

@@ -11,17 +11,17 @@ sidebar_position: 5
 
 ### Case: missing `.dat` files
 
-If your logs look like the following, then make sure you have `ProcessMessages_10-2-1-2_test.dat` and `TallyVotes_10-1-2_test.dat` files in the same directory as your zkeys:
+If your logs look like the following, then make sure you have `MessageProcessorQv_10-2-1-2_test.dat` and `VoteTallyQv_10-1-2_test.dat` files in the same directory as your zkeys:
 
 ```
 node build/ts/index.js generateProofs -x 0xf204a4Ef082f5c04bB89F7D5E6568B796096735a \
 >     -sk macisk.49953af3585856f539d194b46c82f4ed54ec508fb9b882940cbe68bbc57e59e \
 >     -o 0 \
 >     -r ~/rapidsnark/build/prover \
->     -wp ./zkeys/ProcessMessages_10-2-1-2_test \
->     -wt ./zkeys/TallyVotes_10-1-2_test \
->     -zp ./zkeys/ProcessMessages_10-2-1-2_test.0.zkey \
->     -zt ./zkeys/TallyVotes_10-1-2_test.0.zkey \
+>     -wp ./zkeys/MessageProcessorQv_10-2-1-2_test \
+>     -wt ./zkeys/VoteTallyQv_10-1-2_test \
+>     -zp ./zkeys/MessageProcessorQv_10-2-1-2_test.0.zkey \
+>     -zt ./zkeys/VoteTallyQv_10-1-2_test.0.zkey \
 >     -t tally.json \
 >     -f proofs
 
@@ -36,7 +36,7 @@ terminate called after throwing an instance of 'std::system_error'
 Aborted (core dumped)
 
 Error: could not generate proof.
-Error: Error executing ./zkeys/ProcessMessages_10-2-1-2_test /tmp/tmp-9904-zG0k8YPTATWB/input.json /tmp/tmp-9904-zG0k8YPTATWB/output.wtns
+Error: Error executing ./zkeys/MessageProcessorQv_10-2-1-2_test /tmp/tmp-9904-zG0k8YPTATWB/input.json /tmp/tmp-9904-zG0k8YPTATWB/output.wtns
     at genProof (/home/ubuntu/maci/circuits/ts/index.ts:44:15)
     at /home/ubuntu/maci/cli/ts/generateProofs.ts:339:25
     at step (/home/ubuntu/maci/cli/build/generateProofs.js:33:23)
@@ -71,7 +71,7 @@ Error: commitment mismatch
 
 This is because commitments are generated using random salts, thus will differ at each `generateProofs` run.
 
-In [core/Poll.ts](https://github.com/privacy-scaling-explorations/maci/blob/dev/packages/core/ts/Poll.ts):
+In [core/Poll.ts](https://github.com/privacy-scaling-explorations/maci/blob/main/packages/core/ts/Poll.ts):
 
 ```
 let newSbSalt = genRandomSalt();
@@ -140,7 +140,7 @@ event MergeMessageAqSubRoots(uint256 indexed _numSrQueueOps);
 event MergeMessageAq(uint256 indexed _messageRoot);
 ```
 
-Please remember to pull the latest MACI repo updates(`git fetch origin && git pull origin dev`) and run `pnpm build` in the root of this monorepo.
+Please remember to pull the latest MACI repo updates(`git fetch origin && git pull origin main`) and run `pnpm build` in the root of this monorepo.
 
 ### Verifier contract found the proof invalid
 
@@ -159,3 +159,48 @@ Error: The verifier contract found the proof invalid.
 ### The on-chain verification of total spent voice credits failed
 
 If you ran the `verify` command and got this error, please ensure consistency in your use of quadratic voting throughout interactions with MACI, including poll deployment, proof generation, and verification.
+
+### Proof generation process is killed
+
+If your terminal output ends like this:
+
+```
+[i] Starting to fetch logs from block 8386826
+[i] Generating proofs of message processing...
+[i] Progress: 1 / 1
+[i] Wait until proof generation is finished
+Killed
+ELIFECYCLE  Command failed with exit code 137.
+```
+
+This typically indicates the proof generation process was terminated due to exceeding the system's available memory limit (exit code `137` = SIGKILL by the OS, often due to OOM).
+
+Increase Node.js' memory allocation by setting the `NODE_OPTIONS` environment variable before running the command:
+
+```bash
+export NODE_OPTIONS="--max-old-space-size=4096"
+# You can increase the value further (e.g., 8192 for 8GB) if your system has enough RAM:
+export NODE_OPTIONS="--max-old-space-size=8192"
+```
+
+### Error: Not enough or too many values for input signals
+
+If you see errors like:
+
+```
+Error: Not enough values for input signal currentVoteWeightsPathElements
+at /home/maci/node_modules/.pnpm/circom_runtime@0.1.28/node_modules/circom_runtime/build/main.cjs:513:27
+...
+```
+
+```
+Error: Too many values for input signal ballots
+at /home/maci/node_modules/.pnpm/circom_runtime@0.1.28/node_modules/circom_runtime/build/main.cjs:513:27
+...
+```
+
+This usually happens when the Merkle tree depth configured in your MACI deployment does not match the depth expected by the zkey files used during proof generation.
+To solve this:
+
+- Download the correct zkey files from a trusted source.
+- Verify that the `stateTreeDepth`, `messageTreeDepth`, and `voteOptionTreeDepth` used in your CLI or config match the values used to generate those zkey files.

package/versioned_docs/version-v3.x/processes/versioning.md

@@ -19,7 +19,7 @@ MACI follows the [Semantic Versioning Specification (SemVer)](https://semver.org
 
 All MACI packages are organized in our monorepo and follow a global release approach, meaning that all packages have the same version.
 
-Currently, MACI core team manually decides when to release and what the version should be. Packages are released [automatically via CI](https://github.com/privacy-scaling-explorations/maci/blob/dev/.github/workflows/release.yml) when a new tag is created in GitHub. [You can view our releases and tags in GitHub](https://github.com/privacy-scaling-explorations/maci/releases).
+Currently, MACI core team manually decides when to release and what the version should be. Packages are released [automatically via CI](https://github.com/privacy-scaling-explorations/maci/blob/main/.github/workflows/release.yml) when a new tag is created in GitHub. [You can view our releases and tags in GitHub](https://github.com/privacy-scaling-explorations/maci/releases).
 
 ## MACI Release Process
 
@@ -37,10 +37,10 @@ Version number '1.2.3' is used here as an example. You should replace the versio
 git clone https://github.com/privacy-scaling-explorations/maci
 ```
 
-3. Switch to the `dev` branch:
+3. Switch to the `main` branch:
 
 ```
-git checkout dev
+git checkout main
 ```
 
 4. Install required dependencies:

package/versioned_docs/version-v3.x/quick-start.md

@@ -73,7 +73,7 @@ Currently, the ceremony artifacts work with MACI version up to 2.x
 In order to run MACI polls, a coordinator is required to publish their MACI public key. You will need to generate a MACI keypair, and treat the private key just as your ethereum private keys. Please store them in a safe place as you won't be able to finish a round if you lose access, or if compromised a bad actor could decrypt the vote and publish them online. You can generate a new key pair using maci-cli by running the following command in the root of the project:
 
 ```bash
-pnpm run generateMaciKeyPair
+pnpm run generate-maci-keypair
 ```
 
 ### Set the .env
@@ -219,7 +219,7 @@ pnpm run prove:[network] --poll [poll-id] \
 ```
 
 :::info
-The `--coordinator-private-key` is the one you generated earlier with `pnpm run generateMaciKeyPair`.
+The `--coordinator-private-key` is the one you generated earlier with `pnpm run generate-maci-keypair`.
 
 `--start-block` is the block number from which to start looking for events from. You can use the block that you deployed the contracts in.
 

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

@@ -28,6 +28,7 @@ sidebar_position: 13
 - [MACI - Starting From Scratch](https://www.youtube.com/watch?v=qVuhWlHnQF0) - Doris Chan 03/2024
 - [MACI Workshop](https://www.youtube.com/watch?v=AimgqnMjG0o) - ctrlc03 04/2024
 - [MACI Starter Kit Demo](https://www.youtube.com/watch?v=pYoBLLtVEoI&t=1s) - Yash 05/2024
+- [The Promise of Blockchain Voting](https://www.youtube.com/watch?v=TQxR7U52ne0) - Sam Richards 06/2024
 - [MACI Tutorial Deploying Contracts and Subgraph](https://www.youtube.com/watch?v=-QA0VB9EUMk) - Crisgarner 09/2024
 - [MACI Tutorial Frontend Deployment 🚀](https://www.youtube.com/watch?v=q0yS8RfwDcw) - Crisgarner 09/2024
 - [Finalizing a MACI Round](https://www.youtube.com/watch?v=nlS3hOC0ljw) - Crisgarner 09/2024