@maci-protocol/website 0.0.0-ci.c8b9410 → 0.0.0-ci.c92e3dd

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

@@ -77,25 +77,25 @@ Remember that if on a ARM64 chip, you will not be able to compile the c++ witnes
 
 ### Configure circomkit
 
-Edit `circuits/circom/circuits` to include the circuits you would like to compile. This comes already configured with the two main coordinator circuits, in both qv and non qv variants, as well as the client side circuit. The parameters are designed to support testing use cases:
+Edit `circuits/circom/circuits` to include the circuits you would like to compile. This comes already configured with the main coordinator circuits, in qv, non qv and full credits variants, as well as the client side circuit. The parameters are designed to support testing use cases:
 
 ```json
 {
   "PollJoining_10_test": {
-    "file": "./anon/voter/PollJoining",
+    "file": "./voter/PollJoining",
     "template": "PollJoining",
     "params": [10],
     "pubs": ["nullifier", "stateRoot", "pollPublicKey", "pollId"]
   },
   "PollJoined_10_test": {
-    "file": "./anon/voter/PollJoined",
+    "file": "./voter/PollJoined",
     "template": "PollJoined",
     "params": [10],
     "pubs": ["stateRoot"]
   },
-  "ProcessMessages_10-20-2_test": {
-    "file": "./core/qv/processMessages",
-    "template": "ProcessMessages",
+  "MessageProcessorQv_10-20-2_test": {
+    "file": "./coordinator/qv/MessageProcessor",
+    "template": "MessageProcessorQv",
     "params": [10, 20, 2],
     "pubs": [
       "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": "./core/non-qv/processMessages",
-    "template": "ProcessMessagesNonQv",
+  "MessageProcessorNonQv_10-20-2_test": {
+    "file": "./coordinator/non-qv/MessageProcessor",
+    "template": "MessageProcessorNonQv",
     "params": [10, 20, 2],
     "pubs": [
       "totalSignups",
@@ -125,15 +125,31 @@ Edit `circuits/circom/circuits` to include the circuits you would like to compil
       "voteOptions"
     ]
   },
-  "TallyVotes_10-1-2_test": {
-    "file": "./core/qv/tallyVotes",
-    "template": "TallyVotes",
+  "ProcessMessagesFull_10-20-2_test": {
+    "file": "./coordinator/non-qv/MessageProcessor",
+    "template": "MessageProcessorFull",
+    "params": [10, 20, 2],
+    "pubs": [
+      "totalSignups",
+      "index",
+      "batchEndIndex",
+      "currentSbCommitment",
+      "newSbCommitment",
+      "outputBatchHash",
+      "actualStateTreeDepth",
+      "coordinatorPublicKeyHash",
+      "voteOptions"
+    ]
+  },
+  "VoteTallyQv_10-1-2_test": {
+    "file": "./coordinator/qv/VoteTally",
+    "template": "VoteTallyQv",
     "params": [10, 1, 2],
     "pubs": ["index", "totalSignups", "sbCommitment", "currentTallyCommitment", "newTallyCommitment"]
   },
-  "TallyVotesNonQv_10-1-2_test": {
-    "file": "./core/non-qv/tallyVotes",
-    "template": "TallyVotesNonQv",
+  "VoteTallyNonQv_10-1-2_test": {
+    "file": "./coordinator/non-qv/VoteTally",
+    "template": "VoteTallyNonQv",
     "params": [10, 1, 2],
     "pubs": ["index", "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) version. 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.
 
@@ -97,19 +123,19 @@ From the root folder, run:
 **for c++ witness generator**
 
 ```bash
-pnpm build:circuits-c -- --outPath ../testing/zkeys
+pnpm build:circuits-c -- --outPath ../../zkeys
 ```
 
 **for wasm witness generator**
 
 ```bash
-pnpm build:circuits-wasm -- --outPath ../testing/zkeys
+pnpm build:circuits-wasm -- --outPath ../../zkeys
 ```
 
 **generate zkeys**
 
 ```bash
-pnpm setup:zkeys --outPath ../testing/zkeys
+pnpm setup:zkeys --outPath ../../zkeys
 ```
 
 ### Check the Rapidsnark binary
@@ -151,6 +177,12 @@ To run e2e tests with normal voting (not quadratic voting):
 pnpm run test:e2e-non-qv
 ```
 
+To run e2e tests with full credits voting (full):
+
+```bash
+pnpm run test:e2e-full
+```
+
 To run integration tests:
 
 ```bash

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

@@ -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
@@ -142,7 +142,7 @@ The VerifyingKeysRegistry hold the verifying keys used to verify the proofs, on
 | **messageTreeDepth**              | Defines how many messages (votes) the system supports.                               |
 | **voteOptionTreeDepth**           | Defines how many vote options the system supports.                                   |
 | **messageBatchDepth**             | Defines how many messages in a batch can the circuit process.                        |
-| **zkeys**                         | Defines the path to the zkey files for QV and Non QV keys.                           |
+| **zkeys**                         | Defines the path to the zkey files for QV, Non QV and Full Credits keys.             |
 | **pollJoiningZkey**               | Defines the zkey to the poll joining circuit which allows to join polls for voting.  |
 | **pollJoinedZkey**                | Defines the zkey to the poll joined circuit which allows to prove you joined a poll. |
 
@@ -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