@maci-protocol/website 0.0.0-ci.2653bc0

package/versioned_docs/version-v1.2/coordinator-processing.md

@@ -0,0 +1,46 @@
+---
+title: Coordinator local processing
+description: How does the coordinator process and tally messages locally
+sidebar_label: Coordinator local processing
+sidebar_position: 16
+---
+
+# Coordinator local processing
+
+The coordinator is responsible for processing and tallying messages locally, before generating proofs that this was done correctly using the zk-SNARK circuits.
+
+To summarize, the coordinator's goal here is to process all of the messages that were submitted by MACI's voters, then tally the votes based on the valid vote messages. Furthermore, each batch processed should be able to be verified by a zk-SNARK proof.
+
+## Which MACI's components are involved
+
+The following diagram, shows which components are involved and at which step of the way
+
+![components involved](/img/coordinatorComponents.svg)
+
+## What does the process look like?
+
+![processing](/img/offlineProcessing.svg)
+
+Zooming in..
+
+**Message processing**
+
+![message processing](/img/messageProcessingLocal.svg)
+
+**Vote tallying**
+
+![vote tallying](/img/voteTallyingLocal.svg)
+
+## What does the process look like when including the zk-SNARK proofs
+
+**Process of completing a Poll**
+
+![processing with proofs](/img/completingAPoll.svg)
+
+**Process of generating proofs**
+
+![generating proofs](/img/generateProofs.svg)
+
+**Tally commitments**
+
+![tally commitments](/img/tallyCommitments.svg)

package/versioned_docs/version-v1.2/deployment.md

@@ -0,0 +1,122 @@
+---
+title: MACI Deployment
+description: MACI Smart Contracts deployment
+sidebar_label: MACI deployment
+sidebar_position: 24
+---
+
+# MACI Deployment
+
+Currently, it is possible to deploy MACI contracts in two ways:
+
+- using the cli (`maci-cli`)
+- using the hardhat tasks inside the `maci-contracts` package
+
+## MACI Deployment Steps
+
+In order, these are the steps for contract deployment:
+
+1. Deploy crypto (Hasher, Poseidon)
+2. Deploy VK Registry
+3. Set verification keys
+4. Deploy VoiceCreditProxy
+5. Deploy Gatekeeper
+6. Deploy Verifier
+7. Deploy Topup credit
+8. Deploy MessageProcessorFactory, PollFactory, SubsidyFactory, TallyFactory
+9. Deploy MACI, AccQueueQuinaryMaci
+10. Deploy Poll, AccQueueQuinaryMaci, MessageProcessor, Tally and Subsidy (optional)
+
+### Note on ZKey artifacts
+
+For testing purposes, you can use the test zkeys and artifacts that you can download using `pnpm download:test-zkeys`. For production use, you can download the most recent artifacts that have undergone a trusted setup. Please refer to the [Trusted Setup](/docs/v1.2/trusted-setup) section for more information. To download those, please use `pnpm download:ceremony-zkeys`.
+
+Please do not use test artifacts in production. If you do require zKeys configured for larger param sizes, please reach out to us if you will be using them in production and we'll discuss running a new ceremony for those parameters. To build new circuits artifacts for testing purposes, please refer to the [installation page](/docs/v1.2/installation/#configure-circomkit) and to the [circuits](/docs/v1.2/circuits) section.
+
+### Deployment using `maci-cli`
+
+```bash
+maci-cli deployVkRegistry
+maci-cli setVerifyingKeys \
+    --state-tree-depth 10 \
+    --int-state-tree-depth 1 \
+    --msg-tree-depth 2 \
+    --vote-option-tree-depth 2 \
+    --msg-batch-depth 1 \
+    --process-messages-zkey ./zkeys/ProcessMessages_10-2-1-2_test/ProcessMessages_10-2-1-2_test.0.zkey \
+    --tally-votes-zkey ./zkeys/TallyVotes_10-1-2_test/TallyVotes_10-1-2_test.0.zkey
+maci-cli create --stateTreeDepth 10 --use-quadratic-voting true
+maci-cli deployPoll \
+    --pubkey coordinator-public-key \
+    --duration 300 \
+    --int-state-tree-depth 1 \
+    --msg-tree-depth 2 \
+    --msg-batch-depth 1 \
+    --vote-option-tree-depth 2 \
+    --subsidy-enabled false
+```
+
+:::info
+For quadratic voting polls, you can use the `--use-quadratic-voting true` flag when creating the MACI instance.
+For non-quadratic voting polls, you can use the `--use-quadratic-voting false` flag when creating the MACI instance.
+:::
+
+### Deployment using `maci-contracts` hardhat tasks
+
+1. Take the `deploy-config-example.json` file and copy it over to `deploy-config.json`
+2. Update the fields as necessary:
+
+```json
+{
+  "sepolia": {
+    "ConstantInitialVoiceCreditProxy": {
+      "deploy": true,
+      "amount": 99
+    },
+    "FreeForAllGatekeeper": {
+      "deploy": false
+    },
+    "EASGatekeeper": {
+      "deploy": true,
+      "easAddress": "0xC2679fBD37d54388Ce493F1DB75320D236e1815e",
+      "schema": "0xe2636f31239f7948afdd9a9c477048b7fc2a089c347af60e3aa1251e5bf63e5c",
+      "attester": "attester-address"
+    },
+    "MACI": {
+      "stateTreeDepth": 10,
+      "gatekeeper": "EASGatekeeper"
+    },
+    "VkRegistry": {
+      "stateTreeDepth": 10,
+      "intStateTreeDepth": 1,
+      "messageTreeDepth": 2,
+      "voteOptionTreeDepth": 2,
+      "messageBatchDepth": 1,
+      "processMessagesZkey": "../cli/zkeys/ProcessMessages_10-2-1-2_test/ProcessMessages_10-2-1-2_test.0.zkey",
+      "tallyVotesZkey": "../cli/zkeys/TallyVotes_10-1-2_test/TallyVotes_10-1-2_test.0.zkey"
+    },
+    "Poll": {
+      "pollDuration": 30,
+      "coordinatorPubkey": "macipk.ea638a3366ed91f2e955110888573861f7c0fc0bb5fb8b8dca9cd7a08d7d6b93",
+      "subsidyEnabled": false,
+      "useQuadraticVoting": true
+    }
+  }
+}
+```
+
+3. Fill the `.env` file with the appropriate data (you will find an example in the `.env.example` file:
+   - your mnemonic
+   - an RPC key
+4. Run `pnpm deploy` to deploy the contracts (you can specify the network by appending `:network` to the command, e.g. `pnpm deploy:sepolia` - please refer to the available networks on the `package.json` scripts section)
+5. Run `pnpm deploy-poll` to deploy your first Poll (you can specify the network by appending `:network` to the command, e.g. `pnpm deploy-poll:sepolia` - please refer to the available networks on the `package.json` scripts section)
+
+:::info
+Should you wish to deploy on a different network, you will need to update the [contracts/tasks/helpers/constants.ts](https://github.com/privacy-scaling-explorations/maci/blob/dev/contracts/tasks/helpers/constants.ts) file.
+:::
+
+6. You will find all of the deployed contracts addresses and configs in the `deployed-contracts.json` file inside the contracts folder.
+
+:::info
+You can find more information on integration and usage in the [Integrating MACI](/docs/v1.2/integrating) section.
+:::

package/versioned_docs/version-v1.2/installation.md

@@ -0,0 +1,175 @@
+---
+title: Installing MACI
+description: How to install MACI
+sidebar_label: Installation
+sidebar_position: 5
+---
+
+# Installation
+
+## Requirements
+
+You need the following to use MACI:
+
+- Node.js: use [`nvm`](https://github.com/nvm-sh/nvm) to install it. MACI has
+  been tested with Node 14, 16, 18 and 20. We do however recommend to use Node 18 or Node 20 as Node 14 is deprecated and Node 16 will soon be deprecated too.
+- The [`rapidsnark`](https://github.com/iden3/rapidsnark) tool if running on an intel chip (this allows for faster proof generation vs snarkjs).
+
+> Note that MACI works on Linux and MacOS. It has not been tested on Windows, however it should work on Windows Subsystem for Linux (WSL). Keep in mind that when using MACI e2e on a non intel chip, tests will run using snarkjs with WASM. This will result in slower proof generation.
+
+## Installation
+
+### Install `rapidsnark` (if on an intel chip)
+
+First, install dependencies:
+
+```bash
+sudo apt-get install build-essential cmake libgmp-dev libsodium-dev nasm curl m4
+```
+
+If you're running on **MacOS with an intel chip**, install dependencies by running the following command:
+
+```bash
+brew install cmake gmp libsodium nasm
+```
+
+Next, clone `rapidsnark` and build it:
+
+```bash
+git clone https://github.com/iden3/rapidsnark.git && \
+cd rapidsnark
+
+pnpm install && \
+git submodule init && \
+git submodule update && \
+./build_gmp.sh host && \
+mkdir build_prover && cd build_prover && \
+cmake .. -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=../package && \
+make -j4 && make install
+```
+
+Note the location of the `rapidsnark` binary (e.g.
+`/home/user/rapidsnark/build/prover`).
+
+For more information, please check rapidsnark [github repo](https://github.com/iden3/rapidsnark)
+
+### Install circom v2:
+
+https://docs.circom.io/
+
+Note the location of the `circom` binary (e.g. `$HOME/.cargo/bin/circom`), as you will need it later.
+
+### Install MACI
+
+```bash
+git clone https://github.com/privacy-scaling-explorations/maci.git && \
+cd maci && \
+pnpm i && \
+pnpm run build
+```
+
+#### On Intel chips (no ARM64)
+
+Install dependencies:
+
+```bash
+sudo apt-get install libgmp-dev nlohmann-json3-dev nasm g++
+```
+
+:::info
+Remember that if on a ARM64 chip, you will not be able to compile the c++ witness generator and thus use rapidsnark. Please follow instructions for WASM artifacts, in case you decide to recompile artifacts.
+:::
+
+### Decide whether you need to compile new circuits or use the test ones
+
+If you are going to be making any changes to the circom circuits, then the following will apply to you. Otherwise, you can skip to the [Download `.zkey` files](#download-zkey-files-if-you-would-like-to-use-the-default-parameters-or-the-trusted-setup-artifacts) section.
+
+#### Configure circomkit
+
+Edit `circuits/circom/circuits` to include the circuits you would like to compile. This comes already configured with the three main circuits and with testing parameters:
+
+```json
+{
+  "ProcessMessages_10-2-1-2_test": {
+    "file": "processMessages",
+    "template": "ProcessMessages",
+    "params": [10, 2, 1, 2],
+    "pubs": ["inputHash"]
+  },
+  "ProcessMessagesNonQv_10-2-1-2_test": {
+    "file": "processMessagesNonQv",
+    "template": "ProcessMessagesNonQv",
+    "params": [10, 2, 1, 2],
+    "pubs": ["inputHash"]
+  },
+  "TallyVotes_10-1-2_test": {
+    "file": "tallyVotes",
+    "template": "TallyVotes",
+    "params": [10, 1, 2],
+    "pubs": ["inputHash"]
+  },
+  "TallyVotesNonQv_10-1-2_test": {
+    "file": "tallyVotesNonQv",
+    "template": "TallyVotesNonQv",
+    "params": [10, 1, 2],
+    "pubs": ["inputHash"]
+  }
+}
+```
+
+### Generate `.zkey` files
+
+If you wish to generate `.zkey` files from scratch, first navigate to `circuits/circom`
+and edit `circuits.json`. Set the parameters you need.
+
+Next, run the following to compile the circuits with parameters you specified:
+
+**for the c++ witness generator**
+
+```bash
+pnpm test:circuits-c
+```
+
+**for the wasm witness generator**
+
+```bash
+pnpm build:circuits-wasm
+```
+
+Finally, generate the `.zkey` files. This may require a lot of memory and time.
+
+```bash
+pnpm setup:zkeys
+```
+
+> If on a ARM64 chip, the above will work with the wasm witness only. The errors you will get for the c++ witness are:
+>
+> ```bash
+> main.cpp:9:10: fatal error: 'nlohmann/json.hpp' file not found
+> #include <nlohmann/json.hpp>
+>        ^~~~~~~~~~~~~~~~~~~
+> 1 error generated.
+> ```
+
+### Download `.zkey` files (if you would like to use the default parameters or the trusted setup artifacts)
+
+MACI has two main zk-SNARK circuits (plus an optional Subsidy circuit). Each circuit is parameterised. There should be one
+`.zkey` file for each circuit and set of parameters.
+
+Unless you wish to generate a fresh set of `.zkey` files, you should obtain
+them from someone who has performed a multi-party trusted setup for said
+circuits. For more details on which artifacts have undergone a trusted setup, please refer to the [Trusted Setup](/docs/v1.2/trusted-setup) page.
+
+Note the locations of the `.zkey` files as the CLI requires them as command-line flags.
+
+**Download test artifacts**
+
+```bash
+pnpm download:test-zkeys
+```
+
+**Download ceremony artifacts**
+
+```bash
+pnpm download:ceremony-zkeys
+```

package/versioned_docs/version-v1.2/integrating.md

@@ -0,0 +1,200 @@
+---
+title: Integrating MACI
+description: How to integrate MACI into your application
+sidebar_label: Integrating
+sidebar_position: 13
+---
+
+# Integrating MACI
+
+MACI can be used in any protocol that requires collusion resistance, for instance it has been proven to be quite efficient when integrated in quadratic funding applications such as [clr.fund](https://github.com/clrfund/monorepo) and [qfi](https://github.com/quadratic-funding/qfi/tree/feat/code-freeze).
+
+Here we will be looking at QFI and how it was used. Please note that this will be expanded as QFI is updated to use the newest version of MACI. Should you decide to integrate MACI in the meantime, feel free to open an issue on the GitHub repo.
+
+## Deployment
+
+First, you need to deploy contracts to start using MACI. This can be easily done via `maci-cli`.
+Deployment order is:
+
+1. Deploy crypto (Hasher, Poseidon)
+2. Deploy VK Registry
+3. Set verification keys
+4. Deploy VoiceCreditProxy
+5. Deploy Gatekeeper
+6. Deploy Verifier
+7. Deploy Topup credit
+8. Deploy MessageProcessorFactory, PollFactory, SubsidyFactory, TallyFactory
+9. Deploy MACI, AccQueueQuinaryMaci
+10. Deploy Poll, AccQueueQuinaryMaci, MessageProcessor, Tally and Subsidy (optional)
+
+Before running the deploy command make sure you have [zkey files](/docs/v1.2/trusted-setup) from trusted setup and env variables `ETH_PROVIDER` (RPC endpoint) and `ETH_SK` (wallet private key) are set. For production environment make sure you don't use zkey files from our examples.
+
+:::note Non Quadratic Voting
+
+Make sure that if you intend to run a non quadratic voting Poll, you set the **NonQv** zKey files on the VkRegistry contract, as well as deploy the Poll with the option `--use-quadratic-voting false`. Finally, remember to use the correct zk-SNARK artifacts (zKeys, and witnesses) in the genProof/prove commands.
+
+:::
+
+```bash
+maci-cli deployVkRegistry
+maci-cli setVerifyingKeys \
+    --state-tree-depth 10 \
+    --int-state-tree-depth 1 \
+    --msg-tree-depth 2 \
+    --vote-option-tree-depth 2 \
+    --msg-batch-depth 1 \
+    --process-messages-zkey ./zkeys/ProcessMessages_10-2-1-2_test/ProcessMessages_10-2-1-2_test.0.zkey \
+    --tally-votes-zkey ./zkeys/TallyVotes_10-1-2_test/TallyVotes_10-1-2_test.0.zkey
+maci-cli create --stateTreeDepth 10 --use-quadratic-voting true
+maci-cli deployPoll \
+    --pubkey coordinator-public-key \
+    --duration 30 \
+    --int-state-tree-depth 1 \
+    --msg-tree-depth 2 \
+    --msg-batch-depth 1 \
+    --vote-option-tree-depth 2 \
+    --subsidy-enabled false
+```
+
+## Signups and votes
+
+Next, you can start accept user signup and votes. This can be done via `maci-cli` as well:
+
+```bash
+maci-cli signup \
+    --pubkey user-public-key
+maci-cli publish \
+    --pubkey user-public-key \
+    --privkey user-private-key \
+    --state-index 1 \
+    --vote-option-index 0 \
+    --new-vote-weight 9 \
+    --nonce 1 \
+    --poll-id 0
+```
+
+## Poll finalization
+
+As a coordinator, first you need to merge signups and messages (votes). Signups and messages are stored in a queue so when the poll in over, the coordinator needs to create the tree from the queue. This optimization is needed to reduce gas cost for voters. Then coordinator generates proofs for the message processing, tally and subsidy calculations. This allows to publish the poll results on-chain and then everyone can verify the results when the poll is over.
+
+```bash
+maci-cli mergeSignups --poll-id 0
+maci-cli mergeMessages --poll-id 0
+maci-cli genProofs \
+    --privkey coordinator-private-key \
+    --poll-id 0 \
+    --process-zkey ./zkeys/ProcessMessages_10-2-1-2_test/ProcessMessages_10-2-1-2_test.0.zkey \
+    --tally-zkey ./zkeys/TallyVotes_10-1-2_test/TallyVotes_10-1-2_test.0.zkey \
+    --tally-file tally.json \
+    --output proofs/ \
+    --tally-wasm ./zkeys/TallyVotes_10-1-2_test/TallyVotes_10-1-2_test_js/TallyVotes_10-1-2_test.wasm \
+    --process-wasm ./zkeys/ProcessMessages_10-2-1-2_test/ProcessMessages_10-2-1-2_test_js/ProcessMessages_10-2-1-2_test.wasm \
+    --wasm
+maci-cli proveOnChain \
+    --poll-id 0 \
+    --proof-dir proofs/ \
+    --subsidy-enabled false
+maci-cli verify \
+    --poll-id 0 \
+    --subsidy-enabled false \
+    --tally-file tally.json # this file is generated in genProofs
+```
+
+## MACI Contract
+
+The MACI contract is the core of the protocol. Contracts can inherit from MACI and thus expose the signup and topup functions. As with standalone MACI, one would need to deploy a [sign up gatekeeper](/docs/v1.2/contracts#signupgatekeeper) as well as the [voice credit proxy](/docs/v1.2/contracts#voicecreditproxy).
+
+As an example, within the quadratic funding infrastructure project, the QFI contract inherits from MACI and allows sign up via the contribute function.
+
+```javascript
+function contribute(
+    PubKey calldata pubKey,
+    uint256 amount
+    ) external {
+
+    [..snip]
+
+    uint256 voiceCredits = amount / voiceCreditFactor;
+    // The user is marked as registered here upon contribution
+    grantRoundToContributors[nextGrantRoundId][msg.sender] = ContributorStatus(voiceCredits, true);
+
+    // Increase the number of contributors for this round
+    grantRoundToContributorsCount[nextGrantRoundId]++;
+
+    bytes memory signUpGatekeeperAndInitialVoiceCreditProxyData = abi.encode(
+        msg.sender,
+        voiceCredits
+    );
+
+    signUp(
+        pubKey,
+        signUpGatekeeperAndInitialVoiceCreditProxyData,
+        signUpGatekeeperAndInitialVoiceCreditProxyData
+    );
+
+    [..snip]
+
+    emit ContributionSent(msg.sender, amount);
+}
+```
+
+## InitialVoiceCreditProxy
+
+If you'd like to extend the functionality of how votes are distributed among users, you need to extend [InitialVoiceCreditProxy](https://github.com/privacy-scaling-explorations/maci/blob/dev/contracts/contracts/initialVoiceCreditProxy/InitialVoiceCreditProxy.sol) contract. You can see our [basic example](https://github.com/privacy-scaling-explorations/maci/blob/dev/contracts/contracts/initialVoiceCreditProxy/ConstantInitialVoiceCreditProxy.sol) how it's implemented for constant distribution.
+
+```javascript
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.10;
+
+import { InitialVoiceCreditProxy } from "./InitialVoiceCreditProxy.sol";
+
+/// @title ConstantInitialVoiceCreditProxy
+/// @notice This contract allows to set a constant initial voice credit balance
+/// for MACI's voters.
+contract ConstantInitialVoiceCreditProxy is InitialVoiceCreditProxy {
+  /// @notice the balance to be returned by getVoiceCredits
+  uint256 internal balance;
+
+  /// @notice creates a new ConstantInitialVoiceCreditProxy
+  /// @param _balance the balance to be returned by getVoiceCredits
+  constructor(uint256 _balance) payable {
+    balance = _balance;
+  }
+
+  /// @notice Returns the constant balance for any new MACI's voter
+  /// @return balance
+  function getVoiceCredits(address, bytes memory) public view override returns (uint256) {
+    return balance;
+  }
+}
+```
+
+## Subsidy
+
+It's also possible to use subsidy feature when coordinator deploys polls, proves poll results on-chain and when poll results are verified. This contract is used to verify that the subsidy calculations are correct. It is also used to update the subsidy commitment if the proof is valid. To enable this feature just provide `--subsidy-enabled` or `-se` for `maci-cli` commands (`deployPoll`, `proveOnChain`, `verify`).
+
+## Poll Contract
+
+On the other hand, the Poll contract can be inherited to expose functionality such as top ups and publishing of messages/commands.
+
+For instance, within QFI, the `publishMessageBatch` function call the `publishMessage` function of Poll, as shown below:
+
+```javascript
+function publishMessageBatch(
+    Message[] calldata _messages,
+    PubKey[] calldata _encPubKeys
+) external {
+    // Check that the two arrays have the same length
+    require(
+        _messages.length == _encPubKeys.length,
+        "GrantRound: _messages and _encPubKeys should be the same length"
+    );
+
+    uint256 batchSize = _messages.length;
+    for (uint8 i = 0; i < batchSize; ++i) {
+        publishMessage(_messages[i], _encPubKeys[i]);
+    }
+
+    emit Voted(msg.sender);
+}
+```

package/versioned_docs/version-v1.2/introduction.md

@@ -0,0 +1,94 @@
+---
+title: Introduction to MACI
+description: High-level introduction to Minimum Anti-Collusion Infrastructure (MACI)
+sidebar_label: Introduction
+sidebar_position: 1
+---
+
+:::info
+For a more secure and stable protocol, please refer to MACI v3.x
+:::
+
+# Welcome to MACI
+
+![MACI card](/img/maci-card.png)
+
+## Introduction
+
+**Minimal Anti-Collusion Infrastructure (MACI)** is an open-source public good that serves as infrastructure for private on-chain voting.
+
+MACI is an Ethereum application that provides privacy and collusion resistance for on-chain voting, both in a [quadratic](https://vitalik.eth.limo/general/2019/12/07/quadratic.html) and non-quadratic fashion. A common problem among today’s on-chain voting (or public good funding) processes is how easy it is to bribe voters into voting for a particular option. Since all transactions on the blockchain are public by default, without MACI, voters can easily prove to the briber which option they voted for and therefore receive the bribe rewards.
+
+MACI counters this problem by using encryption and zero-knowledge proofs (zk-SNARKs) to hide how each person voted while still publicly revealing the final result. User’s cannot prove which option they voted for, and therefore bribers cannot reliably trust that a user voted for their preferred option. For example, a voter can tell a briber that they are voting for option A, but in reality they voted for option B. There is no reliable way to prove which option the voter actually voted for, so the briber has less incentive to pay voters to vote their way.
+
+Applications like [clr.fund](https://clr.fund/) build atop MACI to increase
+user privacy and discourage collusion or bribery for public goods funding.
+
+## Features
+
+MACI offers the following guarantees:
+
+| Property                 | Description                                                                                                             |
+| ------------------------ | ----------------------------------------------------------------------------------------------------------------------- |
+| **Collusion Resistance** | No one except a trusted coordinator should be certain of the validity of a vote, reducing the effectiveness of bribery. |
+| **Receipt-freeness**     | No one can prove (besides to the coordinator) which way they voted.                                                     |
+| **Privacy**              | No one except a trusted coordinator should be able to decrypt a vote.                                                   |
+| **Uncensorability**      | No one — not even the trusted coordinator, should be able to censor a vote.                                             |
+| **Unforgeability**       | Only the owner of a user's private key may cast a vote tied to its corresponding public key.                            |
+| **Non-repudiation**      | No one may modify or delete a vote after it is cast, although a user may cast another vote to nullify it.               |
+| **Correct execution**    | No one, not even the trusted coordinator, should be able to produce a false tally of votes.                             |
+
+Under the hood, MACI uses Ethereum smart contracts, ECDH encryption, and zero-knowledge proofs.
+It inherits security and uncensorability from the underlying Ethereum
+blockchain, ensures unforgeability via asymmetric encryption, and achieves
+collusion resistance, privacy, and correct execution via zk-SNARK proofs.
+
+The participants of a MACI voting process are: 1) the voters and 2) a trusted coordinator. The coordinator is in charge of setting up the system, deploying polls, and computing the tally of the votes. Through smart contracts and ZK-proofs, MACI ensures that everything is done in a fair manner. Although MACI can provide collusion resistance only if the coordinator is honest, a dishonest coordinator can neither censor nor tamper with its execution.
+
+Note that MACI presumes an identity system where each legitimate member
+controls a unique Ethereum private key.
+
+For information on MACI's latest features, please check out our [MACI v1.2.0 release post](/blog/maci-v1-2-0-release).
+
+## Background
+
+MACI was originally proposed by Vitalik Buterin in [this ethresear.ch
+post](https://ethresear.ch/t/minimal-anti-collusion-infrastructure/5413) and has been maintained and improved since thanks to support from the Ethereum Foundation. For a general overview, the history and the importance of MACI, see [Release Announcement: MACI 1.0](/blog/maci-1-0-release) by Wei Jie, one of the creators. He also created a helpful [overview of MACI video](https://www.youtube.com/watch?v=sKuNj_IQVYI). Kyle Charbonnet wrote a great [Technical Introduction to MACI 1.0](/blog/maci-1-0-technical-introduction) that provides a walkthrough on how MACI operates.
+
+## Credits
+
+MACI is a public good infrastructure that is supported by the [Ethereum Foundation](https://ethereum.foundation/) within [Privacy & Scaling Explorations (PSE)](https://pse.dev/). It's also continuously improved by our open source community! Many people have contributed to MACI, but below are some notable contributors.
+
+**[MACI v1.0](/blog/maci-1-0-release) was originally developed by:**
+
+- [Barry WhiteHat](https://github.com/barryWhiteHat)
+- [Cory Dickson](https://github.com/corydickson)
+- [Chih-Cheng Liang](https://twitter.com/ChihChengLiang)
+- [Han Jian](https://han0110.github.io/)
+- [Kendrick Tan](https://kndrck.co/)
+- [Kirill Goncharov](https://github.com/xuhcc)
+- [Kobi Gurkan](http://kobi.one/)
+- [Koh Wei Jie](https://kohweijie.com)
+- [Samuel Gosling](https://twitter.com/xGozzy)
+
+**[MACI v1.1.1](/blog/maci-v1-1-1-release) was primarily developed by:**
+
+- [ctrlc03](https://github.com/ctrlc03)
+- [chaosma](https://github.com/chaosma)
+- [baumstern](https://github.com/baumstern)
+- [daodesigner](https://github.com/daodesigner)
+- [0xjei](https://github.com/0xjei)
+
+**Currently, MACI (v1.2.0 and beyond) is maintained and continuously improved by a core development team:**
+
+- [ctrlc03](https://github.com/ctrlc03)
+- [samajammin](https://github.com/samajammin)
+- [0xmad](https://github.com/0xmad)
+- [kittybest](https://github.com/kittybest)
+- [crisgarner](https://github.com/crisgarner)
+
+Our core team continues to work on improving the protocol and its documentation with help from our open source community.
+
+:::info
+If you are using one of the previous versions of MACI, see the [MACI v0.x](/docs/v0.x/introduction) documentation.
+:::