chore(contracts): add registry manager deploy task

packages/contracts/contracts/maci/MACI.sol

@@ -9,48 +9,62 @@
 import { InitialVoiceCreditProxy } from "maci-contracts/contracts/initialVoiceCreditProxy/InitialVoiceCreditProxy.sol";
 import { SignUpGatekeeper } from "maci-contracts/contracts/gatekeepers/SignUpGatekeeper.sol";
 
+import { ICommon } from "../interfaces/ICommon.sol";
 import { IPoll } from "../interfaces/IPoll.sol";
+import { IRegistryManager } from "../interfaces/IRegistryManager.sol";
 
 /// @title MACI - Minimum Anti-Collusion Infrastructure
 /// @notice A contract which allows users to sign up, and deploy new polls
-contract MACI is Ownable, BaseMACI {
+contract MACI is Ownable, BaseMACI, ICommon {
+  /// @notice Registry manager
+  IRegistryManager public registryManager;
+
   /// @notice Create a new instance of the MACI contract.
   /// @param pollFactory The PollFactory contract
   /// @param messageProcessorFactory The MessageProcessorFactory contract
   /// @param tallyFactory The TallyFactory contract
   /// @param signUpGatekeeper The SignUpGatekeeper contract
   /// @param initialVoiceCreditProxy The InitialVoiceCreditProxy contract
   /// @param stateTreeDepth The depth of the state tree
   /// @param emptyBallotRoots The roots of the empty ballot trees
   constructor(
     IPollFactory pollFactory,
     IMessageProcessorFactory messageProcessorFactory,
     ITallyFactory tallyFactory,
     SignUpGatekeeper signUpGatekeeper,
     InitialVoiceCreditProxy initialVoiceCreditProxy,
     uint8 stateTreeDepth,
     uint256[5] memory emptyBallotRoots
   )
     payable
     Ownable(msg.sender)
     BaseMACI(
       pollFactory,
       messageProcessorFactory,
       tallyFactory,
       signUpGatekeeper,
       initialVoiceCreditProxy,
       stateTreeDepth,
       emptyBallotRoots
     )
   {}
 
   /// @notice Initialize the poll by given poll id and transfer poll ownership to the caller.
   /// @param pollId The poll id
   function initPoll(uint256 pollId) public onlyOwner {
     PollContracts memory pollAddresses = polls[pollId];
     IPoll poll = IPoll(pollAddresses.poll);
 
     poll.init();
     poll.transferOwnership(msg.sender);
   }
+
+  /// @notice Set RegistryManager for MACI
+  function setRegistryManager(address registryManagerAddress) public onlyOwner {
+    if (registryManagerAddress == address(0)) {
+      revert InvalidAddress();
+    }
+
+    registryManager = IRegistryManager(registryManagerAddress);
+  }
 }

packages/contracts/deploy-config-example.json

@@ -32,7 +32,11 @@
     },
     "MACI": {
       "stateTreeDepth": 10,
-      "gatekeeper": "EASGatekeeper"
+      "gatekeeper": "EASGatekeeper",
+      "registryManager": "EASRegistryManager"
+    },
+    "EASRegistryManager": {
+      "easAddress": "0xC2679fBD37d54388Ce493F1DB75320D236e1815e"
     },
     "VkRegistry": {
       "stateTreeDepth": 10,
@@ -93,7 +97,11 @@
     },
     "MACI": {
       "stateTreeDepth": 10,
-      "gatekeeper": "ZupassGatekeeper"
+      "gatekeeper": "ZupassGatekeeper",
+      "registryManager": "EASRegistryManager"
+    },
+    "EASRegistryManager": {
+      "easAddress": "0xaEF4103A04090071165F78D45D83A0C0782c2B2a"
     },
     "VkRegistry": {
       "stateTreeDepth": 10,
@@ -155,7 +163,11 @@
     },
     "MACI": {
       "stateTreeDepth": 6,
-      "gatekeeper": "EASGatekeeper"
+      "gatekeeper": "EASGatekeeper",
+      "registryManager": "EASRegistryManager"
+    },
+    "EASRegistryManager": {
+      "easAddress": "0x4200000000000000000000000000000000000021"
     },
     "VkRegistry": {
       "stateTreeDepth": 6,
@@ -217,7 +229,11 @@
     },
     "MACI": {
       "stateTreeDepth": 10,
-      "gatekeeper": "FreeForAllGatekeeper"
+      "gatekeeper": "FreeForAllGatekeeper",
+      "registryManager": "EASRegistryManager"
+    },
+    "EASRegistryManager": {
+      "easAddress": "0xC2679fBD37d54388Ce493F1DB75320D236e1815e"
     },
     "VkRegistry": {
       "stateTreeDepth": 10,
@@ -279,7 +295,11 @@
     },
     "MACI": {
       "stateTreeDepth": 10,
-      "gatekeeper": "FreeForAllGatekeeper"
+      "gatekeeper": "FreeForAllGatekeeper",
+      "registryManager": "EASRegistryManager"
+    },
+    "EASRegistryManager": {
+      "easAddress": "0xC2679fBD37d54388Ce493F1DB75320D236e1815e"
     },
     "VkRegistry": {
       "stateTreeDepth": 10,
@@ -341,7 +361,11 @@
     },
     "MACI": {
       "stateTreeDepth": 10,
-      "gatekeeper": "FreeForAllGatekeeper"
+      "gatekeeper": "FreeForAllGatekeeper",
+      "registryManager": "EASRegistryManager"
+    },
+    "EASRegistryManager": {
+      "easAddress": "0x4200000000000000000000000000000000000021"
     },
     "VkRegistry": {
       "stateTreeDepth": 10,
@@ -408,7 +432,11 @@
     },
     "MACI": {
       "stateTreeDepth": 14,
-      "gatekeeper": "FreeForAllGatekeeper"
+      "gatekeeper": "FreeForAllGatekeeper",
+      "registryManager": "EASRegistryManager"
+    },
+    "EASRegistryManager": {
+      "easAddress": "0x4200000000000000000000000000000000000021"
     },
     "VkRegistry": {
       "stateTreeDepth": 10,

packages/contracts/package.json

@@ -44,7 +44,7 @@
     "ethers": "^6.13.2",
     "hardhat": "^2.22.8",
     "lowdb": "^1.0.0",
-    "maci-contracts": "^2.2.1",
+    "maci-contracts": "0.0.0-ci.17a38c9",
     "maci-core": "^2.2.0",
     "maci-domainobjs": "^2.2.0",
     "solidity-docgen": "^0.6.0-beta.36"

packages/contracts/tasks/deploy/maci/05-pollFactory.ts

@@ -1,6 +1,6 @@
-import { ContractStorage, Deployment, EContracts, type IDeployParams } from "maci-contracts";
+import { ContractStorage, Deployment, type IDeployParams } from "maci-contracts";
 
-import { EDeploySteps } from "../../helpers/constants";
+import { EDeploySteps, EContracts } from "../../helpers/constants";
 
 const deployment = Deployment.getInstance();
 const storage = ContractStorage.getInstance();

packages/contracts/tasks/deploy/maci/08-maci.ts

@@ -1,7 +1,6 @@
 import {
   ContractStorage,
   Deployment,
-  EContracts,
   genEmptyBallotRoots,
   type IDeployParams,
   type GitcoinPassportGatekeeper,
@@ -12,7 +11,7 @@ import {
 } from "maci-contracts";
 
 import { MACI } from "../../../typechain-types";
-import { EDeploySteps } from "../../helpers/constants";
+import { EDeploySteps, EContracts } from "../../helpers/constants";
 
 const deployment = Deployment.getInstance();
 const storage = ContractStorage.getInstance();
@@ -53,7 +52,7 @@ deployment.deployTask(EDeploySteps.Maci, "Deploy MACI contract").then((task) =>
       hre.network.name,
     );
     const gatekeeper =
-      deployment.getDeployConfigField<EContracts | null>(EContracts.MACI, "gatekeeper") ||
+      deployment.getDeployConfigField<keyof typeof EContracts | null>(EContracts.MACI, "gatekeeper") ||
       EContracts.FreeForAllGatekeeper;
     const gatekeeperContractAddress = storage.mustGetAddress(gatekeeper, hre.network.name);
     const pollFactoryContractAddress = storage.mustGetAddress(EContracts.PollFactory, hre.network.name);

packages/contracts/tasks/deploy/maci/10-registryManager.ts

@@ -0,0 +1,60 @@
+import { ContractStorage, Deployment, type IDeployParams } from "maci-contracts";
+
+import type { MACI } from "../../../typechain-types";
+
+import { EDeploySteps, EContracts } from "../../helpers/constants";
+
+const deployment = Deployment.getInstance();
+const storage = ContractStorage.getInstance();
+
+/**
+ * Deploy step registration and task itself
+ */
+deployment.deployTask(EDeploySteps.RegistryManager, "Deploy registry manager").then((task) =>
+  task.setAction(async ({ incremental }: IDeployParams, hre) => {
+    deployment.setHre(hre);
+    const deployer = await deployment.getDeployer();
+
+    const registryManagerType =
+      deployment.getDeployConfigField<keyof typeof EContracts | null>(EContracts.MACI, "registryManager") ||
+      EContracts.RegistryManager;
+
+    const registryManagerContractAddress = storage.getAddress(registryManagerType, hre.network.name);
+
+    if (incremental && registryManagerContractAddress) {
+      return;
+    }
+
+    const easAddress = deployment.getDeployConfigField<keyof typeof EContracts | null, keyof typeof EContracts>(
+      registryManagerType,
+      "easAddress",
+    );
+
+    const args = easAddress ? [easAddress] : [];
+
+    const registryManagerContract = await deployment.deployContract(
+      {
+        name: registryManagerType,
+        signer: deployer,
+      },
+      ...args,
+    );
+
+    const maciContractAddress = storage.mustGetAddress(EContracts.MACI, hre.network.name);
+
+    const maciContract = await deployment.getContract<MACI>({
+      name: "contracts/maci/MACI.sol:MACI" as Parameters<typeof deployment.getContract>[0]["name"],
+      address: maciContractAddress,
+    });
+
+    const contractAddress = await registryManagerContract.getAddress();
+    await maciContract.setRegistryManager(contractAddress).then((tx) => tx.wait());
+
+    await storage.register({
+      id: registryManagerType,
+      contract: registryManagerContract,
+      args,
+      network: hre.network.name,
+    });
+  }),
+);

packages/contracts/tasks/helpers/constants/index.ts

@@ -1,10 +1,10 @@
-import { EDeploySteps as EMaciDeploySteps } from "maci-contracts";
+import { EDeploySteps as EMaciDeploySteps, EContracts as EMaciContracts } from "maci-contracts";
 
 /**
  * Deploy steps for maci-platform related constacts
  */
 export enum EPlatformDeployStep {
-  Registry = "full:deploy-registry",
+  RegistryManager = "full:deploy-registry-manager",
 }
 
 /**
@@ -15,6 +15,22 @@ export const EDeploySteps = {
   ...EPlatformDeployStep,
 };
 
+/**
+ * Contracts for maci-platform related constacts
+ */
+export enum EPlatformContracts {
+  RegistryManager = "RegistryManager",
+  EASRegistryManager = "EASRegistryManager",
+}
+
+/**
+ * Contracts for maci and maci-platform
+ */
+export const EContracts = {
+  ...EMaciContracts,
+  ...EPlatformContracts,
+};
+
 /**
  * Supported networks for deployment and task running
  */

packages/contracts/tests/Poll.test.ts → packages/contracts/tests/Maci.test.ts

@@ -1,6 +1,6 @@
 import { expect } from "chai";
-import { Signer } from "ethers";
-import { Verifier, VkRegistry, EMode, getSigners } from "maci-contracts";
+import { Signer, ZeroAddress } from "ethers";
+import { Verifier, VkRegistry, EMode, getSigners, deployContract } from "maci-contracts";
 import { MaciState } from "maci-core";
 import { Keypair, Message, PubKey } from "maci-domainobjs";
 
@@ -96,5 +96,30 @@ describe("Poll", () => {
       );
       await expect(pollContract.init()).to.be.revertedWithCustomError(pollContract, "PollAlreadyInit");
     });
+
+    it("should not be possible to set zero address as registry manager", async () => {
+      await expect(maciContract.setRegistryManager(ZeroAddress)).to.be.revertedWithCustomError(
+        maciContract,
+        "InvalidAddress",
+      );
+    });
+
+    it("should not be possible to set registry manager by non-owner", async () => {
+      const registryManager = await deployContract("RegistryManager", owner, true);
+
+      await expect(
+        maciContract.connect(user).setRegistryManager(await registryManager.getAddress()),
+      ).to.be.revertedWithCustomError(maciContract, "OwnableUnauthorizedAccount");
+    });
+
+    it("should set registry manager properly", async () => {
+      const registryManager = await deployContract("RegistryManager", owner, true);
+      const registryManagerContractAddress = await registryManager.getAddress();
+
+      const tx = await maciContract.setRegistryManager(registryManagerContractAddress);
+      await tx.wait();
+
+      expect(await maciContract.registryManager()).to.equal(registryManagerContractAddress);
+    });
   });
 });