feat: add deployer service

packages/coordinator/package.json

@@ -45,14 +45,14 @@
     "class-validator": "^0.14.1",
     "dotenv": "^16.4.5",
     "ethers": "^6.13.1",
-    "hardhat": "^2.22.6",
+    "hardhat": "^2.22.9",
     "helmet": "^7.1.0",
     "lowdb": "^1.0.0",
-    "maci-circuits": "^2.1.0",
-    "maci-cli": "^2.1.0",
-    "maci-contracts": "^2.1.0",
-    "maci-domainobjs": "^2.0.0",
-    "maci-subgraph": "^2.1.0",
+    "maci-circuits": "^2.2.0",
+    "maci-cli": "^2.2.0",
+    "maci-contracts": "^2.2.1",
+    "maci-domainobjs": "^2.2.0",
+    "maci-subgraph": "^2.2.0",
     "mustache": "^4.2.0",
     "permissionless": "^0.1.44",
     "reflect-metadata": "^0.2.0",

packages/coordinator/ts/common/accountAbstraction.ts

@@ -1,3 +1,22 @@
+import {
+  createPublicClient,
+  http,
+  type HttpTransport,
+  type TransactionReceipt,
+  type Transport,
+  type Hex,
+  type PublicClient,
+  Chain,
+} from "viem";
+import { toECDSASigner } from "@zerodev/permissions/signers";
+import { privateKeyToAccount } from "viem/accounts";
+import { deserializePermissionAccount } from "@zerodev/permissions";
+import { ENTRYPOINT_ADDRESS_V07 } from "permissionless";
+import { KERNEL_V3_1 } from "@zerodev/sdk/constants";
+import { createKernelAccountClient, KernelAccountClient, KernelSmartAccount } from "@zerodev/sdk";
+import { ENTRYPOINT_ADDRESS_V07_TYPE } from "permissionless/types";
+import { ESupportedNetworks, viemChain } from "./networks";
+
 /**
  * Generate the RPCUrl for Pimlico based on the chain we need to interact with
  * @param network - the network we want to interact with
@@ -12,3 +31,76 @@ export const genPimlicoRPCUrl = (network: string): string => {
 
   return `https://api.pimlico.io/v2/${network}/rpc?apikey=${pimlicoAPIKey}`;
 };
+
+/**
+ * Get a public client
+ * @param rpcUrl - the RPC URL
+ * @returns the public client
+ */
+export const getPublicClient = (rpcUrl: string, chainName: ESupportedNetworks): PublicClient<HttpTransport, Chain> => {
+  return createPublicClient({
+    transport: http(rpcUrl),
+    chain: viemChain(chainName),
+  });
+};
+
+/**
+ * Get a Kernel account handle given a session key
+ * @param sessionKey
+ * @param chainId
+ */
+export const getKernelClient = async (
+  sessionKey: Hex,
+  approval: string,
+  chain: ESupportedNetworks,
+): Promise<
+  KernelAccountClient<
+    ENTRYPOINT_ADDRESS_V07_TYPE,
+    Transport,
+    Chain,
+    KernelSmartAccount<ENTRYPOINT_ADDRESS_V07_TYPE, HttpTransport, Chain>
+  >
+> => {
+  const bundlerUrl = genPimlicoRPCUrl(chain);
+  const publicClient = getPublicClient(bundlerUrl, chain);
+
+  // Using a stored private key
+  const sessionKeySigner = toECDSASigner({
+    signer: privateKeyToAccount(sessionKey),
+  });
+
+  const sessionKeyAccount = await deserializePermissionAccount(
+    publicClient,
+    ENTRYPOINT_ADDRESS_V07,
+    KERNEL_V3_1,
+    approval,
+    sessionKeySigner,
+  );
+
+  const kernelClient = createKernelAccountClient({
+    bundlerTransport: http(bundlerUrl),
+    entryPoint: ENTRYPOINT_ADDRESS_V07,
+    account: sessionKeyAccount,
+    chain: viemChain(chain),
+  });
+
+  return kernelClient;
+};
+
+/**
+ * The topic for the contract creation event
+ */
+export const contractCreationEventTopic = "0x4db17dd5e4732fb6da34a148104a592783ca119a1e7bb8829eba6cbadef0b511";
+
+/**
+ * Get the address of the newly deployed contract from a transaction receipt
+ * @param receipt - The transaction receipt
+ * @returns The address of the newly deployed contract
+ */
+export const getDeployedContractAddress = (receipt: TransactionReceipt): string | undefined => {
+  const addr = receipt.logs.find((log) => log.topics[0] === contractCreationEventTopic);
+
+  const deployedAddress = addr ? "0x" + addr.topics[1]?.slice(26) : undefined;
+
+  return deployedAddress;
+};

packages/coordinator/ts/common/errors.ts

@@ -11,4 +11,21 @@ export enum ErrorCodes {
   FILE_NOT_FOUND = "6",
   SUBGRAPH_DEPLOY = "7",
   SESSION_KEY_NOT_FOUND = "8",
+  UNSUPPORTED_VOICE_CREDIT_PROXY = "9",
+  UNSUPPORTED_GATEKEEPER = "10",
+  FAILED_TO_DEPLOY_GATEKEEPER = "11",
+  FAILED_TO_DEPLOY_VOICE_CREDIT_PROXY = "12",
+  FAILED_TO_DEPLOY_VERIFIER = "13",
+  FAILED_TO_DEPLOY_POSEIDON_T3 = "14",
+  FAILED_TO_DEPLOY_POSEIDON_T4 = "15",
+  FAILED_TO_DEPLOY_POSEIDON_T5 = "16",
+  FAILED_TO_DEPLOY_POSEIDON_T6 = "17",
+  FAILED_TO_DEPLOY_POLL_FACTORY = "18",
+  FAILED_TO_DEPLOY_POLL = "19",
+  FAILED_TO_DEPLOY_TALLY_FACTORY = "20",
+  FAILED_TO_DEPLOY_MESSAGE_PROCESSOR_FACTORY = "21",
+  FAILED_TO_DEPLOY_MACI = "22",
+  FAILED_TO_DEPLOY_VK_REGISTRY = "23",
+  FAILED_TO_SET_MACI_INSTANCE_ON_GATEKEEPER = "24",
+  FAILED_TO_GET_NEXT_POLL_ID = "25",
 }

packages/coordinator/ts/common/networks.ts

@@ -1,64 +1,84 @@
+import {
+  arbitrum,
+  arbitrumSepolia,
+  base,
+  baseSepolia,
+  bsc,
+  type Chain,
+  gnosis,
+  holesky,
+  linea,
+  lineaSepolia,
+  mainnet,
+  optimism,
+  optimismSepolia,
+  polygon,
+  scroll,
+  scrollSepolia,
+  sepolia,
+} from "viem/chains";
+
 export enum ESupportedNetworks {
   ETHEREUM = "mainnet",
   OPTIMISM = "optimism",
   OPTIMISM_SEPOLIA = "optimism-sepolia",
   BSC = "bsc",
   BSC_CHAPEL = "chapel",
   GNOSIS_CHAIN = "gnosis",
-  FUSE = "fuse",
   POLYGON = "matic",
-  FANTOM_OPERA = "fantom",
-  ZKSYNC_ERA_TESTNET = "zksync-era-testnet",
-  BOBA = "boba",
-  MOONBEAM = "moonbeam",
-  MOONRIVER = "moonriver",
-  MOONBASE_ALPHA = "mbase",
-  FANTOM_TESTNET = "fantom-testnet",
   ARBITRUM_ONE = "arbitrum-one",
-  CELO = "celo",
-  AVALANCHE_FUJI = "fuji",
-  AVALANCHE = "avalanche",
-  CELO_ALFAJORES = "celo-alfajores",
   HOLESKY = "holesky",
-  AURORA = "aurora",
-  AURORA_TESTNET = "aurora-testnet",
-  HARMONY = "harmony",
   LINEA_SEPOLIA = "linea-sepolia",
-  GNOSIS_CHIADO = "gnosis-chiado",
-  MODE_SEPOLIA = "mode-sepolia",
-  MODE = "mode-mainnet",
   BASE_SEPOLIA = "base-sepolia",
-  ZKSYNC_ERA_SEPOLIA = "zksync-era-sepolia",
-  POLYGON_ZKEVM = "polygon-zkevm",
-  ZKSYNC_ERA = "zksync-era",
   ETHEREUM_SEPOLIA = "sepolia",
   ARBITRUM_SEPOLIA = "arbitrum-sepolia",
   LINEA = "linea",
   BASE = "base",
   SCROLL_SEPOLIA = "scroll-sepolia",
   SCROLL = "scroll",
-  BLAST_MAINNET = "blast-mainnet",
-  ASTAR_ZKEVM_MAINNET = "astar-zkevm-mainnet",
-  SEI_TESTNET = "sei-testnet",
-  BLAST_TESTNET = "blast-testnet",
-  ETHERLINK_TESTNET = "etherlink-testnet",
-  XLAYER_SEPOLIA = "xlayer-sepolia",
-  XLAYER_MAINNET = "xlayer-mainnet",
-  POLYGON_AMOY = "polygon-amoy",
-  ZKYOTO_TESTNET = "zkyoto-testnet",
-  POLYGON_ZKEVM_CARDONA = "polygon-zkevm-cardona",
-  SEI_MAINNET = "sei-mainnet",
-  ROOTSTOCK_MAINNET = "rootstock",
-  IOTEX_MAINNET = "iotex",
-  NEAR_MAINNET = "near-mainnet",
-  NEAR_TESTNET = "near-testnet",
-  COSMOS = "cosmoshub-4",
-  COSMOS_HUB = "theta-testnet-001",
-  OSMOSIS = "osmosis-1",
-  OSMO_TESTNET = "osmo-test-4",
-  ARWEAVE = "arweave-mainnet",
-  BITCOIN = "btc",
-  SOLANA = "solana-mainnet-beta",
-  INJECTIVE_MAINNET = "injective-mainnet",
-  INJECTIVE_TESTNET = "injective-testnet",
 }
+
+/**
+ * Get the Viem chain for a given network
+ *
+ * @param network - the network to get the chain for
+ * @returns the Viem chain
+ */
+export const viemChain = (network: ESupportedNetworks): Chain => {
+  switch (network) {
+    case ESupportedNetworks.ETHEREUM:
+      return mainnet;
+    case ESupportedNetworks.ETHEREUM_SEPOLIA:
+      return sepolia;
+    case ESupportedNetworks.ARBITRUM_ONE:
+      return arbitrum;
+    case ESupportedNetworks.ARBITRUM_SEPOLIA:
+      return arbitrumSepolia;
+    case ESupportedNetworks.BASE_SEPOLIA:
+      return baseSepolia;
+    case ESupportedNetworks.LINEA_SEPOLIA:
+      return lineaSepolia;
+    case ESupportedNetworks.SCROLL_SEPOLIA:
+      return scrollSepolia;
+    case ESupportedNetworks.SCROLL:
+      return scroll;
+    case ESupportedNetworks.BASE:
+      return base;
+    case ESupportedNetworks.HOLESKY:
+      return holesky;
+    case ESupportedNetworks.LINEA:
+      return linea;
+    case ESupportedNetworks.BSC:
+      return bsc;
+    case ESupportedNetworks.GNOSIS_CHAIN:
+      return gnosis;
+    case ESupportedNetworks.POLYGON:
+      return polygon;
+    case ESupportedNetworks.OPTIMISM:
+      return optimism;
+    case ESupportedNetworks.OPTIMISM_SEPOLIA:
+      return optimismSepolia;
+    default:
+      throw new Error(`Unsupported network: ${network}`);
+  }
+};

packages/coordinator/ts/deployer/__tests__/deployer.controller.test.ts

@@ -0,0 +1,16 @@
+describe("SessionKeysController", () => {
+  beforeEach(async () => {});
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("v1/deploy/maci", () => {
+    test("should deploy all contract", async () => {});
+    test("should only deploy the contracts that are not deployed", async () => {});
+  });
+
+  describe("v1/deploy/poll", () => {
+    test("should deploy a new poll", () => {});
+  });
+});

packages/coordinator/ts/deployer/__tests__/deployer.service.test.ts

@@ -0,0 +1,59 @@
+import dotenv from "dotenv";
+import { ErrorCodes, ESupportedNetworks } from "../../common";
+import { DeployerService } from "../deployer.service";
+import { FileService } from "../../file/file.service";
+import { testMaciDeploymentConfig } from "./utils";
+import { SessionKeysService } from "../../sessionKeys/sessionKeys.service";
+import { CryptoService } from "../../crypto/crypto.service";
+
+dotenv.config();
+
+describe("DeployerService", () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  const chain = ESupportedNetworks.OPTIMISM_SEPOLIA;
+
+  const fileService = new FileService();
+  const deployerService = new DeployerService(fileService);
+
+  const sessionKeyService = new SessionKeysService(new CryptoService(), fileService);
+
+  let approval: string;
+  let sessionKeyAddress: string;
+
+  before(() => {
+    sessionKeyAddress = sessionKeyService.generateSessionKey().sessionKeyAddress;
+    sessionKeyAddress = sessionKeyService.generateSessionKey().sessionKeyAddress;
+  });
+
+  describe("deployMaci", () => {
+    test("should throw when passing a non existent session key address", async () => {
+      await expect(
+        deployerService.deployMaci({
+          config: testMaciDeploymentConfig,
+          chain,
+          approval: "",
+          sessionKeyAddress: "0x",
+        }),
+      ).rejects.toThrow(ErrorCodes.SESSION_KEY_NOT_FOUND);
+    });
+
+    //   test("should deploy maci contracts", async () => {
+    //     const maciAddress = await deployerService.deployMaci({
+    //         config: testMaciDeploymentConfig,
+    //         chain,
+    //         approval: "",
+    //         sessionKeyAddress: "0x"
+    //     })
+    //   });
+  });
+
+  describe("deployPoll", () => {
+    test("should throw when passing a non existent maci address", async () => {});
+    test("should deploy a poll", () => {});
+  });
+
+  test("should deploy a poll", () => {});
+});

packages/coordinator/ts/deployer/__tests__/utils.ts

@@ -0,0 +1,31 @@
+import { EGatekeepers, EInitialVoiceCreditProxies } from "maci-contracts";
+import { IDeployMaciConfig } from "../types";
+
+/**
+ * MACI deployment configuration
+ */
+export const testMaciDeploymentConfig: IDeployMaciConfig = {
+  gatekeeper: {
+    type: EGatekeepers.FreeForAll,
+    args: [],
+  },
+  initialVoiceCreditsProxy: {
+    type: EInitialVoiceCreditProxies.Constant,
+    args: {
+      amount: 100,
+    },
+  },
+  MACI: {
+    gatekeeper: EGatekeepers.FreeForAll,
+    stateTreeDepth: 10,
+  },
+  VkRegistry: {
+    args: {
+      stateTreeDepth: 10,
+      messageTreeDepth: 2,
+      voteOptionTreeDepth: 2,
+      messageBatchDepth: 1,
+      intStateTreeDepth: 1,
+    },
+  },
+};