@maci-protocol/coordinator 0.0.0-ci.e3476db → 0.0.0-ci.e52a091

package/build/ts/deployer/deployer.service.js

@@ -7,29 +7,19 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var DeployerService_1;
-import { PubKey, VerifyingKey } from "@maci-protocol/domainobjs";
-import { ConstantInitialVoiceCreditProxy__factory as ConstantInitialVoiceCreditProxyFactory, ContractStorage, EPolicies, FreeForAllPolicy__factory as FreeForAllPolicyFactory, EASPolicy__factory as EASPolicyFactory, ZupassPolicy__factory as ZupassPolicyFactory, HatsPolicy__factory as HatsPolicyFactory, SemaphorePolicy__factory as SemaphorePolicyFactory, GitcoinPassportPolicy__factory as GitcoinPassportPolicyFactory, Verifier__factory as VerifierFactory, PoseidonT3__factory as PoseidonT3Factory, PoseidonT4__factory as PoseidonT4Factory, PoseidonT5__factory as PoseidonT5Factory, PoseidonT6__factory as PoseidonT6Factory, VkRegistry__factory as VkRegistryFactory, TallyFactory__factory as TallyFactoryFactory, PollFactory__factory as PollFactoryFactory, MessageProcessorFactory__factory as MessageProcessorFactoryFactory, MessageProcessor__factory as MessageProcessorFactory, ERC20VotesPolicy__factory as ERC20VotesPolicyFactory, Tally__factory as TallyFactory, Poll__factory as PollFactory, MACI__factory as MACIFactory, EContracts, EInitialVoiceCreditProxies, EMode, deployPoll, extractAllVks, extractVk, genEmptyBallotRoots, } from "@maci-protocol/sdk";
-import { Injectable, Logger } from "@nestjs/common";
+import { ContractStorage, EPolicies, VerifyingKeysRegistry__factory as VerifyingKeysRegistryFactory, MessageProcessor__factory as MessageProcessorFactory, Tally__factory as TallyFactory, Poll__factory as PollFactory, MACI__factory as MACIFactory, EContracts, EInitialVoiceCreditProxies, EMode, deployPoll, extractAllVerifyingKeys, deployConstantInitialVoiceCreditProxy, deployFreeForAllSignUpPolicy, deployERC20VotesPolicy, deployAnonAadhaarPolicy, deploySignupTokenPolicy, deployMerkleProofPolicy, deploySemaphoreSignupPolicy, deployZupassSignUpPolicy, deployGitcoinPassportPolicy, deployEASSignUpPolicy, deployHatsSignupPolicy, deployMaci, setVerifyingKeys, deployVerifyingKeysRegistryContract, generateEmptyBallotRoots, getDeployedPolicyProxyFactories, deployVerifier, ECheckerFactories, EPolicyFactories, } from "@maci-protocol/sdk";
+import { Injectable } from "@nestjs/common";
 import { BaseContract } from "ethers";
-import { encodeFunctionData } from "viem";
-import path from "path";
 import { ErrorCodes } from "../common";
-import { getBundlerClient, getDeployedContractAddress, getPublicClient } from "../common/accountAbstraction";
+import { getCoordinatorKeypair } from "../common/coordinatorKeypair";
 import { FileService } from "../file/file.service";
 import { SessionKeysService } from "../sessionKeys/sessionKeys.service";
-import { MAX_GAS_LIMIT } from "./constants";
-import { estimateExtraGasLimit } from "./utils";
 /**
  * DeployerService is responsible for deploying contracts.
  */
-let DeployerService = DeployerService_1 = class DeployerService {
+let DeployerService = class DeployerService {
     sessionKeysService;
     fileService;
-    /**
-     * Logger
-     */
-    logger = new Logger(DeployerService_1.name);
     /**
      * Contract storage instance
      */
@@ -42,299 +32,291 @@ let DeployerService = DeployerService_1 = class DeployerService {
     constructor(sessionKeysService, fileService) {
         this.sessionKeysService = sessionKeysService;
         this.fileService = fileService;
-        this.logger = new Logger(DeployerService_1.name);
-        this.storage = ContractStorage.getInstance(path.join(process.cwd(), "deployed-contracts.json"));
+        this.storage = ContractStorage.getInstance();
     }
     /**
-     * Get the policy abi and bytecode based on the policy type
-     * and also check if there is already an instance deployed
+     * Get the policy contract object
+     * always deploy and save it
      *
-     * @param policyType - the policy type
+     * @param signer - the signer
      * @param network - the network
-     * @param args - the policy args
-     * @returns - the policy abi and bytecode
+     * @param policyConfig - the policy configuration parameters
+     * @returns - the policy contract
      */
-    getPolicyData(policyType, network, args) {
-        const address = this.storage.getAddress(policyType, network);
-        let storedArgs;
-        let isAlreadyDeployed;
+    async deployAndSavePolicy(signer, network, policyConfig) {
+        let policyContract;
+        let policyFactory;
+        let checkFactory;
+        let policyFactoryName;
+        let checkFactoryName;
+        let factoryIsSaved;
+        let checkerIsSaved;
+        const { type, args } = policyConfig;
         // based on the policy type, we need to deploy the correct policy
-        switch (policyType) {
+        switch (type) {
             case EPolicies.FreeForAll: {
-                return {
-                    address,
-                    abi: FreeForAllPolicyFactory.abi,
-                    bytecode: FreeForAllPolicyFactory.bytecode,
-                    alreadyDeployed: !!address,
-                };
+                policyFactoryName = EPolicyFactories.FreeForAll;
+                checkFactoryName = ECheckerFactories.FreeForAll;
+                const factories = await getDeployedPolicyProxyFactories({
+                    policy: policyFactoryName,
+                    checker: checkFactoryName,
+                    network,
+                    signer,
+                });
+                factoryIsSaved = !!factories.policy;
+                checkerIsSaved = !!factories.checker;
+                [policyContract, , policyFactory, checkFactory] = await deployFreeForAllSignUpPolicy(factories, signer, true);
+                break;
             }
             case EPolicies.EAS: {
-                storedArgs = this.storage.getContractArgs(policyType, network);
-                isAlreadyDeployed =
-                    !!storedArgs &&
-                        storedArgs.length === 3 &&
-                        storedArgs[0] === args.easAddress &&
-                        storedArgs[1] === args.schema &&
-                        storedArgs[2] === args.attester;
-                return {
-                    address: isAlreadyDeployed ? address : undefined,
-                    abi: EASPolicyFactory.abi,
-                    bytecode: EASPolicyFactory.bytecode,
-                    alreadyDeployed: isAlreadyDeployed,
-                };
+                policyFactoryName = EPolicyFactories.EAS;
+                checkFactoryName = ECheckerFactories.EAS;
+                const factories = await getDeployedPolicyProxyFactories({
+                    policy: policyFactoryName,
+                    checker: checkFactoryName,
+                    network,
+                    signer,
+                });
+                factoryIsSaved = !!factories.policy;
+                checkerIsSaved = !!factories.checker;
+                [policyContract, , policyFactory, checkFactory] = await deployEASSignUpPolicy({
+                    eas: args.easAddress,
+                    attester: args.attester,
+                    schema: args.schema,
+                }, factories, signer, true);
+                break;
             }
-            case EPolicies.Zupass: {
-                storedArgs = this.storage.getContractArgs(policyType, network);
-                isAlreadyDeployed =
-                    !!storedArgs &&
-                        storedArgs.length === 4 &&
-                        storedArgs[0] === args.signer1 &&
-                        storedArgs[1] === args.signer2 &&
-                        storedArgs[2] === args.eventId &&
-                        storedArgs[3] === args.zupassVerifier;
-                return {
-                    address: isAlreadyDeployed ? address : undefined,
-                    abi: ZupassPolicyFactory.abi,
-                    bytecode: ZupassPolicyFactory.bytecode,
-                    alreadyDeployed: isAlreadyDeployed,
-                };
+            case EPolicies.GitcoinPassport: {
+                policyFactoryName = EPolicyFactories.GitcoinPassport;
+                checkFactoryName = ECheckerFactories.GitcoinPassport;
+                const factories = await getDeployedPolicyProxyFactories({
+                    policy: policyFactoryName,
+                    checker: checkFactoryName,
+                    network,
+                    signer,
+                });
+                factoryIsSaved = !!factories.policy;
+                checkerIsSaved = !!factories.checker;
+                [policyContract, , policyFactory, checkFactory] = await deployGitcoinPassportPolicy({
+                    decoderAddress: args.decoderAddress,
+                    minimumScore: Number(args.passingScore),
+                }, factories, signer, true);
+                break;
             }
             case EPolicies.Hats: {
-                storedArgs = this.storage.getContractArgs(policyType, network);
-                isAlreadyDeployed =
-                    !!storedArgs &&
-                        storedArgs.length === 2 &&
-                        storedArgs[0] === args.hatsProtocolAddress &&
-                        JSON.stringify(storedArgs[1]) === JSON.stringify(args.critrionHats);
-                return {
-                    address: isAlreadyDeployed ? address : undefined,
-                    abi: HatsPolicyFactory.abi,
-                    bytecode: HatsPolicyFactory.bytecode,
-                    alreadyDeployed: isAlreadyDeployed,
-                };
+                policyFactoryName = EPolicyFactories.Hats;
+                checkFactoryName = ECheckerFactories.Hats;
+                const factories = await getDeployedPolicyProxyFactories({
+                    policy: policyFactoryName,
+                    checker: checkFactoryName,
+                    network,
+                    signer,
+                });
+                factoryIsSaved = !!factories.policy;
+                checkerIsSaved = !!factories.checker;
+                [policyContract, , policyFactory, checkFactory] = await deployHatsSignupPolicy({
+                    hats: args.hatsProtocolAddress,
+                    criterionHats: args.critrionHats.map((c) => BigInt(c)),
+                }, factories, signer, true);
+                break;
+            }
+            case EPolicies.Zupass: {
+                policyFactoryName = EPolicyFactories.Zupass;
+                checkFactoryName = ECheckerFactories.Zupass;
+                const factories = await getDeployedPolicyProxyFactories({
+                    policy: policyFactoryName,
+                    checker: checkFactoryName,
+                    network,
+                    signer,
+                });
+                factoryIsSaved = !!factories.policy;
+                checkerIsSaved = !!factories.checker;
+                [policyContract, , policyFactory, checkFactory] = await deployZupassSignUpPolicy({
+                    eventId: args.eventId,
+                    signer1: args.signer1,
+                    signer2: args.signer2,
+                    verifier: args.zupassVerifier,
+                }, factories, signer, true);
+                break;
             }
             case EPolicies.Semaphore: {
-                storedArgs = this.storage.getContractArgs(policyType, network);
-                isAlreadyDeployed =
-                    !!storedArgs &&
-                        storedArgs.length === 2 &&
-                        storedArgs[0] === args.semaphoreContract &&
-                        storedArgs[1] === args.groupId;
-                return {
-                    address: isAlreadyDeployed ? address : undefined,
-                    abi: SemaphorePolicyFactory.abi,
-                    bytecode: SemaphorePolicyFactory.bytecode,
-                    alreadyDeployed: isAlreadyDeployed,
-                };
+                policyFactoryName = EPolicyFactories.Semaphore;
+                checkFactoryName = ECheckerFactories.Semaphore;
+                const factories = await getDeployedPolicyProxyFactories({
+                    policy: policyFactoryName,
+                    checker: checkFactoryName,
+                    network,
+                    signer,
+                });
+                factoryIsSaved = !!factories.policy;
+                checkerIsSaved = !!factories.checker;
+                [policyContract, , policyFactory, checkFactory] = await deploySemaphoreSignupPolicy({
+                    semaphore: args.semaphoreContract,
+                    groupId: BigInt(args.groupId),
+                }, factories, signer, true);
+                break;
             }
-            case EPolicies.GitcoinPassport: {
-                storedArgs = this.storage.getContractArgs(policyType, network);
-                isAlreadyDeployed =
-                    !!storedArgs &&
-                        storedArgs.length === 2 &&
-                        storedArgs[0] === args.decoderAddress &&
-                        storedArgs[1] === args.passingScore;
-                return {
-                    address: isAlreadyDeployed ? address : undefined,
-                    abi: GitcoinPassportPolicyFactory.abi,
-                    bytecode: GitcoinPassportPolicyFactory.bytecode,
-                    alreadyDeployed: isAlreadyDeployed,
-                };
+            case EPolicies.MerkleProof: {
+                policyFactoryName = EPolicyFactories.MerkleProof;
+                checkFactoryName = ECheckerFactories.MerkleProof;
+                const factories = await getDeployedPolicyProxyFactories({
+                    policy: policyFactoryName,
+                    checker: checkFactoryName,
+                    network,
+                    signer,
+                });
+                factoryIsSaved = !!factories.policy;
+                checkerIsSaved = !!factories.checker;
+                [policyContract, , policyFactory, checkFactory] = await deployMerkleProofPolicy({
+                    root: args.root,
+                }, factories, signer, true);
+                break;
+            }
+            case EPolicies.Token: {
+                policyFactoryName = EPolicyFactories.Token;
+                checkFactoryName = ECheckerFactories.Token;
+                const factories = await getDeployedPolicyProxyFactories({
+                    policy: policyFactoryName,
+                    checker: checkFactoryName,
+                    network,
+                    signer,
+                });
+                factoryIsSaved = !!factories.policy;
+                checkerIsSaved = !!factories.checker;
+                [policyContract, , policyFactory, checkFactory] = await deploySignupTokenPolicy({
+                    token: args.token,
+                }, factories, signer, true);
+                break;
+            }
+            case EPolicies.AnonAadhaar: {
+                policyFactoryName = EPolicyFactories.AnonAadhaar;
+                checkFactoryName = ECheckerFactories.AnonAadhaar;
+                const factories = await getDeployedPolicyProxyFactories({
+                    policy: policyFactoryName,
+                    checker: checkFactoryName,
+                    network,
+                    signer,
+                });
+                factoryIsSaved = !!factories.policy;
+                checkerIsSaved = !!factories.checker;
+                [policyContract, , policyFactory, checkFactory] = await deployAnonAadhaarPolicy({
+                    verifierAddress: args.verifier,
+                    nullifierSeed: args.nullifierSeed,
+                }, factories, signer, true);
+                break;
             }
             case EPolicies.ERC20Votes: {
-                storedArgs = this.storage.getContractArgs(policyType, network);
-                isAlreadyDeployed =
-                    !!storedArgs &&
-                        storedArgs.length === 3 &&
-                        storedArgs[0] === args.token &&
-                        storedArgs[1] === args.factor &&
-                        storedArgs[2] === args.snapshotBlock;
-                return {
-                    address: isAlreadyDeployed ? address : undefined,
-                    abi: ERC20VotesPolicyFactory.abi,
-                    bytecode: ERC20VotesPolicyFactory.bytecode,
-                    alreadyDeployed: isAlreadyDeployed,
-                };
+                policyFactoryName = EPolicyFactories.ERC20Votes;
+                checkFactoryName = ECheckerFactories.ERC20Votes;
+                const factories = await getDeployedPolicyProxyFactories({
+                    policy: policyFactoryName,
+                    checker: checkFactoryName,
+                    network,
+                    signer,
+                });
+                factoryIsSaved = !!factories.policy;
+                checkerIsSaved = !!factories.checker;
+                [policyContract, , policyFactory, checkFactory] = await deployERC20VotesPolicy({
+                    snapshotBlock: BigInt(args.snapshotBlock),
+                    threshold: BigInt(args.threshold),
+                    token: args.token,
+                }, factories, signer, true);
+                break;
             }
             default:
                 throw new Error(ErrorCodes.UNSUPPORTED_POLICY.toString());
         }
+        await this.storage.register({
+            id: type,
+            name: type,
+            contract: policyContract,
+            args: args ? Object.values(args).map((arg) => String(arg)) : [],
+            network,
+        });
+        if (!factoryIsSaved) {
+            await this.storage.register({
+                id: policyFactoryName,
+                name: policyFactoryName,
+                contract: policyFactory,
+                network,
+            });
+        }
+        if (!checkerIsSaved) {
+            await this.storage.register({
+                id: checkFactoryName,
+                name: checkFactoryName,
+                contract: checkFactory,
+                network,
+            });
+        }
+        return policyContract;
     }
     /**
-     * Get the voice credit proxy abi and bytecode based on the voice credit proxy type
-     * and also check if there is already an instance deployed
+     * Get the voice credit proxy contract object
+     * always deploy and save it
      *
+     * @param signer - the signer
      * @param voiceCreditProxyType - the voice credit proxy type
      * @param network - the network
-     * @param args - the voice credit proxy args
-     * @returns - the voice credit proxy abi and bytecode
+     * @param args - the args
+     * @returns - the voice credit proxy contract
      */
-    getVoiceCreditProxyData(voiceCreditProxyType, network, args) {
-        let storedArgs;
-        let isAlreadyDeployed;
-        const address = this.storage.getAddress(voiceCreditProxyType, network);
+    async deployAndSaveVoiceCreditProxy(signer, voiceCreditProxyType, network, args) {
+        let contract;
         switch (voiceCreditProxyType) {
             case EInitialVoiceCreditProxies.Constant: {
-                storedArgs = this.storage.getContractArgs(voiceCreditProxyType, network);
-                isAlreadyDeployed = !!storedArgs && storedArgs[0] === args.amount;
-                return {
-                    address: isAlreadyDeployed ? address : undefined,
-                    abi: ConstantInitialVoiceCreditProxyFactory.abi,
-                    bytecode: ConstantInitialVoiceCreditProxyFactory.bytecode,
-                    alreadyDeployed: isAlreadyDeployed,
-                };
+                [contract] = await deployConstantInitialVoiceCreditProxy({
+                    amount: args.amount,
+                }, signer, undefined, true);
+                break;
             }
             default:
                 throw new Error(ErrorCodes.UNSUPPORTED_VOICE_CREDIT_PROXY.toString());
         }
-    }
-    /**
-     * @param abi - the abi
-     * @param bytecode - the bytecode
-     * @param args - the args
-     * @param publicClient - the public client
-     * @returns - the address
-     */
-    async deployAndGetAddress(kernelClient, abi, bytecode, args, bundlerClient, publicClient) {
-        const deployCallData = await kernelClient.account.encodeDeployCallData({
-            abi,
-            args,
-            bytecode,
-        });
-        const gasPrice = await kernelClient.getUserOperationGasPrice();
-        const opEstimate = await kernelClient.prepareUserOperation({
-            callData: deployCallData,
-            sender: kernelClient.account.address,
-            maxFeePerGas: gasPrice.maxFeePerGas,
-            maxPriorityFeePerGas: gasPrice.maxPriorityFeePerGas,
-        });
-        const callGasLimitMultiplier = estimateExtraGasLimit(opEstimate.callGasLimit);
-        const tx = await kernelClient.sendUserOperation({
-            callData: deployCallData,
-            sender: kernelClient.account.address,
-            maxFeePerGas: gasPrice.maxFeePerGas,
-            maxPriorityFeePerGas: gasPrice.maxPriorityFeePerGas,
-            callGasLimit: opEstimate.callGasLimit + callGasLimitMultiplier < MAX_GAS_LIMIT
-                ? opEstimate.callGasLimit + callGasLimitMultiplier
-                : MAX_GAS_LIMIT,
-        });
-        const receipt = await bundlerClient.waitForUserOperationReceipt({
-            hash: tx,
-        });
-        const txReceipt = await publicClient.getTransactionReceipt({
-            hash: receipt.receipt.transactionHash,
-        });
-        return getDeployedContractAddress(txReceipt);
-    }
-    /**
-     * Deploy a contract and store the address
-     *
-     * @param contract - the contract to deploy
-     * @param args - the args
-     * @param abi - the abi
-     * @param bytecode - the bytecode
-     * @param kernelClient - the kernel client
-     * @param publicClient - the public client
-     * @param chain - the chain
-     * @returns - the address of the deployed contract
-     */
-    async deployAndStore(contract, args, abi, bytecode, kernelClient, bundlerClient, publicClient, chain) {
-        let address = this.storage.getAddress(contract, chain);
-        if (!address) {
-            address = await this.deployAndGetAddress(kernelClient, abi, bytecode, args, bundlerClient, publicClient);
-            if (!address) {
-                this.logger.error(`Failed to deploy contract: ${contract}`);
-                throw new Error(`${ErrorCodes.FAILED_TO_DEPLOY_CONTRACT} ${contract}`);
-            }
-            await this.storage.register({
-                id: contract,
-                contract: new BaseContract(address, abi),
-                args: args.map((arg) => {
-                    if (Array.isArray(arg)) {
-                        return arg.map((a) => String(a));
-                    }
-                    return String(arg);
-                }),
-                network: chain,
-            });
-        }
-        return address;
-    }
-    /**
-     * Estimate gas, add a bit extra and send the user operation (aka. transaction)
-     * @param to - the to address of the user operation
-     * @param value - the value of the user operation
-     * @param abi - the abi
-     * @param functionName - the function name
-     * @param args - the args
-     * @param errorMessage - the error message
-     * @param kernelClient - the kernel client
-     * @param bundlerClient - the bundler client
-     */
-    async estimateGasAndSend(to, value, abi, functionName, args, errorMessage, kernelClient, bundlerClient) {
-        const gasEstimates = await kernelClient.getUserOperationGasPrice();
-        const userOperation = {
-            sender: kernelClient.account.address,
-            maxFeePerGas: gasEstimates.maxFeePerGas,
-            maxPriorityFeePerGas: gasEstimates.maxPriorityFeePerGas,
-            callData: await kernelClient.account.encodeCalls([
-                {
-                    to,
-                    value,
-                    data: encodeFunctionData({
-                        abi,
-                        functionName,
-                        args,
-                    }),
-                },
-            ]),
-        };
-        const opEstimate = await kernelClient.prepareUserOperation(userOperation);
-        const callGasLimitMultiplier = estimateExtraGasLimit(opEstimate.callGasLimit);
-        const userOperationHash = await kernelClient.sendUserOperation({
-            ...userOperation,
-            callGasLimit: opEstimate.callGasLimit + callGasLimitMultiplier < MAX_GAS_LIMIT
-                ? opEstimate.callGasLimit + callGasLimitMultiplier
-                : MAX_GAS_LIMIT,
+        await this.storage.register({
+            id: voiceCreditProxyType,
+            contract,
+            args: args ? Object.values(args).map((arg) => String(arg)) : [],
+            network,
         });
-        const receipt = await bundlerClient.waitForUserOperationReceipt({ hash: userOperationHash });
-        if (!receipt.success) {
-            throw new Error(errorMessage);
-        }
-        return receipt;
+        return contract;
     }
     /**
      * Get verifying keys arguments (specially zkey paths)
      * @param signer - the signer
-     * @param vkRegistryContract - the deployed vk registry contract
-     * @param vkRegistryArgs - the arguments send to the endpoint
+     * @param verifyingKeysRegistryContract - the deployed verifyingKey registry contract
+     * @param verifyingKeysRegistryArgs - the arguments send to the endpoint
      * @param mode - use QV or NON_QV
      * @returns SetVerifyingKeysArgs
      */
-    async getVerifyingKeysArgs(signer, vkRegistryContract, vkRegistryArgs, mode) {
-        const pollJoiningZkeyPath = this.fileService.getZkeyFilePaths(process.env.COORDINATOR_POLL_JOINING_ZKEY_NAME, true).zkey;
-        const pollJoinedZkeyPath = this.fileService.getZkeyFilePaths(process.env.COORDINATOR_POLL_JOINED_ZKEY_NAME, true).zkey;
-        const processMessagesZkeyPath = this.fileService.getZkeyFilePaths(process.env.COORDINATOR_MESSAGE_PROCESS_ZKEY_NAME, mode === EMode.QV).zkey;
-        const tallyVotesZkeyPath = this.fileService.getZkeyFilePaths(process.env.COORDINATOR_TALLY_ZKEY_NAME, mode === EMode.QV).zkey;
-        const { pollJoiningVk, pollJoinedVk, processVk, tallyVk } = await extractAllVks({
+    async getVerifyingKeysArgs(signer, verifyingKeysRegistryAddress, verifyingKeysRegistryArgs, mode) {
+        const { zkey: pollJoiningZkeyPath } = this.fileService.getZkeyFilePaths(process.env.COORDINATOR_POLL_JOINING_ZKEY_NAME);
+        const { zkey: pollJoinedZkeyPath } = this.fileService.getZkeyFilePaths(process.env.COORDINATOR_POLL_JOINED_ZKEY_NAME);
+        const { zkey: messageProcessorZkeyPath } = this.fileService.getZkeyFilePaths(process.env.COORDINATOR_MESSAGE_PROCESS_ZKEY_NAME, mode);
+        // There are only QV and Non-QV modes available for tally circuit
+        const { zkey: voteTallyZkeyPath } = this.fileService.getZkeyFilePaths(process.env.COORDINATOR_TALLY_ZKEY_NAME, 
+        // if FULL use NON_QV because there are only VoteTallyQV and VoteTallyNonQV zkeys
+        mode === EMode.FULL ? EMode.NON_QV : mode);
+        const { pollJoiningVerifyingKey, pollJoinedVerifyingKey, processVerifyingKey, tallyVerifyingKey } = await extractAllVerifyingKeys({
             pollJoiningZkeyPath,
             pollJoinedZkeyPath,
-            processMessagesZkeyPath,
-            tallyVotesZkeyPath,
+            messageProcessorZkeyPath,
+            voteTallyZkeyPath,
         });
-        const { stateTreeDepth, intStateTreeDepth, voteOptionTreeDepth, messageBatchSize } = vkRegistryArgs;
+        const { stateTreeDepth, pollStateTreeDepth, tallyProcessingStateTreeDepth, voteOptionTreeDepth, messageBatchSize } = verifyingKeysRegistryArgs;
         return {
-            pollJoiningVk: pollJoiningVk,
-            pollJoinedVk: pollJoinedVk,
-            processMessagesVk: processVk,
-            tallyVotesVk: tallyVk,
+            pollJoiningVerifyingKey: pollJoiningVerifyingKey,
+            pollJoinedVerifyingKey: pollJoinedVerifyingKey,
+            processMessagesVerifyingKey: processVerifyingKey,
+            tallyVotesVerifyingKey: tallyVerifyingKey,
             stateTreeDepth: Number(stateTreeDepth),
-            intStateTreeDepth: Number(intStateTreeDepth),
+            tallyProcessingStateTreeDepth: Number(tallyProcessingStateTreeDepth),
             voteOptionTreeDepth: Number(voteOptionTreeDepth),
             messageBatchSize: Number(messageBatchSize),
+            pollStateTreeDepth: Number(pollStateTreeDepth),
             signer,
             mode,
-            vkRegistryAddress: await vkRegistryContract.getAddress(),
+            verifyingKeysRegistryAddress,
         };
     }
     /**
@@ -346,161 +328,46 @@ let DeployerService = DeployerService_1 = class DeployerService {
      * @returns the address of the deployed maci contract
      */
     async deployMaci({ approval, sessionKeyAddress, chain, config }) {
-        const publicClient = getPublicClient(chain);
-        const bundlerClient = getBundlerClient(chain);
-        const kernelClient = await this.sessionKeysService.generateClientFromSessionKey(sessionKeyAddress, approval, chain);
-        let policyAddress = this.storage.getAddress(config.policy.type, chain);
-        const policyData = this.getPolicyData(config.policy.type, chain, config.policy.args);
-        // if the policy is not already deployed, we need to deploy it
-        if (!policyData.alreadyDeployed) {
-            policyAddress = await this.deployAndStore(config.policy.type, config.policy.args ? Object.values(config.policy.args) : [], policyData.abi, policyData.bytecode, kernelClient, bundlerClient, publicClient, chain);
-        }
-        // deploy all maci contracts
-        // (we are not using Promise.all because the write tx nonce should be sequential)
-        // 1. verifier
-        await this.deployAndStore(EContracts.Verifier, [], VerifierFactory.abi, VerifierFactory.bytecode, kernelClient, bundlerClient, publicClient, chain);
-        // 2. poseidon
-        let poseidonT3Address;
-        let poseidonT4Address;
-        let poseidonT5Address;
-        let poseidonT6Address;
-        if (config.Poseidon) {
-            // Some times the poseidon contracts are already deployed so we don't need to deploy them again
-            poseidonT3Address = config.Poseidon.poseidonT3;
-            poseidonT4Address = config.Poseidon.poseidonT4;
-            poseidonT5Address = config.Poseidon.poseidonT5;
-            poseidonT6Address = config.Poseidon.poseidonT6;
-        }
-        else {
-            poseidonT3Address = await this.deployAndStore(EContracts.PoseidonT3, [], PoseidonT3Factory.abi, PoseidonT3Factory.bytecode, kernelClient, bundlerClient, publicClient, chain);
-            poseidonT4Address = await this.deployAndStore(EContracts.PoseidonT4, [], PoseidonT4Factory.abi, PoseidonT4Factory.bytecode, kernelClient, bundlerClient, publicClient, chain);
-            poseidonT5Address = await this.deployAndStore(EContracts.PoseidonT5, [], PoseidonT5Factory.abi, PoseidonT5Factory.bytecode, kernelClient, bundlerClient, publicClient, chain);
-            poseidonT6Address = await this.deployAndStore(EContracts.PoseidonT6, [], PoseidonT6Factory.abi, PoseidonT6Factory.bytecode, kernelClient, bundlerClient, publicClient, chain);
-        }
-        // 3. factories
-        const pollFactoryAddress = await this.deployAndStore(EContracts.PollFactory, [], PollFactoryFactory.abi, PollFactoryFactory.linkBytecode({
-            "contracts/crypto/PoseidonT3.sol:PoseidonT3": poseidonT3Address,
-            "contracts/crypto/PoseidonT4.sol:PoseidonT4": poseidonT4Address,
-            "contracts/crypto/PoseidonT5.sol:PoseidonT5": poseidonT5Address,
-            "contracts/crypto/PoseidonT6.sol:PoseidonT6": poseidonT6Address,
-        }), kernelClient, bundlerClient, publicClient, chain);
-        const tallyFactoryAddress = await this.deployAndStore(EContracts.TallyFactory, [], TallyFactoryFactory.abi, TallyFactoryFactory.linkBytecode({
-            "contracts/crypto/PoseidonT3.sol:PoseidonT3": poseidonT3Address,
-            "contracts/crypto/PoseidonT4.sol:PoseidonT4": poseidonT4Address,
-            "contracts/crypto/PoseidonT5.sol:PoseidonT5": poseidonT5Address,
-            "contracts/crypto/PoseidonT6.sol:PoseidonT6": poseidonT6Address,
-        }), kernelClient, bundlerClient, publicClient, chain);
-        const messageProcessorFactoryAddress = await this.deployAndStore(EContracts.MessageProcessorFactory, [], MessageProcessorFactoryFactory.abi, MessageProcessorFactoryFactory.linkBytecode({
-            "contracts/crypto/PoseidonT3.sol:PoseidonT3": poseidonT3Address,
-            "contracts/crypto/PoseidonT4.sol:PoseidonT4": poseidonT4Address,
-            "contracts/crypto/PoseidonT5.sol:PoseidonT5": poseidonT5Address,
-            "contracts/crypto/PoseidonT6.sol:PoseidonT6": poseidonT6Address,
-        }), kernelClient, bundlerClient, publicClient, chain);
-        // 4. VkRegistry
-        const vkRegistryAddress = await this.deployAndStore(EContracts.VkRegistry, [], VkRegistryFactory.abi, VkRegistryFactory.bytecode, kernelClient, bundlerClient, publicClient, chain);
-        try {
-            const processMessagesZkeyPathQv = this.fileService.getZkeyFilePaths(process.env.COORDINATOR_MESSAGE_PROCESS_ZKEY_NAME, true);
-            const tallyVotesZkeyPathQv = this.fileService.getZkeyFilePaths(process.env.COORDINATOR_TALLY_ZKEY_NAME, true);
-            const processMessagesZkeyPathNonQv = this.fileService.getZkeyFilePaths(process.env.COORDINATOR_MESSAGE_PROCESS_ZKEY_NAME, false);
-            const tallyVotesZkeyPathNonQv = this.fileService.getZkeyFilePaths(process.env.COORDINATOR_TALLY_ZKEY_NAME, false);
-            const pollJoiningZkeyPath = this.fileService.getZkeyFilePaths(process.env.COORDINATOR_POLL_JOINING_ZKEY_NAME, true);
-            const pollJoinedZkeyPath = this.fileService.getZkeyFilePaths(process.env.COORDINATOR_POLL_JOINED_ZKEY_NAME, true);
-            const [qvProcessVk, qvTallyVk, nonQvProcessVk, nonQvTallyVk, pollJoiningVk, pollJoinedVk] = await Promise.all([
-                extractVk(processMessagesZkeyPathQv.zkey),
-                extractVk(tallyVotesZkeyPathQv.zkey),
-                extractVk(processMessagesZkeyPathNonQv.zkey),
-                extractVk(tallyVotesZkeyPathNonQv.zkey),
-                extractVk(pollJoiningZkeyPath.zkey),
-                extractVk(pollJoinedZkeyPath.zkey),
-            ]).then((vks) => vks.map((vk) => vk && VerifyingKey.fromObj(vk).asContractParam()));
-            const processZkeys = [qvProcessVk, nonQvProcessVk].filter(Boolean);
-            const tallyZkeys = [qvTallyVk, nonQvTallyVk].filter(Boolean);
-            // check if the keys are already set
-            const [isProcessVkSet, isProcessNonQvVkSet, isTallyVkSet, isTallyNonQvVkSet] = await Promise.all([
-                publicClient.readContract({
-                    address: vkRegistryAddress,
-                    abi: VkRegistryFactory.abi,
-                    functionName: "hasProcessVk",
-                    args: [
-                        config.VkRegistry.args.stateTreeDepth,
-                        config.VkRegistry.args.voteOptionTreeDepth,
-                        config.VkRegistry.args.messageBatchSize,
-                        EMode.QV,
-                    ],
-                }),
-                publicClient.readContract({
-                    address: vkRegistryAddress,
-                    abi: VkRegistryFactory.abi,
-                    functionName: "hasProcessVk",
-                    args: [
-                        config.VkRegistry.args.stateTreeDepth,
-                        config.VkRegistry.args.voteOptionTreeDepth,
-                        config.VkRegistry.args.messageBatchSize,
-                        EMode.NON_QV,
-                    ],
-                }),
-                publicClient.readContract({
-                    address: vkRegistryAddress,
-                    abi: VkRegistryFactory.abi,
-                    functionName: "hasTallyVk",
-                    args: [
-                        config.VkRegistry.args.stateTreeDepth,
-                        config.VkRegistry.args.intStateTreeDepth,
-                        config.VkRegistry.args.voteOptionTreeDepth,
-                        EMode.QV,
-                    ],
-                }),
-                publicClient.readContract({
-                    address: vkRegistryAddress,
-                    abi: VkRegistryFactory.abi,
-                    functionName: "hasTallyVk",
-                    args: [
-                        config.VkRegistry.args.stateTreeDepth,
-                        config.VkRegistry.args.intStateTreeDepth,
-                        config.VkRegistry.args.voteOptionTreeDepth,
-                        EMode.NON_QV,
-                    ],
-                }),
-            ]);
-            if (isProcessVkSet && isProcessNonQvVkSet && isTallyVkSet && isTallyNonQvVkSet) {
-                this.logger.debug("Verifying keys are already set on the vk registry");
-            }
-            else {
-                await this.estimateGasAndSend(vkRegistryAddress, 0n, VkRegistryFactory.abi, "setVerifyingKeysBatch", [
-                    config.VkRegistry.args.stateTreeDepth,
-                    config.VkRegistry.args.intStateTreeDepth,
-                    config.VkRegistry.args.voteOptionTreeDepth,
-                    config.VkRegistry.args.messageBatchSize,
-                    [EMode.QV, EMode.NON_QV],
-                    pollJoiningVk,
-                    pollJoinedVk,
-                    processZkeys,
-                    tallyZkeys,
-                ], ErrorCodes.FAILED_TO_SET_VERIFYING_KEYS_ON_VK_REGISTRY.toString(), kernelClient, bundlerClient);
-            }
-        }
-        catch (error) {
-            this.logger.error("Failed to set verifying keys on vk registry: ", error);
-            throw error;
-        }
-        // 5. maci (here we don't check whether one is already deployed, we just deploy it)
-        const emptyBallotRoots = genEmptyBallotRoots(config.MACI.stateTreeDepth);
-        const maciAddress = await this.deployAndStore(EContracts.MACI, [
-            pollFactoryAddress,
-            messageProcessorFactoryAddress,
-            tallyFactoryAddress,
-            policyAddress,
-            config.MACI.stateTreeDepth,
-            emptyBallotRoots,
-        ], MACIFactory.abi, MACIFactory.linkBytecode({
-            "contracts/crypto/PoseidonT3.sol:PoseidonT3": "0x07490eba00dc4ACA6721D052Fa4C5002Aa077233",
-            "contracts/crypto/PoseidonT4.sol:PoseidonT4": "0xbb0e724CE02e5E7eDd31e632dc6e59F229a1126d",
-            "contracts/crypto/PoseidonT5.sol:PoseidonT5": "0xE0398F7DFAC494c530F6404AfEaC8669ABeD2679",
-            "contracts/crypto/PoseidonT6.sol:PoseidonT6": "0xfD77833F10a29c76A6a0ede235Eb651D744d0E2F",
-        }), kernelClient, bundlerClient, publicClient, chain);
-        // set the gate on the policy
-        await this.estimateGasAndSend(policyAddress, 0n, policyData.abi, "setTarget", [maciAddress], ErrorCodes.FAILED_TO_SET_MACI_INSTANCE_ON_POLICY.toString(), kernelClient, bundlerClient);
-        return { address: maciAddress };
+        const signer = await this.sessionKeysService.getCoordinatorSigner(chain, sessionKeyAddress, approval);
+        const policyContract = await this.deployAndSavePolicy(signer, chain, config.policy);
+        const policyAddress = await policyContract.getAddress();
+        const verifierContract = await deployVerifier(signer, true);
+        const verifyingKeysRegistryAddress = await deployVerifyingKeysRegistryContract({ signer });
+        const verifyingKeysArgs = await this.getVerifyingKeysArgs(signer, verifyingKeysRegistryAddress, config.VerifyingKeysRegistry.args, config.MACI.mode);
+        await setVerifyingKeys(verifyingKeysArgs);
+        // deploy the smart contracts
+        const maciAddresses = await deployMaci({
+            stateTreeDepth: config.MACI.stateTreeDepth,
+            signer,
+            signupPolicyAddress: policyAddress,
+        });
+        // store the contracts
+        await Promise.all([
+            this.storage.register({
+                id: EContracts.Verifier,
+                contract: verifierContract,
+                network: chain,
+            }),
+            this.storage.register({
+                id: EContracts.VerifyingKeysRegistry,
+                contract: new BaseContract(verifyingKeysRegistryAddress, VerifyingKeysRegistryFactory.abi),
+                network: chain,
+            }),
+            this.storage.register({
+                id: EContracts.MACI,
+                contract: new BaseContract(maciAddresses.maciContractAddress, MACIFactory.abi),
+                args: [
+                    maciAddresses.pollFactoryContractAddress,
+                    maciAddresses.messageProcessorFactoryContractAddress,
+                    maciAddresses.tallyFactoryContractAddress,
+                    policyAddress,
+                    config.MACI.stateTreeDepth,
+                    generateEmptyBallotRoots(config.MACI.stateTreeDepth).map((root) => root.toString()),
+                ],
+                network: chain,
+            }),
+        ]);
+        return { address: maciAddresses.maciContractAddress };
     }
     /**
      * Deploy a poll
@@ -509,10 +376,7 @@ let DeployerService = DeployerService_1 = class DeployerService {
      * @returns poll id
      */
     async deployPoll({ approval, sessionKeyAddress, chain, config }) {
-        const publicClient = getPublicClient(chain);
-        const bundlerClient = getBundlerClient(chain);
-        const kernelClient = await this.sessionKeysService.generateClientFromSessionKey(sessionKeyAddress, approval, chain);
-        const signer = await this.sessionKeysService.getKernelClientSigner(kernelClient);
+        const signer = await this.sessionKeysService.getCoordinatorSigner(chain, sessionKeyAddress, approval);
         // check if there is a maci contract deployed on this chain
         const maciAddress = this.storage.getAddress(EContracts.MACI, chain);
         if (!maciAddress) {
@@ -523,43 +387,33 @@ let DeployerService = DeployerService_1 = class DeployerService {
         if (!verifierAddress) {
             throw new Error(ErrorCodes.VERIFIER_NOT_DEPLOYED.toString());
         }
-        // check if there is a vk registry deployed on this chain
-        const vkRegistryAddress = this.storage.getAddress(EContracts.VkRegistry, chain);
-        if (!vkRegistryAddress) {
-            throw new Error(ErrorCodes.VK_REGISTRY_NOT_DEPLOYED.toString());
-        }
-        // check if policy address was given
-        let policyAddress = config.policy.address;
-        if (!policyAddress) {
-            const policyData = this.getPolicyData(config.policy.type, chain, config.policy.args);
-            policyAddress = policyData.address;
-            // if the policy is not already deployed, we need to deploy it
-            if (!policyData.alreadyDeployed) {
-                policyAddress = await this.deployAndStore(config.policy.type, config.policy.args ? Object.values(config.policy.args) : [], policyData.abi, policyData.bytecode, kernelClient, bundlerClient, publicClient, chain);
-            }
+        // check if there is a verifyingKey registry deployed on this chain
+        const verifyingKeysRegistryAddress = this.storage.getAddress(EContracts.VerifyingKeysRegistry, chain);
+        if (!verifyingKeysRegistryAddress) {
+            throw new Error(ErrorCodes.VERIFYING_KEYS_REGISTRY_NOT_DEPLOYED.toString());
         }
+        const policyContract = await this.deployAndSavePolicy(signer, chain, config.policy);
+        const policyAddress = (await policyContract.getAddress());
         // check if initial voice credit proxy address was given
         let initialVoiceCreditProxyAddress = config.initialVoiceCreditsProxy.address;
         if (!initialVoiceCreditProxyAddress) {
-            const voiceCreditProxyData = this.getVoiceCreditProxyData(config.initialVoiceCreditsProxy.type, chain, config.initialVoiceCreditsProxy.args);
-            initialVoiceCreditProxyAddress = voiceCreditProxyData.address;
-            // if the voice credit proxy is not already deployed, we need to deploy it
-            if (!voiceCreditProxyData.alreadyDeployed) {
-                initialVoiceCreditProxyAddress = await this.deployAndStore(config.initialVoiceCreditsProxy.type, Object.values(config.initialVoiceCreditsProxy.args), voiceCreditProxyData.abi, voiceCreditProxyData.bytecode, kernelClient, bundlerClient, publicClient, chain);
-            }
+            const initialVoiceCreditProxyContract = await this.deployAndSaveVoiceCreditProxy(signer, config.initialVoiceCreditsProxy.type, chain, config.initialVoiceCreditsProxy.args);
+            initialVoiceCreditProxyAddress = (await initialVoiceCreditProxyContract.getAddress());
         }
-        const mode = config.useQuadraticVoting ? EMode.QV : EMode.NON_QV;
+        // instantiate the coordinator MACI keypair
+        const coordinatorKeypair = getCoordinatorKeypair();
         const deployPollArgs = {
             maciAddress,
             pollStartTimestamp: config.startDate,
             pollEndTimestamp: config.endDate,
-            intStateTreeDepth: config.intStateTreeDepth,
+            tallyProcessingStateTreeDepth: config.tallyProcessingStateTreeDepth,
             voteOptionTreeDepth: config.voteOptionTreeDepth,
             messageBatchSize: config.messageBatchSize,
-            coordinatorPubKey: PubKey.deserialize(config.coordinatorPubkey),
+            stateTreeDepth: config.pollStateTreeDepth,
+            coordinatorPublicKey: coordinatorKeypair.publicKey,
             verifierContractAddress: verifierAddress,
-            vkRegistryContractAddress: vkRegistryAddress,
-            mode,
+            verifyingKeysRegistryContractAddress: verifyingKeysRegistryAddress,
+            mode: config.mode,
             policyContractAddress: policyAddress,
             initialVoiceCreditProxyContractAddress: initialVoiceCreditProxyAddress,
             relayers: config.relayers ? config.relayers.map((address) => address) : [],
@@ -569,43 +423,37 @@ let DeployerService = DeployerService_1 = class DeployerService {
         };
         const { pollContractAddress, messageProcessorContractAddress, tallyContractAddress, pollId } = await deployPoll(deployPollArgs);
         const poll = PollFactory.connect(pollContractAddress, signer);
-        // read the emptyBallotRoot and extContracts
-        const emptyBallotRoot = await poll.emptyBallotRoot();
-        const extContracts = await poll.extContracts();
         // store to storage
         await Promise.all([
             this.storage.register({
                 id: EContracts.Poll,
                 key: `poll-${pollId}`,
                 contract: poll,
-                args: [
-                    {
-                        ...deployPollArgs,
-                        extContracts,
-                        emptyBallotRoot: emptyBallotRoot.toString(),
-                    },
-                ],
+                // clones do not have args for verification
+                args: [],
                 network: chain,
             }),
             this.storage.register({
                 id: EContracts.MessageProcessor,
                 key: `poll-${pollId}`,
-                contract: new BaseContract(messageProcessorContractAddress, MessageProcessorFactory.abi),
-                args: [verifierAddress, vkRegistryAddress, pollContractAddress, mode],
+                contract: MessageProcessorFactory.connect(messageProcessorContractAddress, signer),
+                // clones do not have args for verification
+                args: [],
                 network: chain,
             }),
             this.storage.register({
                 id: EContracts.Tally,
                 key: `poll-${pollId}`,
-                contract: new BaseContract(tallyContractAddress, TallyFactory.abi),
-                args: [verifierAddress, vkRegistryAddress, pollContractAddress, messageProcessorContractAddress, mode],
+                contract: TallyFactory.connect(tallyContractAddress, signer),
+                // clones do not have args for verification
+                args: [],
                 network: chain,
             }),
         ]);
         return { pollId: pollId.toString() };
     }
 };
-DeployerService = DeployerService_1 = __decorate([
+DeployerService = __decorate([
     Injectable(),
     __metadata("design:paramtypes", [SessionKeysService,
         FileService])