feat: add deployer service

.gitignore

@@ -32,8 +32,8 @@ yarn-error.log*
 # do not commit any .env files to git, except for the .env.example file. https://create.t3.gg/en/usage/env-variables#using-environment-variables
 .env
 .env*.local
-deploy-config.json
-deployed-contracts.json
+packages/coordinator/deploy-config.json
+packages/coordinator/deployed-contracts.json
 
 # vercel
 .vercel

packages/contracts/ts/index.ts

@@ -1 +1,3 @@
 export { ERegistryManagerRequestType, ERegistryManagerRequestStatus } from "./constants";
+
+export * from "../typechain-types";

packages/coordinator/package.json

@@ -54,13 +54,13 @@
     "maci-domainobjs": "^2.0.0",
     "maci-subgraph": "^2.3.0",
     "mustache": "^4.2.0",
-    "permissionless": "^0.1.44",
+    "permissionless": ">=0.1.18 <=0.1.29",
     "reflect-metadata": "^0.2.0",
     "rxjs": "^7.8.1",
     "socket.io": "^4.7.5",
     "tar": "^7.4.1",
     "ts-node": "^10.9.1",
-    "viem": "^2.7.15"
+    "viem": "^2.16.3"
   },
   "devDependencies": {
     "@nestjs/cli": "^10.4.2",

packages/coordinator/tests/aa.test.ts

@@ -0,0 +1,141 @@
+import { signerToEcdsaValidator } from "@zerodev/ecdsa-validator";
+import { serializePermissionAccount, toPermissionValidator } from "@zerodev/permissions";
+import { toSudoPolicy } from "@zerodev/permissions/policies";
+import { toECDSASigner } from "@zerodev/permissions/signers";
+import { addressToEmptyAccount, createKernelAccount } from "@zerodev/sdk";
+import { KERNEL_V3_1 } from "@zerodev/sdk/constants";
+import dotenv from "dotenv";
+import { ENTRYPOINT_ADDRESS_V07 } from "permissionless";
+import { Hex, zeroAddress } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+
+import { ErrorCodes, ESupportedNetworks } from "../ts/common";
+import { getPublicClient } from "../ts/common/accountAbstraction";
+import { testMaciDeploymentConfig, testPollDeploymentConfig } from "../ts/deployer/__tests__/utils";
+import { DeployerService } from "../ts/deployer/deployer.service";
+import { FileService } from "../ts/file/file.service";
+import { SessionKeysService } from "../ts/sessionKeys/sessionKeys.service";
+
+dotenv.config();
+
+const entryPoint = ENTRYPOINT_ADDRESS_V07;
+const kernelVersion = KERNEL_V3_1;
+
+/**
+ * Generate an approval for a session key
+ *
+ * @param sessionKeyAddress - the session key address
+ * @returns - the approval
+ */
+export const generateApproval = async (sessionKeyAddress: Hex): Promise<string> => {
+  const publicClient = getPublicClient(ESupportedNetworks.OPTIMISM_SEPOLIA);
+
+  const sessionKeySigner = privateKeyToAccount(process.env.TEST_PRIVATE_KEY! as `0x${string}`);
+  const ecdsaValidator = await signerToEcdsaValidator(publicClient, {
+    signer: sessionKeySigner,
+    entryPoint,
+    kernelVersion,
+  });
+
+  const emptyAccount = addressToEmptyAccount(sessionKeyAddress);
+  const emptySessionKeySigner = toECDSASigner({ signer: emptyAccount });
+
+  const permissionPlugin = await toPermissionValidator(publicClient, {
+    entryPoint,
+    kernelVersion,
+    signer: emptySessionKeySigner,
+    policies: [toSudoPolicy({})],
+  });
+
+  const sessionKeyAccount = await createKernelAccount(publicClient, {
+    entryPoint,
+    kernelVersion,
+    plugins: {
+      sudo: ecdsaValidator,
+      regular: permissionPlugin,
+    },
+  });
+
+  return serializePermissionAccount(sessionKeyAccount);
+};
+
+describe("Account Abstraction e2e", () => {
+  const fileService = new FileService();
+  const sessionKeyService = new SessionKeysService(fileService);
+  const deployerService = new DeployerService(sessionKeyService, fileService);
+
+  const { sessionKeyAddress } = sessionKeyService.generateSessionKey();
+
+  let approval: string;
+
+  beforeAll(async () => {
+    approval = await generateApproval(sessionKeyAddress);
+  });
+
+  describe("deployMaci", () => {
+    it("should deploy all maci related contracts", async () => {
+      const maciAddress = await deployerService.deployMaci({
+        approval,
+        sessionKeyAddress,
+        chain: ESupportedNetworks.OPTIMISM_SEPOLIA,
+        config: testMaciDeploymentConfig,
+      });
+
+      expect(maciAddress).not.toBe(zeroAddress);
+    });
+  });
+
+  describe("deployPoll", () => {
+    it("should deploy a poll", async () => {
+      const poll = await deployerService.deployPoll({
+        approval,
+        sessionKeyAddress,
+        chain: ESupportedNetworks.OPTIMISM_SEPOLIA,
+        config: testPollDeploymentConfig,
+      });
+
+      expect(poll).toBeDefined();
+    });
+  });
+
+  describe("sessionKeys", () => {
+    it("should create a client from a session key and an approval", async () => {
+      const client = await sessionKeyService.generateClientFromSessionKey(
+        sessionKeyAddress,
+        approval,
+        ESupportedNetworks.OPTIMISM_SEPOLIA,
+      );
+
+      expect(client).toBeDefined();
+      expect(client.transport.key).toBe("http");
+      expect(client.key).toBe("Account");
+      expect(client.account.address).not.toBe(zeroAddress);
+      expect(client.account.kernelVersion).toBe(kernelVersion);
+      expect(client.account.entryPoint).toBe(entryPoint);
+      // this is an account with limited permissions so no sudo validator
+      expect(client.account.kernelPluginManager.address).toBe(zeroAddress);
+      expect(client.account.kernelPluginManager.sudoValidator).toBe(undefined);
+
+      // send a transaction
+      const tx = await client.sendTransaction({
+        to: zeroAddress,
+        value: 0n,
+        data: "0x",
+      });
+
+      expect(tx.length).toBeGreaterThan(0);
+    });
+
+    it("should not allow to create a client after the session key has been deactivated", async () => {
+      sessionKeyService.deactivateSessionKey(sessionKeyAddress);
+
+      await expect(
+        sessionKeyService.generateClientFromSessionKey(
+          sessionKeyAddress,
+          approval,
+          ESupportedNetworks.OPTIMISM_SEPOLIA,
+        ),
+      ).rejects.toThrow(ErrorCodes.SESSION_KEY_NOT_FOUND);
+    });
+  });
+});

packages/coordinator/ts/app.module.ts

@@ -2,6 +2,7 @@ import { Module } from "@nestjs/common";
 import { ThrottlerModule } from "@nestjs/throttler";
 
 import { CryptoModule } from "./crypto/crypto.module";
+import { DeployerModule } from "./deployer/deployer.module";
 import { FileModule } from "./file/file.module";
 import { ProofModule } from "./proof/proof.module";
 import { SessionKeysModule } from "./sessionKeys/sessionKeys.module";
@@ -20,6 +21,7 @@ import { SubgraphModule } from "./subgraph/subgraph.module";
     SubgraphModule,
     ProofModule,
     SessionKeysModule,
+    DeployerModule,
   ],
 })
 export class AppModule {}

packages/coordinator/ts/common/accountAbstraction.ts

@@ -1,26 +1,27 @@
+import { deserializePermissionAccount } from "@zerodev/permissions";
+import { toECDSASigner } from "@zerodev/permissions/signers";
+import { createKernelAccountClient, KernelAccountClient, KernelSmartAccount } from "@zerodev/sdk";
+import { KERNEL_V3_1 } from "@zerodev/sdk/constants";
 import dotenv from "dotenv";
-import { type Chain, createPublicClient, http, type HttpTransport, type PublicClient } from "viem";
+import { BundlerClient, createBundlerClient, ENTRYPOINT_ADDRESS_V07 } from "permissionless";
+import { ENTRYPOINT_ADDRESS_V07_TYPE } from "permissionless/types";
+import {
+  createPublicClient,
+  http,
+  type HttpTransport,
+  type TransactionReceipt,
+  type Transport,
+  type Hex,
+  type PublicClient,
+  Chain,
+} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
 
 import { ErrorCodes } from "./errors";
 import { ESupportedNetworks, viemChain } from "./networks";
 
 dotenv.config();
 
-/**
- * Generate the RPCUrl for Pimlico based on the chain we need to interact with
- * @param network - the network we want to interact with
- * @returns the RPCUrl for the network
- */
-export const genPimlicoRPCUrl = (network: string): string => {
-  const pimlicoAPIKey = process.env.PIMLICO_API_KEY;
-
-  if (!pimlicoAPIKey) {
-    throw new Error(ErrorCodes.PIMLICO_API_KEY_NOT_SET);
-  }
-
-  return `https://api.pimlico.io/v2/${network}/rpc?apikey=${pimlicoAPIKey}`;
-};
-
 /**
  * Generate the RPCUrl for Alchemy based on the chain we need to interact with
  * @param network - the network we want to interact with
@@ -53,3 +54,92 @@ export const getPublicClient = (chainName: ESupportedNetworks): PublicClient<Htt
     transport: http(genAlchemyRPCUrl(chainName)),
     chain: viemChain(chainName),
   });
+
+/**
+ * Get a bundler client
+ * @param chainName - the chain name
+ * @returns the bundler client
+ */
+export const getBundlerClient = (
+  chainName: ESupportedNetworks,
+): BundlerClient<ENTRYPOINT_ADDRESS_V07_TYPE, Chain | undefined> =>
+  createBundlerClient({
+    transport: http(genPimlicoRPCUrl(chainName)),
+    chain: viemChain(chainName),
+    entryPoint: ENTRYPOINT_ADDRESS_V07,
+  });
+
+/**
+ * Generate the RPCUrl for Pimlico based on the chain we need to interact with
+ * @param network - the network we want to interact with
+ * @returns the RPCUrl for the network
+ */
+export const genPimlicoRPCUrl = (network: string): string => {
+  const pimlicoAPIKey = process.env.PIMLICO_API_KEY;
+
+  if (!pimlicoAPIKey) {
+    throw new Error(ErrorCodes.PIMLICO_API_KEY_NOT_SET);
+  }
+
+  return `https://api.pimlico.io/v2/${network}/rpc?apikey=${pimlicoAPIKey}`;
+};
+
+/**
+ * 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 publicClient = getPublicClient(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(process.env.ZERODEV_BUNDLER_RPC),
+    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

@@ -12,7 +12,18 @@ export enum ErrorCodes {
   SUBGRAPH_DEPLOY = "7",
   SESSION_KEY_NOT_FOUND = "8",
   PIMLICO_API_KEY_NOT_SET = "9",
-  INVALID_APPROVAL = "10",
-  UNSUPPORTED_NETWORK = "11",
-  RPC_API_KEY_NOT_SET = "12",
+  UNSUPPORTED_VOICE_CREDIT_PROXY = "10",
+  UNSUPPORTED_GATEKEEPER = "11",
+  FAILED_TO_DEPLOY_CONTRACT = "12",
+  FAILED_TO_SET_MACI_INSTANCE_ON_GATEKEEPER = "13",
+  FAILED_TO_GET_NEXT_POLL_ID = "14",
+  INVALID_APPROVAL = "15",
+  MACI_NOT_DEPLOYED = "16",
+  VERIFIER_NOT_DEPLOYED = "17",
+  VK_REGISTRY_NOT_DEPLOYED = "18",
+  FAILED_TO_SET_VERIFYING_KEYS_ON_VK_REGISTRY = "19",
+  UNSUPPORTED_NETWORK = "20",
+  RPC_API_KEY_NOT_SET = "21",
+  FAILED_TO_DEPLOY_MACI = "22",
+  FAILED_TO_DEPLOY_POLL = "23",
 }

packages/coordinator/ts/common/index.ts

@@ -1,2 +1,3 @@
 export { ErrorCodes } from "./errors";
 export { ESupportedNetworks } from "./networks";
+export const MESSAGE_TREE_ARITY = 5n;