@maci-protocol/coordinator 0.0.0-ci.5209133

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

@@ -0,0 +1,628 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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, ERC20Policy__factory as ERC20PolicyFactory, 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 { BaseContract } from "ethers";
+import { encodeFunctionData } from "viem";
+import path from "path";
+import { ErrorCodes } from "../common";
+import { getBundlerClient, getDeployedContractAddress, getPublicClient } from "../common/accountAbstraction";
+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 {
+    sessionKeysService;
+    fileService;
+    /**
+     * Logger
+     */
+    logger = new Logger(DeployerService_1.name);
+    /**
+     * Contract storage instance
+     */
+    storage;
+    /**
+     * Create a new instance of DeployerService
+     *
+     * @param fileService - file service
+     */
+    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"));
+    }
+    /**
+     * Get the policy abi and bytecode based on the policy type
+     * and also check if there is already an instance deployed
+     *
+     * @param policyType - the policy type
+     * @param network - the network
+     * @param args - the policy args
+     * @returns - the policy abi and bytecode
+     */
+    getPolicyData(policyType, network, args) {
+        const address = this.storage.getAddress(policyType, network);
+        let storedArgs;
+        let isAlreadyDeployed;
+        // based on the policy type, we need to deploy the correct policy
+        switch (policyType) {
+            case EPolicies.FreeForAll: {
+                return {
+                    address,
+                    abi: FreeForAllPolicyFactory.abi,
+                    bytecode: FreeForAllPolicyFactory.bytecode,
+                    alreadyDeployed: !!address,
+                };
+            }
+            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,
+                };
+            }
+            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.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,
+                };
+            }
+            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,
+                };
+            }
+            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.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,
+                };
+            }
+            case EPolicies.ERC20: {
+                storedArgs = this.storage.getContractArgs(policyType, network);
+                isAlreadyDeployed =
+                    !!storedArgs &&
+                        storedArgs.length === 2 &&
+                        storedArgs[0] === args.token &&
+                        storedArgs[1] === args.threshold;
+                return {
+                    address: isAlreadyDeployed ? address : undefined,
+                    abi: ERC20PolicyFactory.abi,
+                    bytecode: ERC20PolicyFactory.bytecode,
+                    alreadyDeployed: isAlreadyDeployed,
+                };
+            }
+            default:
+                throw new Error(ErrorCodes.UNSUPPORTED_POLICY.toString());
+        }
+    }
+    /**
+     * 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
+     *
+     * @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
+     */
+    getVoiceCreditProxyData(voiceCreditProxyType, network, args) {
+        let storedArgs;
+        let isAlreadyDeployed;
+        const address = this.storage.getAddress(voiceCreditProxyType, network);
+        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,
+                };
+            }
+            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,
+        });
+        const receipt = await bundlerClient.waitForUserOperationReceipt({ hash: userOperationHash });
+        if (!receipt.success) {
+            throw new Error(errorMessage);
+        }
+        return receipt;
+    }
+    /**
+     * 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 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({
+            pollJoiningZkeyPath,
+            pollJoinedZkeyPath,
+            processMessagesZkeyPath,
+            tallyVotesZkeyPath,
+        });
+        const { stateTreeDepth, intStateTreeDepth, voteOptionTreeDepth, messageBatchSize } = vkRegistryArgs;
+        return {
+            pollJoiningVk: pollJoiningVk,
+            pollJoinedVk: pollJoinedVk,
+            processMessagesVk: processVk,
+            tallyVotesVk: tallyVk,
+            stateTreeDepth: Number(stateTreeDepth),
+            intStateTreeDepth: Number(intStateTreeDepth),
+            voteOptionTreeDepth: Number(voteOptionTreeDepth),
+            messageBatchSize: Number(messageBatchSize),
+            signer,
+            mode,
+            vkRegistryAddress: await vkRegistryContract.getAddress(),
+        };
+    }
+    /**
+     * Deploy MACI contracts
+     *
+     * @param args - deploy maci arguments
+     * @param options - ws hooks
+     * @returns - deployed maci contract
+     * @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 };
+    }
+    /**
+     * Deploy a poll
+     *
+     * @param args - deploy poll dto
+     * @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);
+        // check if there is a maci contract deployed on this chain
+        const maciAddress = this.storage.getAddress(EContracts.MACI, chain);
+        if (!maciAddress) {
+            throw new Error(ErrorCodes.MACI_NOT_DEPLOYED.toString());
+        }
+        // check if there is a verifier deployed on this chain
+        const verifierAddress = this.storage.getAddress(EContracts.Verifier, chain);
+        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 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 mode = config.useQuadraticVoting ? EMode.QV : EMode.NON_QV;
+        const deployPollArgs = {
+            maciAddress,
+            pollStartTimestamp: config.startDate,
+            pollEndTimestamp: config.endDate,
+            intStateTreeDepth: config.intStateTreeDepth,
+            voteOptionTreeDepth: config.voteOptionTreeDepth,
+            messageBatchSize: config.messageBatchSize,
+            coordinatorPubKey: PubKey.deserialize(config.coordinatorPubkey),
+            verifierContractAddress: verifierAddress,
+            vkRegistryContractAddress: vkRegistryAddress,
+            mode,
+            policyContractAddress: policyAddress,
+            initialVoiceCreditProxyContractAddress: initialVoiceCreditProxyAddress,
+            relayers: config.relayers ? config.relayers.map((address) => address) : [],
+            voteOptions: Number(config.voteOptions),
+            initialVoiceCredits: Number(config.initialVoiceCreditsProxy.args.amount),
+            signer,
+        };
+        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(),
+                    },
+                ],
+                network: chain,
+            }),
+            this.storage.register({
+                id: EContracts.MessageProcessor,
+                key: `poll-${pollId}`,
+                contract: new BaseContract(messageProcessorContractAddress, MessageProcessorFactory.abi),
+                args: [verifierAddress, vkRegistryAddress, pollContractAddress, mode],
+                network: chain,
+            }),
+            this.storage.register({
+                id: EContracts.Tally,
+                key: `poll-${pollId}`,
+                contract: new BaseContract(tallyContractAddress, TallyFactory.abi),
+                args: [verifierAddress, vkRegistryAddress, pollContractAddress, messageProcessorContractAddress, mode],
+                network: chain,
+            }),
+        ]);
+        return { pollId: pollId.toString() };
+    }
+};
+DeployerService = DeployerService_1 = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [SessionKeysService,
+        FileService])
+], DeployerService);
+export { DeployerService };
+//# sourceMappingURL=deployer.service.js.map