@maci-protocol/website 0.0.0-ci.86ec64f → 0.0.0-ci.895cd6f

package/blog/2025-08-18-maci-aragon-plugin.md

@@ -0,0 +1,107 @@
+---
+slug: maci-aragon-plugin
+title: MACI Aragon Plugin
+description: A MACI plugin for Aragon OSx to enable private voting in DAOs
+authors:
+  - name: ctrlc03
+    title: MACI former team lead
+    url: https://x.com/ctrlc03
+    image_url: https://avatars.githubusercontent.com/u/93448202?v=4
+  - name: John Guilding
+    title: MACI team lead
+    url: https://x.com/john_guilding
+    image_url: https://pbs.twimg.com/profile_images/1629144990914945024/C6_xsK78_400x400.jpg
+  - name: NicoSerranoP
+    title: MACI team member
+    url: https://x.com/NicoSerranoP
+    image_url: https://avatars.githubusercontent.com/u/38594836?v=4
+tags: [voting, security, anonymity, Aragon, MACI, development]
+excerpt: "A MACI plugin for Aragon OSx to enable private voting in DAOs"
+---
+
+Hey Anon,
+
+Welcome to another MACI blogpost. Today we are going to be looking at a voting plugin we have been developing to work with the [Aragon OSx stack](https://www.aragon.org/osx).
+
+As mentioned in our [latest roadmap blog post](https://maci.pse.dev/blog/2025-Roadmap#2025---what-will-we-focus-the-rest-of-the-year), our team decided to focus on supporting governance projects by integrating with tooling providers such as [Aragon](https://www.aragon.org/). Look out for further announcements over the next month. We're working on some exciting additions to the roadmap to accelerate private governance on Ethereum.
+
+So why integrate MACI with Aragon OSx? Our thesis is simple: \***\*private voting will increase voter participation and protect those voting. It will also lead to more honest and accurate outcomes as people can vote more honestly.\*\***
+
+Current public voting systems create barriers to honest participation. Voters face social pressure, fear of retaliation, and concerns about how their choices might affect future opportunities. Private voting removes these barriers, enabling DAOs to capture the true preferences of their communities.
+
+We chose to integrate with Aragon because their OSx platform provides an excellent foundation for custom DAO governance, and as a reputable team building in the open, they're the perfect partner for this integration.
+
+### The real cost of public voting
+
+While transparency is often celebrated in crypto, public voting creates serious barriers to honest participation that threaten the legitimacy of DAO governance.
+
+**Fear of retaliation keeps voters silent.** Large token holders can pressure smaller voters by threatening to exclude them from future opportunities, airdrops, or partnerships. When voting records are public, retaliation becomes easy to execute, leading many to abstain rather than risk consequences.
+
+**Social pressure distorts genuine preferences.** Voters often wait to see how others vote before casting their own ballot, leading to herding behavior that doesn't reflect genuine preferences. Some even [say](https://x.com/LefterisJP/status/1921562225333916094) governance voting has devolved into a game of politics. The "follow the whale" mentality and politics involved undermine the democratic ideals DAOs strive for.
+
+**Vote verification enables problematic markets.** When votes are public, it also creates conditions where governance power can be openly [traded](https://www.tronweekly.com/arbitrum-vote-buying-scandal-how-5-eth-shook/), as buyers can verify they received what they paid for.
+
+**Public real time results can enable whales intervention.** If the votes are public and visible in real time while the voting period is happening, whales (or users through token loans) could influence the decision by using their voting power to overpower the community decision.
+
+### Why MACI
+
+MACI (Minimal Anti Collusion Infrastructure) is a private voting protocol that aims to reduce collusion and coercion with receipt freeness - this makes it the logical next step for DAOs that really care about the problems highlighted above.
+
+In more detail, every vote is encrypted and can only be decrypted for tallying, by a trusted entity referred to as the coordinator. Voters can override their votes at any point during the voting period, and thus without a clear receipt for their vote, they are not able to prove beyond reasonable doubt that they actually voted for an option. This discourages bribers from buying votes and other voters from attempting to collude.
+
+While the coordinator can decrypt votes, they cannot produce an incorrect tally or censor votes, thanks to zero knowledge proofs and smart contracts.
+
+For more details about MACI and how it works, we recommend reading our other blogposts such as this introductory [article](https://maci.pse.dev/blog/maci-for-beginners) and our comprehensive documentation [website](https://maci.pse.dev/docs/introduction).
+
+### How does Aragon OSx work
+
+Aragon OSx is a smart contract framework that works on EVM compatible chains. DAOs can easily deploy custom governance stacks using Aragon OSx, and can benefit from several plugins to extend their functionality over time. This plugin architecture allows DAOs to customise their governance without rebuilding from scratch.
+
+A plugin is a smart contract with custom governance logic, limited in scope, and with single-purpose logic that can be used to extend OSx-based organisations. Examples include [token voting](https://docs.aragon.org/token-voting/1.x/index.html) and [multisig](https://docs.aragon.org/multisig/1.x/index.html), and now.. privacy-preserving voting through MACI.
+
+### How does the MACI plugin work
+
+The plugin allows DAO members to create new proposals by calling a smart contract function: `createProposal`. The function checks that the caller has enough governance tokens - this minimum amount is set by the DAO at deployment time. The plugin creates a new MACI poll that hosts the encrypted private votes for that particular proposal.
+
+The plugin then captures the current block number (minus one) as a snapshot to determine voter eligibility. Once they decide to vote, they can register their interest to vote via their DAO frontend (in MACI's context we call this process _join a poll_), and their voting power is determined by their token balance at the time of proposal creation. Voters can use their real wallet holding their tokens to register themselves by publishing a MACI public key created on their devices. After that, the voter can use any wallet to submit an encrypted message containing the registered public key and their selected option.
+
+Voters are then able to vote using their full voting power by choosing one of the options available, which at this time are Yes, No or Abstain. Voting is completely handled by MACI’s smart contracts, therefore voters do not actually ever interact with the DAO plugin.
+
+Once the proposal ends, MACI’s backend service (the [coordinator service](https://github.com/privacy-scaling-explorations/maci/tree/dev/apps/coordinator)), starts processing the votes, and generate zk-SNARK proofs to be validated on chain. Voters can be sure of the correct execution thanks to those proofs verifying on chain. Finally, the results are uploaded and the proposal execution can be triggered.
+
+The full flow can be observed in the diagram below:
+
+![new-flow-maci](https://hackmd.io/_uploads/Sktza18Xge.png)
+
+A proposal execution can range from transferring funds, calling a function on the DAO smart contract itself, calling out an external contract (for instance to initiate a token swap), or setting up a new plugin.
+
+An example proposal shown below, with a proposal requesting users to vote on whether they are happy to convert part of the DAOs USDC reserves to ETH.
+
+![dao1](https://hackmd.io/_uploads/rk7C3dHXll.png)
+
+The familiar voting interface makes privacy seamless - voters simply select their choice without needing to understand the cryptography running behind the scenes.
+
+![voting1](https://hackmd.io/_uploads/H1TR3OHXxg.png)
+
+### Implementation Considerations
+
+- **Network Support:** Currently compatible with all EVM chains such as Ethereum, Arbitrum, Optimism, and some zkEVM networks such as Scroll and Linea. [Here](https://maci.pse.dev/docs/supported-networks/) is a list of all compatible networks.
+- **Timeline:** Vote processing is not immediate due to the need to process votes offchain and to generate zk-SNARK proofs of correct execution. The time it takes to process votes can be reduced by using more powerful hardware.
+- **Reliance on trusted coordinator:** MACI in its current form relies on a trusted coordinator entity which can decrypt the votes - this is an automated piece of software that can run on a server or a Trusted Execution Environment for more security. The team is working on decentralising the coordinator entity and will soon begin working on an upgraded version that uses homomorphic encryption and threshold encryption to distribute the responsibilities across multiple entities. Please note that while the coordinator can see the votes, they cannot censor users nor provide incorrect results.
+- **Costs:** Using MACI can be more costly than traditional blockchain-based voting. While these costs are negligible in layer 2 networks, costs can increase in Ethereum mainnet. Please refer to our [costs](https://maci.pse.dev/docs/supported-networks/costs) section in the documentation website for more details on current benchmarks.
+
+### Next steps
+
+As DAOs evolve from experimental communities to serious organisations managing significant resources, governance systems must evolve too. The current landscape presents an ideal opportunity for DAOs to pioneer MACI, thus we are looking for forward-thinking DAOs to pilot MACI’s governance plugin - especially those facing challenges around voter participation, sensitive decision-making, or community pressure. Ready to be among the first? Reach out at [maci@pse.dev](mailto:maci@pse.dev) or join our [Discord](https://discord.com/invite/sF5CT5rzrR). Governance on Ethereum needs a privacy shake up, stay in the loop if you're interested in hearing what else the team has been working on.
+
+### References and resources
+
+- [MACI repo](https://github.com/privacy-scaling-explorations/maci)
+- [MACI voting plugin](https://github.com/privacy-scaling-explorations/maci-voting-plugin-aragon)
+- [MACI -Aragon sample frontend](https://github.com/privacy-scaling-explorations/maci-aragon-osx-gov-app)
+- [Aragon OSx](https://github.com/aragon/osx)
+- [Aragon docs](https://docs.aragon.org/)
+
+## Acknowledgements
+
+Thanks to the Aragon team for review.

package/blog/2025-09-05-maci-coordinator-service.md

@@ -0,0 +1,167 @@
+---
+slug: maci-coordinator-service
+title: MACI Coordinator Service
+description: Announcing our coordinator service for MACI
+authors:
+  - name: ctrlc03
+    title: MACI former team lead
+    url: https://x.com/ctrlc03
+    image_url: https://avatars.githubusercontent.com/u/93448202?v=4c
+  - name: NicoSerranoP
+    title: MACI team member
+    url: https://x.com/NicoSerranoP
+    image_url: https://avatars.githubusercontent.com/u/38594836?v=4
+tags: [voting, security, anonymity, MACI, coordinator]
+excerpt: "A MACI plugin for Aragon OSx to enable private voting in DAOs"
+---
+
+Hey Anon,
+
+Welcome back to our MACI blog.
+
+Today, we are excited to officially announce something we have referenced frequently: the Coordinator Service.
+
+If you ever used MACI, for instance to run a Retroactive Public Goods Funding (RPGF) or Quadratic Funding (QF) round, you might be aware of how tedious it was to operate. The manual process of running scripts to finalise a round and calculate the tally as well as all of the zk-SNARK proofs could require some time and technical expertise. All these steps had to be done in the terminal and you needed to be familiar with MACI's inner workings to understand the process.
+
+**Fear no more - the coordinator service is here to make your life easier.**
+
+## The vision: MACI for everyone
+
+Our goal is ambitious, yet simple: **completely eliminate the need for any technical knowledge to use MACI**. No more terminal commands, no more manual proof generation, no more complex scripts. Just configure once, run inside a Docker container on your server, and enjoy the full power of MACI's privacy-preserving voting infrastructure.
+
+## Technical implementation
+
+The service was built with the following technologies for reliability and scalability:
+
+- TypeScript for type-safe, maintainable code
+- Nest.js framework for enterprise-grade architecture
+- REST API for standard CRUD operations
+- WebSocket endpoints for real-time updates during intensive computations
+- MACI SDK package to have all the logic and functions ready to use
+- Docker-ready for simple deployment anywhere
+
+The core functionalities of the service are as follows:
+
+- Deploy a MACI [subgraph](https://github.com/privacy-scaling-explorations/maci/tree/dev/apps/coordinator/ts/subgraph) to query on-chain data easily
+- [Deploy](https://github.com/privacy-scaling-explorations/maci/tree/dev/apps/coordinator/ts/deployer) the MACI smart contracts, including polls
+- [Finalise](https://github.com/privacy-scaling-explorations/maci/tree/dev/apps/coordinator/ts/proof) polls by processing votes and tallying the results
+- [Schedule](https://github.com/privacy-scaling-explorations/maci/tree/main/apps/coordinator/ts/scheduler) polls for automatic finalization when the voting period ends
+- [Health](https://github.com/privacy-scaling-explorations/maci/tree/main/apps/coordinator/ts/health) endpoint to check everything is setup and working
+
+Let's dive into more details in the following sections.
+
+### Subraph deployment
+
+The endpoint to deploy a subgraph requires some configuration in the `.env` file, as well as an HTTP request to the endpoint responsible for this `https://coordinator.maci.vote/v1/subgraph/deploy`. Make sure you have an account in [The Graph](https://thegraph.com/studio/) to setup your `.env` file before starting the coordinator service.
+
+### Contracts deployment
+
+There are two endpoints in this module: deploy maci (`https://coordinator.maci.vote/v1/deploy/maci`) and deploy poll (`https://coordinator.maci.vote/v1/deploy/poll`). This will take care of all contracts deployment and configuration. It is worth pointing out that you should read the [coordinator service API documentation](https://coordinator.maci.vote/api) and the [MACI guides](https://maci.pse.dev/docs/core-concepts/workflow) to understand the roles of each contract (MACI, poll, policy, initialVoiceCredit).
+
+You can deploy one MACI contract (and its internal smart contracts) that will have one gatekeeper policy (e.g. FreeForAll) for all voters to sign up. After that you can deploy multiple polls with different settings (start date, end date, gatekeeper policy, etc). Each voter will have to join each poll to be eligible to participate in. The poll's gatekeeper will check the voter eligibility to join the poll.
+
+### Finalisation
+
+This step includes three separate actions:
+
+1. Merge - calculate the state merkle tree root and store a commitment to its root (`https://coordinator.maci.vote/v1/proof/merge`)
+2. Process - fetch all smart contracts events to reconstruct the state locally and process all votes. This includes decrypting votes, checking validity, and finally tallying them. zk-SNARK proofs are generated for each batch of votes processed (`https://coordinator.maci.vote/v1/proof/generate`)
+3. Submit - submitting all of the zk-SNARK proofs on chain to prove that the poll was processed correctly. Finally, submit the tally results on chain so that they can be seen by everyone (`https://coordinator.maci.vote/v1/proof/submit`)
+
+We chose to separate each action into its own endpoint to avoid long-running computations that could lead to network errors or timeouts.
+
+### Schedule
+
+After finishing up the finalisation module, we realized that it would be a lot easier for users to create polls and schedule the finalization process. This removes the need for users to manually call the finalization endpoints described above.
+
+1. To schedule a deployed poll you can use `https://coordinator.maci.vote/v1/scheduler/register`.
+2. To check if a poll is scheduled you can use `https://coordinator.maci.vote/v1/scheduler/status`
+3. To delete a scheduled poll you can use `https://coordinator.maci.vote/v1/scheduler/delete`
+
+## How to use
+
+### Run it from source
+
+1. Clone the MACI repository: [https://github.com/privacy-scaling-explorations/maci](https://github.com/privacy-scaling-explorations/maci)
+2. Install dependencies and build the project
+
+```bash
+pnpm install
+pnpm run build
+```
+
+3. Download the zkeys for the coordinator
+
+```bash
+pnpm run download-zkeys:ceremony:coordinator
+```
+
+4. Generate a coordinator MACI keypair. Remember to store those values for later.
+
+```bash
+pnpm run generate-maci-keypair
+```
+
+5. Move to the coordinator service directory
+
+```bash
+cd apps/coordinator
+```
+
+6. Configure your `.env` file. Make sure to configure it with your own secure values. The coordinator MACI private key from the previous step should be set here
+
+```bash
+cp .env.example .env
+```
+
+7. Start the service
+
+```bash
+pnpm run start
+# or
+pnpm run start:prod
+```
+
+### Run it with Docker
+
+1. Clone the MACI repository: [https://github.com/privacy-scaling-explorations/maci](https://github.com/privacy-scaling-explorations/maci)
+2. Go inside the project directory
+
+```bash
+cd maci
+```
+
+3. Build the docker image and run the container
+
+```bash
+# Build docker
+docker compose -f apps/coordinator/docker-compose.yml build
+
+# Run container detached
+docker compose -f apps/coordinator/docker-compose.yml up -d
+```
+
+## Usage notes
+
+1. You can check out the documentation while the service is running in [http://localhost:3001/api](http://localhost:3001/api)
+
+2. We have a [e2e.deploy.test.ts](https://github.com/privacy-scaling-explorations/maci/blob/main/apps/coordinator/tests/e2e.deploy.test.ts) file that performs a complete process: deployment, voting and finalization. You can use it to guide yourself.
+
+## Future work
+
+We are researching about different cryptographic methods to decentralize the coordinator. The idea is to eliminate reliance on a single centralized service for finalizing polls. A group of people would be able to spin up their own coordinator services and finalize the poll in a multi-party computation. For more info check out our MACI v4 research.
+
+## Conclusion
+
+The MACI Coordinator Service represents a significant leap forward in making MACI accessible to everyone. Whether you're running a small community poll or a large-scale funding round, the coordinator service handles the complexity so you can focus on what matters - empowering your community with private, secure voting.
+
+Ready to get started? Head over to our documentation and deploy your first MACI round today!
+
+Please reach out if you would like to integrate the service into your frontend.
+
+## References
+
+- [MACI repo](https://github.com/privacy-scaling-explorations/maci)
+- [Sample frontend](https://github.com/privacy-scaling-explorations/maci-aragon-osx-gov-app) using the coordinator service
+- [Code examples](https://github.com/privacy-scaling-explorations/maci-aragon-osx-gov-app/blob/main/plugins/maciVoting/contexts/CoordinatorContext.tsx)
+- [Documentation](https://maci.pse.dev/docs/category/coordinator-service)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maci-protocol/website",
-  "version": "0.0.0-ci.86ec64f",
+  "version": "0.0.0-ci.895cd6f",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -45,7 +45,7 @@
     "@types/node": "^24.2.0",
     "@types/react": "^19.1.9",
     "ts-node": "^10.9.2",
-    "typescript": "^5.8.3"
+    "typescript": "^5.9.2"
   },
   "browserslist": {
     "production": [
@@ -62,5 +62,5 @@
   "engines": {
     "node": ">=18.0"
   },
-  "gitHead": "c60edfc68d77f84d132590938967d6ed651a591a"
+  "gitHead": "891089114253b0a313ada2b33ca7bf275f10d144"
 }

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

@@ -60,12 +60,18 @@ Pull requests are great if you want to add a feature or fix a bug. Here's a quic
 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 checkout main
+git pull
+git checkout your-branch
+git rebase main
 git reset $(git merge-base main $(git rev-parse --abbrev-ref HEAD))
 ```
 
-9. Push to your fork and submit a pull request on our `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.
+9. Before creating a pull request make sure your work is ready. Do not create WIP pull requests and do not skip pre-commit hooks.
 
-10. Link any issues that the PR is addressing as described in our processes documentation.
+10. Push to your fork and submit a pull request on our `main` branch. Please provide us with some explanation of why you made the changes you made. For new features make sure to explain a standard use case to us. Do not remove our PR template and follow all the steps defined in it.
+
+11. Link any issues that the PR is addressing as described in our processes documentation.
 
 ## CI (Github Actions) Tests
 

package/versioned_docs/version-v3.x/technical-references/coordinator-service/index.md

@@ -7,4 +7,18 @@ sidebar_position: 1
 
 # Coordinator Service
 
-Welcome to the Coordinator Service technical reference. Here you will find the technical details of the Coordinator Service, including the API endpoints and code examples.
+Welcome to the Coordinator Service technical reference. This guide describes how the Coordinator Service works, its workflow, and how to interact with it. For more technical code documentation regarding API endpoints and data transfer objects, please refer to the [API documentation](https://coordinator.maci.vote/api).
+
+## Responsibilities
+
+A MACI coordinator is responsible for running voting processes. In quadratic funding rounds or authority election rounds, the coordinator is the entity that defines who can vote, which projects or candidates are eligible for funding, and the duration of the voting round.
+
+First of all, the coordinator needs to deploy the MACI smart contracts with the desired configuration: gatekeeper policy, which defines who can sign up as a voter; the state Merkle tree depth which defines the maximum number of voters; and the voting mode which defines how votes will be counted (more info in [Poll types](https://maci.pse.dev/docs/core-concepts/poll-types#quadratic-voting)).
+
+After deploying the MACI contracts, the coordinator can deploy a poll (which represents a voting process). To deploy the poll, the coordinator needs to specify: the gatekeeper policy, which defines who can join the poll as a voter; the start and end dates of the poll; the number of options to vote for; the maximum number of votes per voter; and the voting mode.
+
+The coordinator will then wait until the poll ends, after which they will need to finalize the poll. This involves processing all published messages, extracting the votes, tallying them, and submitting the results on-chain.
+
+## Conclusion
+
+In the following documents, we will go through the details of setting up the Coordinator Service and how to interact with it to perform the tasks described above.

package/versioned_docs/version-v3.x/technical-references/coordinator-service/installation.md

@@ -5,39 +5,11 @@ sidebar_label: Installation
 sidebar_position: 2
 ---
 
-1. Add `.env` file (see `.env.example`).
-2. Generate RSA key pair with `pnpm run generate-keypair`.
-3. Download zkey files using `pnpm run download-zkeys:{type}` (only test type is available for now).
-4. Make sure you copied RSA public key to your application. This will be needed for encrypting `Authorization` header and coordinator private key for proof generation. Also it can be accessed through API method `GET v1/proof/publicKey`.
-5. Run `pnpm run start` to run the service.
-6. All API calls must be called with `Authorization` header, where the value is encrypted with RSA public key you generated before. Header value contains message signature and message digest created by `COORDINATOR_ADDRESSES`. The format is `publicEncrypt({signature}:{digest})`.
-   Make sure you set `COORDINATOR_ADDRESSES` env variable and sign any message with the addresses from your application (see [AccountSignatureGuard](./ts/auth/AccountSignatureGuard.service.ts)).
-7. Proofs can be generated with `POST v1/proof/generate` API method or with Websockets (see [dto spec](./ts/proof/dto.ts), [controller](./ts/app.controller.ts) and [wsgateway](./ts/events/events.gateway.ts)).
-
-## Subgraph deployment
-
-It is possible to deploy subgraph using coordinator service.
-
-First, you need to setup subgraph and create a project. [Subgraph dashboard](https://thegraph.com/studio/).
-
-Then, set env variables:
+There are two ways to run the coordinator service: building it from source or using Docker. Both methods require you to clone the MACI repository and move to the project root directory.
 
+```bash
+git clone https://github.com/privacy-scaling-explorations/maci
+cd maci
 ```
-# Subgraph name
-SUBGRAPH_NAME="maci-subgraph"
-
-# Subgraph provider url
-SUBGRAPH_PROVIDER_URL=https://api.studio.thegraph.com/deploy/
-
-# Subgraph deploy key
-SUBGRAPH_DEPLOY_KEY=*******
 
-# Subgraph project folder
-SUBGRAPH_FOLDER=../subgraph
-```
-
-After deployment, subgraph url will be available in studio dashboard and you can use this type of url to get latest deployed version in your application:
-
-```
-https://api.studio.thegraph.com/.../{SUBGRAPH_NAME}/version/latest
-```
+You need to check the latest [README.md](https://github.com/privacy-ethereum/maci/tree/main/apps/coordinator) instructions in the coordinator service app for detailed information about requirements and steps to install, build, and run the service.

package/versioned_docs/version-v3.x/technical-references/coordinator-service/usage.md

@@ -0,0 +1,64 @@
+---
+title: Usage
+description: Learn how to interact with a running MACI coordinator service instance.
+sidebar_label: Usage
+sidebar_position: 3
+---
+
+After setting up and running the MACI coordinator service, you can interact with it through its RESTful API. The service provides various endpoints for deployment and finalization of polls. Please refer to the API documentation at [https://coordinator.maci.vote/api](https://coordinator.maci.vote/api) for the exact request format and required parameters for all endpoint calls described below.
+
+# Authentication
+
+The coordinator service uses a custom signature authentication mechanism to guard the deploy endpoints. To interact with these endpoints, you need to:
+
+1. Make sure you have run the command to set up and generate the RSA keypair, as described in the instructions section.
+
+2. Ensure that your Ethereum public key is set in the `.env` file under the `COORDINATOR_ADDRESSES` variable.
+
+3. Get the RSA public key from the coordinator service with [https://coordinator.maci.vote/v1/proof/publicKey](https://coordinator.maci.vote/v1/proof/publicKey).
+
+4. Sign a message such as "authenticate-me" using the coordinator's Ethereum private key.
+
+5. Encrypt both the message (also called digest) and its signature using the RSA public key. For example, you can use RSA public-key encryption in the format:
+
+```javascript
+const payload: string = "signature:digest";
+```
+
+Then encrypt this payload using the coordinator’s RSA public key.
+
+# Deploy MACI
+
+To deploy the set of MACI smart contracts, you need to call the endpoint [https://coordinator.maci.vote/v1/deploy/maci](https://coordinator.maci.vote/v1/deploy/maci) with a POST request. The request body should include the necessary parameters for the deployment, such as the gatekeeper policy, state tree depth, and voting mode.
+
+# Deploy Poll
+
+To deploy a new poll to an existing MACI instance, you need to call the endpoint [https://coordinator.maci.vote/v1/deploy/poll](https://coordinator.maci.vote/v1/deploy/poll) with a POST request. The request body should include the necessary parameters for the poll deployment, such as the gatekeeper policy, start and end dates, number of options, and voting mode.
+
+# Deploy Subgraph
+
+To deploy a subgraph for a MACI instance and its corresponding polls, you need to call the endpoint [https://coordinator.maci.vote/v1/subgraph/deploy](https://coordinator.maci.vote/v1/subgraph/deploy) with a POST request. The request body should include the necessary parameters for the subgraph deployment, such as the MACI contract address and the subgraph name.
+
+# Finalize Poll
+
+To finalize a poll, you need to follow a series of steps that involve processing messages, merging state trees, generating proofs, and submitting the final tally on-chain. The Coordinator Service provides endpoints for each of these steps.
+
+## Merge
+
+To merge the published messages and create the required state tree, you need to call the endpoint [https://coordinator.maci.vote/v1/proof/merge](https://coordinator.maci.vote/v1/proof/merge) with a POST request. The request body should include the necessary parameters for the merge operation, such as the MACI contract address and the poll ID.
+
+## Generate
+
+Once the Merkle trees are ready, you can generate the zk-SNARK proof for the final tally by calling the endpoint [https://coordinator.maci.vote/v1/proof/generate](https://coordinator.maci.vote/v1/proof/generate) with a POST request. The request body should include the necessary parameters for the proof generation, such as the MACI contract address and the poll ID.
+
+## Submit
+
+After generating the proof, you can submit the final tally on-chain by calling the endpoint [https://coordinator.maci.vote/v1/proof/submit](https://coordinator.maci.vote/v1/proof/submit) with a POST request. The request body should include the necessary parameters for the submission, such as the MACI contract address, poll ID, and the generated proof.
+
+# Schedule Poll
+
+After deploying a poll, you can schedule it to be finalized automatically after it ends. Make sure to set the MACI coordinator private key in the `.env` file. To do so, you need to call the endpoint [https://coordinator.maci.vote/v1/schedule/poll](https://coordinator.maci.vote/v1/schedule/poll) with a POST request. The request body should include the necessary parameters for scheduling the poll, such as the MACI contract address and the poll ID.
+
+# Health
+
+To check that the env variables are set correctly and the service is running, you can call the health endpoint [https://coordinator.maci.vote/v1/health](https://coordinator.maci.vote/v1/health) with a GET request. This endpoint will return a status message indicating the rapidsnark access, redis database connection, zkeys access, and the MACI coordinator address with its funds in each MACI-compatible network.