@maci-protocol/coordinator 0.0.0-ci.8a288fb → 0.0.0-ci.8bb6ea8

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

@@ -1,321 +1,186 @@
-import { IInitialVoiceCreditProxy__factory as VoiceCreditProxyFactory, ContractStorage, EContracts, EInitialVoiceCreditProxies, EPolicies, FreeForAllPolicy__factory as FreeForAllPolicyFactory, EASPolicy__factory as EASPolicyFactory, ZupassPolicy__factory as ZupassPolicyFactory, SemaphorePolicy__factory as SemaphorePolicyFactory, HatsPolicy__factory as HatsPolicyFactory, GitcoinPassportPolicy__factory as GitcoinPassportPolicyFactory, MACI__factory as MACIFactory, Verifier__factory as VerifierFactory, } from "@maci-protocol/sdk";
+import { ContractStorage, deployFreeForAllSignUpPolicy, deployPoll, deployVerifier, deployVerifyingKeysRegistryContract, deployMaci, deployConstantInitialVoiceCreditProxyFactory, deployConstantInitialVoiceCreditProxy, getDeployedPolicyProxyFactories, ECheckerFactories, EContracts, EInitialVoiceCreditProxies, EInitialVoiceCreditProxiesFactories, EPolicies, EPolicyFactories, ESupportedChains, ECheckers, } from "@maci-protocol/sdk";
 import dotenv from "dotenv";
-import { BaseContract, zeroPadBytes } from "ethers";
 import { zeroAddress } from "viem";
-import path from "path";
-import { ErrorCodes, ESupportedNetworks } from "../../common";
-import { FileService } from "../../file/file.service";
-import { generateApproval } from "../../sessionKeys/__tests__/utils";
-import { SessionKeysService } from "../../sessionKeys/sessionKeys.service";
+import { ErrorCodes } from "../../common";
 import { DeployerService } from "../deployer.service";
-import { estimateExtraGasLimit } from "../utils";
 import { testMaciDeploymentConfig, testPollDeploymentConfig } from "./utils";
 dotenv.config();
+jest.mock("@maci-protocol/sdk", () => ({
+    ...jest.requireActual("@maci-protocol/sdk"),
+    ContractStorage: {
+        getInstance: jest.fn(),
+    },
+    deployFreeForAllSignUpPolicy: jest.fn(),
+    deployPoll: jest.fn(),
+    deployVerifyingKeysRegistryContract: jest.fn(),
+    deployVerifier: jest.fn(),
+    getDeployedPolicyProxyFactories: jest.fn(),
+    setVerifyingKeys: jest.fn(),
+    deployMaci: jest.fn(),
+    deployConstantInitialVoiceCreditProxyFactory: jest.fn(),
+    deployConstantInitialVoiceCreditProxy: jest.fn(),
+}));
 describe("DeployerService", () => {
+    const chain = ESupportedChains.OptimismSepolia;
+    const signer = {
+        getAddress: jest.fn().mockResolvedValue(zeroAddress),
+    };
+    const approval = "approval";
+    const sessionKeyAddress = zeroAddress;
+    const mockStorage = {
+        register: jest.fn(),
+        getAddress: jest.fn(),
+    };
+    const mockContract = {
+        deploymentTransaction: jest.fn(),
+        getAddress: jest.fn().mockResolvedValue(zeroAddress.replace("0x0", "0x1")),
+    };
+    const fileService = {
+        getZkeyFilePaths: jest.fn(),
+    };
+    const sessionKeyService = {
+        getCoordinatorSigner: jest.fn().mockResolvedValue(signer),
+    };
+    beforeEach(() => {
+        mockStorage.getAddress = jest.fn().mockReturnValue(zeroAddress);
+        sessionKeyService.getCoordinatorSigner = jest.fn().mockResolvedValue(signer);
+        fileService.getZkeyFilePaths = jest.fn().mockReturnValue({ zkey: "" });
+        ContractStorage.getInstance.mockReturnValue(mockStorage);
+        deployFreeForAllSignUpPolicy.mockResolvedValue([
+            mockContract,
+            mockContract,
+            mockContract,
+            mockContract,
+        ]);
+        deployVerifier.mockResolvedValue(mockContract);
+        deployVerifyingKeysRegistryContract.mockResolvedValue(mockContract);
+        deployConstantInitialVoiceCreditProxyFactory.mockResolvedValue(mockContract);
+        deployConstantInitialVoiceCreditProxy.mockResolvedValue(mockContract);
+        deployPoll.mockResolvedValue({
+            pollContractAddress: zeroAddress,
+            messageProcessorContractAddress: zeroAddress,
+            tallyContractAddress: zeroAddress,
+            pollId: 0n,
+        });
+        deployMaci.mockResolvedValue({
+            maciContractAddress: zeroAddress.replace("0x0", "0x1"),
+            pollFactoryContractAddress: zeroAddress,
+            messageProcessorFactoryContractAddress: zeroAddress,
+            tallyFactoryContractAddress: zeroAddress,
+            poseidonAddresses: {
+                poseidonT3: zeroAddress,
+                poseidonT4: zeroAddress,
+                poseidonT5: zeroAddress,
+                poseidonT6: zeroAddress,
+            },
+            verifierContractAddress: zeroAddress,
+            verifyingKeysRegistryContractAddress: zeroAddress,
+        });
+        getDeployedPolicyProxyFactories.mockResolvedValue({ checker: undefined, policy: undefined });
+    });
     afterEach(() => {
         jest.clearAllMocks();
     });
-    const chain = ESupportedNetworks.OPTIMISM_SEPOLIA;
-    const fileService = new FileService();
-    const storageInstance = ContractStorage.getInstance(path.join(process.cwd(), "deployed-contracts.json"));
-    const sessionKeyService = new SessionKeysService(fileService);
-    const deployerService = new DeployerService(sessionKeyService, fileService);
-    let approval;
-    let sessionKeyAddress;
-    beforeAll(async () => {
-        approval = await generateApproval(sessionKeyAddress);
-        sessionKeyAddress = (await sessionKeyService.generateSessionKey()).sessionKeyAddress;
-    });
-    describe("getVoiceCreditProxyData", () => {
-        test("should return the voice credit proxy data", () => {
-            const voiceCreditProxyData = deployerService.getVoiceCreditProxyData(EInitialVoiceCreditProxies.Constant, chain, {
-                amount: "50",
-            });
-            expect(voiceCreditProxyData).toBeDefined();
-            expect(voiceCreditProxyData.alreadyDeployed).toBe(false);
-            expect(voiceCreditProxyData.abi).toBeDefined();
-            expect(voiceCreditProxyData.bytecode).toBeDefined();
+    describe("deployAndSavePolicy", () => {
+        test("should throw when the policy is not existent", async () => {
+            const deployerService = new DeployerService(sessionKeyService, fileService);
+            await expect(deployerService.deployAndSavePolicy(signer, chain, {
+                policyType: "NonExistent",
+                checkerType: "NonExistent",
+            })).rejects.toThrow(ErrorCodes.UNSUPPORTED_POLICY.toString());
         });
-        test("should return the voice credit proxy data and that the voice credit proxy is already deployed", async () => {
-            await storageInstance.register({
-                id: EInitialVoiceCreditProxies.Constant,
-                contract: new BaseContract("0x", VoiceCreditProxyFactory.abi),
-                network: chain,
-                args: ["50"],
+        test("should deploy policy if none is stored", async () => {
+            const deployerService = new DeployerService(sessionKeyService, fileService);
+            const policy = await deployerService.deployAndSavePolicy(signer, chain, {
+                policyType: EPolicies.FreeForAll,
+                checkerType: ECheckers.FreeForAll,
             });
-            const voiceCreditProxyData = deployerService.getVoiceCreditProxyData(EInitialVoiceCreditProxies.Constant, chain, {
-                amount: "50",
-            });
-            expect(voiceCreditProxyData).toBeDefined();
-            expect(voiceCreditProxyData.alreadyDeployed).toBe(true);
-            expect(voiceCreditProxyData.abi).toBeDefined();
-            expect(voiceCreditProxyData.bytecode).toBeDefined();
-            storageInstance.cleanup(chain);
-        });
-        it("should throw when the voice credits proxy is not existent", () => {
-            expect(() => deployerService.getVoiceCreditProxyData("NotExistent", chain, {
-                amount: "50",
-            })).toThrow(ErrorCodes.UNSUPPORTED_VOICE_CREDIT_PROXY.toString());
-        });
-    });
-    describe("getPolicyData", () => {
-        // we cleanup after each test so we don't have leftover saved contracts
-        afterEach(() => {
-            storageInstance.cleanup(chain);
-        });
-        it("should throw when the policy is not existent", () => {
-            expect(() => deployerService.getPolicyData("NotExistent", chain)).toThrow(ErrorCodes.UNSUPPORTED_POLICY.toString());
+            expect(policy).toBeDefined();
+            expect(await policy.getAddress()).not.toBe(zeroAddress);
         });
-        describe("FreeForAllPolicy", () => {
-            it("should return the policy data and that the policy is not deployed", () => {
-                const policyData = deployerService.getPolicyData(EPolicies.FreeForAll, chain);
-                expect(policyData).toBeDefined();
-                expect(policyData.alreadyDeployed).toBe(false);
-                expect(policyData.abi).toBeDefined();
-                expect(policyData.bytecode).toBeDefined();
+        test("should save factories (policy and checker) after deploying policy", async () => {
+            const deployerService = new DeployerService(sessionKeyService, fileService);
+            await deployerService.deployAndSavePolicy(signer, chain, {
+                policyType: EPolicies.FreeForAll,
+                checkerType: ECheckers.FreeForAll,
             });
-            it("should return the policy data and that the policy is already deployed", async () => {
-                await storageInstance.register({
-                    id: EPolicies.FreeForAll,
-                    contract: new BaseContract("0x", FreeForAllPolicyFactory.abi),
-                    network: chain,
-                    args: [],
-                });
-                const policyData = deployerService.getPolicyData(EPolicies.FreeForAll, chain);
-                expect(policyData).toBeDefined();
-                expect(policyData.alreadyDeployed).toBe(true);
-                expect(policyData.abi).toBeDefined();
-                expect(policyData.bytecode).toBeDefined();
+            expect(mockStorage.register).toHaveBeenCalledTimes(4);
+            expect(mockStorage.register).toHaveBeenNthCalledWith(1, {
+                id: EPolicies.FreeForAll,
+                name: EPolicies.FreeForAll,
+                contract: mockContract,
+                args: [await mockContract.getAddress()],
+                network: chain,
             });
-        });
-        describe("EASPolicy", () => {
-            it("should return the policy data and that the policy is not deployed", () => {
-                const policyData = deployerService.getPolicyData(EPolicies.EAS, chain);
-                expect(policyData).toBeDefined();
-                expect(policyData.alreadyDeployed).toBe(false);
-                expect(policyData.abi).toBeDefined();
-                expect(policyData.bytecode).toBeDefined();
+            expect(mockStorage.register).toHaveBeenNthCalledWith(2, {
+                id: ECheckers.FreeForAll,
+                name: ECheckers.FreeForAll,
+                contract: mockContract,
+                args: [],
+                network: chain,
             });
-            it("should return the policy data and that the policy is already deployed", async () => {
-                await storageInstance.register({
-                    id: EPolicies.EAS,
-                    contract: new BaseContract("0x", EASPolicyFactory.abi),
-                    network: chain,
-                    args: [zeroAddress, zeroPadBytes("0x", 32), zeroAddress],
-                });
-                const policyData = deployerService.getPolicyData(EPolicies.EAS, chain, {
-                    easAddress: zeroAddress,
-                    schema: zeroPadBytes("0x", 32),
-                    attester: zeroAddress,
-                });
-                expect(policyData).toBeDefined();
-                expect(policyData.alreadyDeployed).toBe(true);
-                expect(policyData.abi).toBeDefined();
-                expect(policyData.bytecode).toBeDefined();
+            expect(mockStorage.register).toHaveBeenNthCalledWith(3, {
+                id: EPolicyFactories.FreeForAll,
+                name: EPolicyFactories.FreeForAll,
+                contract: mockContract,
+                network: chain,
             });
-            it("should return that the policy is not deployed when the args are different", async () => {
-                await storageInstance.register({
-                    id: EPolicies.EAS,
-                    contract: new BaseContract("0x", EASPolicyFactory.abi),
-                    network: chain,
-                    args: [zeroAddress, zeroPadBytes("0x", 32), zeroAddress.replace("0x0", "0x1")],
-                });
-                const policyData = deployerService.getPolicyData(EPolicies.EAS, chain, {
-                    easAddress: zeroAddress,
-                    schema: zeroPadBytes("0x", 32),
-                    attester: zeroAddress,
-                });
-                expect(policyData).toBeDefined();
-                expect(policyData.alreadyDeployed).toBe(false);
-                expect(policyData.abi).toBeDefined();
-                expect(policyData.bytecode).toBeDefined();
+            expect(mockStorage.register).toHaveBeenNthCalledWith(4, {
+                id: ECheckerFactories.FreeForAll,
+                name: ECheckerFactories.FreeForAll,
+                contract: mockContract,
+                network: chain,
             });
         });
-        describe("ZupassPolicy", () => {
-            it("should return the policy data and that the policy is not deployed", () => {
-                const policyData = deployerService.getPolicyData(EPolicies.Zupass, chain, {
-                    signer1: zeroAddress,
-                    signer2: zeroAddress,
-                    eventId: "0x",
-                    zupassVerifier: zeroAddress,
-                });
-                expect(policyData).toBeDefined();
-                expect(policyData.alreadyDeployed).toBe(false);
-                expect(policyData.abi).toBeDefined();
-                expect(policyData.bytecode).toBeDefined();
+        test("should reuse policy factories if already stored", async () => {
+            getDeployedPolicyProxyFactories.mockResolvedValue({
+                checker: mockContract,
+                policy: mockContract,
             });
-            it("should return the policy data and that the policy is already deployed", async () => {
-                await storageInstance.register({
-                    id: EPolicies.Zupass,
-                    contract: new BaseContract("0x", ZupassPolicyFactory.abi),
-                    network: chain,
-                    args: [zeroAddress, zeroAddress, "0x", zeroAddress],
-                });
-                const policyData = deployerService.getPolicyData(EPolicies.Zupass, chain, {
-                    signer1: zeroAddress,
-                    signer2: zeroAddress,
-                    eventId: "0x",
-                    zupassVerifier: zeroAddress,
-                });
-                expect(policyData).toBeDefined();
-                expect(policyData.alreadyDeployed).toBe(true);
-                expect(policyData.abi).toBeDefined();
-                expect(policyData.bytecode).toBeDefined();
+            const deployerService = new DeployerService(sessionKeyService, fileService);
+            await deployerService.deployAndSavePolicy(signer, chain, {
+                policyType: EPolicies.FreeForAll,
+                checkerType: ECheckers.FreeForAll,
             });
-            it("should return that the policy is not deployed when the args are different", async () => {
-                await storageInstance.register({
-                    id: EPolicies.Zupass,
-                    contract: new BaseContract("0x", ZupassPolicyFactory.abi),
-                    network: chain,
-                    args: [zeroAddress, zeroAddress, "0x", zeroAddress.replace("0x0", "0x1")],
-                });
-                const policyData = deployerService.getPolicyData(EPolicies.Zupass, chain, {
-                    signer1: zeroAddress,
-                    signer2: zeroAddress,
-                    eventId: "0x",
-                    zupassVerifier: zeroAddress,
-                });
-                expect(policyData).toBeDefined();
-                expect(policyData.alreadyDeployed).toBe(false);
-                expect(policyData.abi).toBeDefined();
-                expect(policyData.bytecode).toBeDefined();
+            await deployerService.deployAndSavePolicy(signer, chain, {
+                policyType: EPolicies.FreeForAll,
+                checkerType: ECheckers.FreeForAll,
             });
+            expect(mockStorage.register).toHaveBeenCalledTimes(4);
         });
-        describe("SemaphorePolicy", () => {
-            it("should return the policy data and that the policy is not deployed", () => {
-                const policyData = deployerService.getPolicyData(EPolicies.Semaphore, chain, {
-                    semaphoreContract: zeroAddress,
-                    groupId: "0",
-                });
-                expect(policyData).toBeDefined();
-                expect(policyData.alreadyDeployed).toBe(false);
-                expect(policyData.abi).toBeDefined();
-                expect(policyData.bytecode).toBeDefined();
-            });
-            it("should return the policy data and that the policy is already deployed", async () => {
-                await storageInstance.register({
-                    id: EPolicies.Semaphore,
-                    contract: new BaseContract("0x", SemaphorePolicyFactory.abi),
-                    network: chain,
-                    args: [zeroAddress, "0"],
-                });
-                const policyData = deployerService.getPolicyData(EPolicies.Semaphore, chain, {
-                    semaphoreContract: zeroAddress,
-                    groupId: "0",
-                });
-                expect(policyData).toBeDefined();
-                expect(policyData.alreadyDeployed).toBe(true);
-                expect(policyData.abi).toBeDefined();
-                expect(policyData.bytecode).toBeDefined();
-            });
-            it("should return that the policy is not deployed when the args are different", async () => {
-                await storageInstance.register({
-                    id: EPolicies.Semaphore,
-                    contract: new BaseContract("0x", SemaphorePolicyFactory.abi),
-                    network: chain,
-                    args: [zeroAddress, "0"],
-                });
-                const policyData = deployerService.getPolicyData(EPolicies.Semaphore, chain, {
-                    semaphoreContract: zeroAddress,
-                    groupId: "1",
-                });
-                expect(policyData).toBeDefined();
-                expect(policyData.alreadyDeployed).toBe(false);
-                expect(policyData.abi).toBeDefined();
-                expect(policyData.bytecode).toBeDefined();
-            });
+    });
+    describe("deployAndSaveVoiceCreditProxyFactory", () => {
+        test("should throw when the voice credit proxy factory is not existent", async () => {
+            const deployerService = new DeployerService(sessionKeyService, fileService);
+            await expect(deployerService.deployAndSaveVoiceCreditProxyFactory(signer, "NonExistent", chain)).rejects.toThrow(ErrorCodes.UNSUPPORTED_VOICE_CREDIT_PROXY_FACTORY.toString());
         });
-        describe("HatsPolicy", () => {
-            it("should return the policy data and that the policy is not deployed", () => {
-                const policyData = deployerService.getPolicyData(EPolicies.Hats, chain, {
-                    hatsProtocolAddress: zeroAddress,
-                    critrionHats: [zeroAddress],
-                });
-                expect(policyData).toBeDefined();
-                expect(policyData.alreadyDeployed).toBe(false);
-                expect(policyData.abi).toBeDefined();
-                expect(policyData.bytecode).toBeDefined();
-            });
-            it("should return the policy data and that the policy is already deployed", async () => {
-                await storageInstance.register({
-                    id: EPolicies.Hats,
-                    contract: new BaseContract("0x", HatsPolicyFactory.abi),
-                    network: chain,
-                    args: [zeroAddress, [zeroAddress]],
-                });
-                const policyData = deployerService.getPolicyData(EPolicies.Hats, chain, {
-                    hatsProtocolAddress: zeroAddress,
-                    critrionHats: [zeroAddress],
-                });
-                expect(policyData).toBeDefined();
-                expect(policyData.alreadyDeployed).toBe(true);
-                expect(policyData.abi).toBeDefined();
-                expect(policyData.bytecode).toBeDefined();
-            });
-            it("should return that the policy is not deployed when the args are different", async () => {
-                await storageInstance.register({
-                    id: EPolicies.Hats,
-                    contract: new BaseContract("0x", HatsPolicyFactory.abi),
-                    network: chain,
-                    args: [zeroAddress, ["0x"]],
-                });
-                const policyData = deployerService.getPolicyData(EPolicies.Hats, chain, {
-                    hatsProtocolAddress: zeroAddress,
-                    critrionHats: ["0x1"],
-                });
-                expect(policyData).toBeDefined();
-                expect(policyData.alreadyDeployed).toBe(false);
-                expect(policyData.abi).toBeDefined();
-                expect(policyData.bytecode).toBeDefined();
-            });
+        test("should deploy voice credit proxy factory if none is stored", async () => {
+            const deployerService = new DeployerService(sessionKeyService, fileService);
+            const constantInitialVoiceCreditProxyFactory = await deployerService.deployAndSaveVoiceCreditProxyFactory(signer, EInitialVoiceCreditProxiesFactories.Constant, chain);
+            expect(constantInitialVoiceCreditProxyFactory).toBeDefined();
+            expect(await constantInitialVoiceCreditProxyFactory.getAddress()).not.toBe(zeroAddress);
         });
-        describe("GitcoinPassportPolicy", () => {
-            it("should return the policy data and that the policy is not deployed", () => {
-                const policyData = deployerService.getPolicyData(EPolicies.GitcoinPassport, chain, {
-                    decoderAddress: zeroAddress,
-                    passingScore: "0",
-                });
-                expect(policyData).toBeDefined();
-                expect(policyData.alreadyDeployed).toBe(false);
-                expect(policyData.abi).toBeDefined();
-                expect(policyData.bytecode).toBeDefined();
-            });
-            it("should return the policy data and that the policy is already deployed", async () => {
-                await storageInstance.register({
-                    id: EPolicies.GitcoinPassport,
-                    contract: new BaseContract("0x", GitcoinPassportPolicyFactory.abi),
-                    network: chain,
-                    args: [zeroAddress, "0"],
-                });
-                const policyData = deployerService.getPolicyData(EPolicies.GitcoinPassport, chain, {
-                    decoderAddress: zeroAddress,
-                    passingScore: "0",
-                });
-                expect(policyData).toBeDefined();
-                expect(policyData.alreadyDeployed).toBe(true);
-                expect(policyData.abi).toBeDefined();
-                expect(policyData.bytecode).toBeDefined();
-            });
-            it("should return that the policy is not deployed when the args are different", async () => {
-                await storageInstance.register({
-                    id: EPolicies.GitcoinPassport,
-                    contract: new BaseContract("0x", GitcoinPassportPolicyFactory.abi),
-                    network: chain,
-                    args: [zeroAddress, "0"],
-                });
-                const policyData = deployerService.getPolicyData(EPolicies.GitcoinPassport, chain, {
-                    decoderAddress: zeroAddress,
-                    passingScore: "1",
-                });
-                expect(policyData).toBeDefined();
-                expect(policyData.alreadyDeployed).toBe(false);
-                expect(policyData.abi).toBeDefined();
-                expect(policyData.bytecode).toBeDefined();
-            });
+    });
+    describe("deployAndSaveVoiceCreditProxy", () => {
+        test("should throw when the voice credit proxy is not existent", async () => {
+            const deployerService = new DeployerService(sessionKeyService, fileService);
+            const constantInitialVoiceCreditProxyFactory = await deployerService.deployAndSaveVoiceCreditProxyFactory(signer, EInitialVoiceCreditProxiesFactories.Constant, chain);
+            await expect(deployerService.deployAndSaveVoiceCreditProxy(signer, "NonExistent", chain, constantInitialVoiceCreditProxyFactory)).rejects.toThrow(ErrorCodes.UNSUPPORTED_VOICE_CREDIT_PROXY.toString());
+        });
+        test("should deploy voice credit proxy if none is stored", async () => {
+            const deployerService = new DeployerService(sessionKeyService, fileService);
+            const constantInitialVoiceCreditProxyFactory = await deployerService.deployAndSaveVoiceCreditProxyFactory(signer, EInitialVoiceCreditProxiesFactories.Constant, chain);
+            const voiceCreditProxy = await deployerService.deployAndSaveVoiceCreditProxy(signer, EInitialVoiceCreditProxies.Constant, chain, constantInitialVoiceCreditProxyFactory, { amount: 100 });
+            expect(voiceCreditProxy).toBeDefined();
+            expect(await voiceCreditProxy.getAddress()).not.toBe(zeroAddress);
         });
     });
     describe("deployMaci", () => {
         test("should throw when passing a non existent session key address", async () => {
+            sessionKeyService.getCoordinatorSigner = jest
+                .fn()
+                .mockRejectedValue(new Error(ErrorCodes.SESSION_KEY_NOT_FOUND.toString()));
+            const deployerService = new DeployerService(sessionKeyService, fileService);
             await expect(deployerService.deployMaci({
                 config: testMaciDeploymentConfig,
                 chain,
@@ -324,44 +189,37 @@ describe("DeployerService", () => {
             })).rejects.toThrow(ErrorCodes.SESSION_KEY_NOT_FOUND.toString());
         });
         test("should throw when the approval is not valid", async () => {
+            sessionKeyService.getCoordinatorSigner = jest
+                .fn()
+                .mockRejectedValue(new Error(ErrorCodes.INVALID_APPROVAL.toString()));
+            const deployerService = new DeployerService(sessionKeyService, fileService);
             await expect(deployerService.deployMaci({
                 config: testMaciDeploymentConfig,
                 chain,
-                approval: "0x",
+                approval: "0x123",
                 sessionKeyAddress,
             })).rejects.toThrow(ErrorCodes.INVALID_APPROVAL.toString());
         });
         test("should deploy all new contracts", async () => {
-            const mockDeployMaci = jest.fn().mockResolvedValue({ address: zeroAddress });
-            jest.spyOn(DeployerService.prototype, "deployMaci").mockImplementation(mockDeployMaci);
+            const deployerService = new DeployerService(sessionKeyService, fileService);
             const { address: maciAddress } = await deployerService.deployMaci({
                 config: testMaciDeploymentConfig,
                 chain,
                 approval,
                 sessionKeyAddress,
             });
-            expect(maciAddress).toBe(zeroAddress);
+            expect(maciAddress).toBe(zeroAddress.replace("0x0", "0x1"));
         });
     });
     describe("deployPoll", () => {
-        afterEach(() => {
-            storageInstance.cleanup(chain);
-        });
         test("should throw when there is no maci contract deployed", async () => {
-            await expect(deployerService.deployPoll({
-                approval,
-                sessionKeyAddress,
-                chain,
-                config: testPollDeploymentConfig,
-            })).rejects.toThrow(ErrorCodes.MACI_NOT_DEPLOYED.toString());
-        });
-        test("should throw when there is no maci contract deployed to this specific chain", async () => {
-            await storageInstance.register({
-                id: EContracts.MACI,
-                contract: new BaseContract("0x", MACIFactory.abi),
-                network: ESupportedNetworks.ARBITRUM_ONE,
-                args: [],
+            ContractStorage.getInstance.mockReturnValue({
+                ...mockStorage,
+                getAddress: jest
+                    .fn()
+                    .mockImplementation((key) => (key !== EContracts.MACI ? zeroAddress : undefined)),
             });
+            const deployerService = new DeployerService(sessionKeyService, fileService);
             await expect(deployerService.deployPoll({
                 approval,
                 sessionKeyAddress,
@@ -369,13 +227,14 @@ describe("DeployerService", () => {
                 config: testPollDeploymentConfig,
             })).rejects.toThrow(ErrorCodes.MACI_NOT_DEPLOYED.toString());
         });
-        it("should throw when there is no verifier deployed", async () => {
-            await storageInstance.register({
-                id: EContracts.MACI,
-                contract: new BaseContract("0x", MACIFactory.abi),
-                network: chain,
-                args: [],
+        test("should throw when there is no verifier deployed", async () => {
+            ContractStorage.getInstance.mockReturnValue({
+                ...mockStorage,
+                getAddress: jest
+                    .fn()
+                    .mockImplementation((key) => (key !== EContracts.Verifier ? zeroAddress : undefined)),
             });
+            const deployerService = new DeployerService(sessionKeyService, fileService);
             await expect(deployerService.deployPoll({
                 approval,
                 sessionKeyAddress,
@@ -383,29 +242,23 @@ describe("DeployerService", () => {
                 config: testPollDeploymentConfig,
             })).rejects.toThrow(ErrorCodes.VERIFIER_NOT_DEPLOYED.toString());
         });
-        it("should throw when there is no vk registry deployed", async () => {
-            await storageInstance.register({
-                id: EContracts.MACI,
-                contract: new BaseContract("0x", MACIFactory.abi),
-                network: chain,
-                args: [],
-            });
-            await storageInstance.register({
-                id: EContracts.Verifier,
-                contract: new BaseContract("0x", VerifierFactory.abi),
-                network: chain,
-                args: [],
+        test("should throw when there is no verifying keys registry deployed", async () => {
+            ContractStorage.getInstance.mockReturnValue({
+                ...mockStorage,
+                getAddress: jest
+                    .fn()
+                    .mockImplementation((key) => key !== EContracts.VerifyingKeysRegistry ? zeroAddress : undefined),
             });
+            const deployerService = new DeployerService(sessionKeyService, fileService);
             await expect(deployerService.deployPoll({
                 approval,
                 sessionKeyAddress,
                 chain,
                 config: testPollDeploymentConfig,
-            })).rejects.toThrow(ErrorCodes.VK_REGISTRY_NOT_DEPLOYED.toString());
+            })).rejects.toThrow(ErrorCodes.VERIFYING_KEYS_REGISTRY_NOT_DEPLOYED.toString());
         });
         test("should deploy a poll", async () => {
-            const mockDeployPoll = jest.fn().mockResolvedValue({ pollId: "0" });
-            jest.spyOn(DeployerService.prototype, "deployPoll").mockImplementation(mockDeployPoll);
+            const deployerService = new DeployerService(sessionKeyService, fileService);
             const { pollId } = await deployerService.deployPoll({
                 config: testPollDeploymentConfig,
                 chain,
@@ -415,11 +268,5 @@ describe("DeployerService", () => {
             expect(pollId).toBe("0");
         });
     });
-    describe("estimateExtraGasLimit", () => {
-        it("should return the extra gas limit", () => {
-            const extraGasLimit = estimateExtraGasLimit(100n);
-            expect(extraGasLimit.toString()).toBe("5");
-        });
-    });
 });
 //# sourceMappingURL=deployer.service.test.js.map