chore(contracts): add function to deploy contracts deterministically (#816)

* chore(contracts): add function to deploy contracts deterministically

re #766

* chore(contracts): return correct contract instance

re #766

Author: cedoor

packages/contracts/scripts/utils.ts

@@ -1,5 +1,6 @@
 import { SupportedNetwork, isSupportedNetwork } from "@semaphore-protocol/utils"
 import { readFileSync, writeFileSync } from "fs"
+import { FactoryOptions } from "hardhat/types"
 
 export type NetworkDeployedContracts = {
     name: "Semaphore" | "SemaphoreVerifier" | "PoseidonT3"
@@ -14,6 +15,51 @@ export type DeployedContracts = {
 
 const deployedContractsPath = "../utils/src/networks/deployed-contracts.json"
 
+/**
+ * Deploys contracts using a deterministic deployment proxy if
+ * the network is supported, otherwise it deploys contract with
+ * the factory as usual.
+ * Part of this code may be moved to a separate Hardhat plugin in
+ * the future.
+ */
+export async function deploy(
+    ethers: any,
+    contractName: string,
+    network?: string,
+    args: any[] = [],
+    opts?: FactoryOptions
+): Promise<string> {
+    const ContractFactory = await ethers.getContractFactory(contractName, opts)
+
+    // If the network is not a local one and it's supported, it deploys contracts deterministically.
+    if (network && isSupportedNetwork(network)) {
+        // Proxy address got from https://github.com/Arachnid/deterministic-deployment-proxy.
+        const proxyAddress = "0x4e59b44847b379578588920ca78fbf26c0b4956c"
+        // For the moment, salt will always be zero.
+        const salt = `0x${"0".repeat(64)}`
+
+        const { bytecode, interface: abi } = ContractFactory
+        const [signer] = await ethers.getSigners()
+
+        // If the contract has a constructor with arguments, they should be added to the bytecode/initcode.
+        const encodedArgs = args ? abi.encodeDeploy(args).slice(2) : ""
+
+        await signer.sendTransaction({
+            to: proxyAddress,
+            data: `${salt}${bytecode.replace("0x", "")}${encodedArgs}`
+        })
+
+        // Contract addresses can be calculated deterministically.
+        return ethers.getCreate2Address(proxyAddress, salt, ethers.keccak256(bytecode + encodedArgs))
+    }
+
+    const contract = await ContractFactory.deploy(...args)
+
+    await contract.waitForDeployment()
+
+    return contract.getAddress()
+}
+
 export function getDeployedContracts(): DeployedContracts {
     return JSON.parse(readFileSync(deployedContractsPath, "utf8"))
 }

packages/contracts/tasks/deploy.ts

@@ -1,6 +1,6 @@
 import { SupportedNetwork } from "@semaphore-protocol/utils"
 import { task, types } from "hardhat/config"
-import { saveDeployedContracts } from "../scripts/utils"
+import { deploy, saveDeployedContracts } from "../scripts/utils"
 
 task("deploy", "Deploy a Semaphore contract")
     .addOptionalParam<boolean>("verifier", "Verifier contract address", undefined, types.string)
@@ -14,44 +14,32 @@ task("deploy", "Deploy a Semaphore contract")
             const startBlock = await ethers.provider.getBlockNumber()
 
             if (!semaphoreVerifierAddress) {
-                const VerifierFactory = await ethers.getContractFactory(`SemaphoreVerifier`)
-
-                const verifier = await VerifierFactory.deploy()
-
-                await verifier.waitForDeployment()
-
-                semaphoreVerifierAddress = await verifier.getAddress()
+                semaphoreVerifierAddress = await deploy(ethers, "SemaphoreVerifier", hardhatArguments.network)
 
                 if (logs) {
                     console.info(`SemaphoreVerifier contract has been deployed to: ${semaphoreVerifierAddress}`)
                 }
             }
 
             if (!poseidonT3Address) {
-                const PoseidonT3Factory = await ethers.getContractFactory("PoseidonT3")
-
-                const poseidonT3 = await PoseidonT3Factory.deploy()
-
-                await poseidonT3.waitForDeployment()
-
-                poseidonT3Address = await poseidonT3.getAddress()
+                poseidonT3Address = await deploy(ethers, "PoseidonT3", hardhatArguments.network)
 
                 if (logs) {
                     console.info(`PoseidonT3 library has been deployed to: ${poseidonT3Address}`)
                 }
             }
 
-            const SemaphoreFactory = await ethers.getContractFactory("Semaphore", {
-                libraries: {
-                    PoseidonT3: poseidonT3Address
+            const semaphoreAddress = await deploy(
+                ethers,
+                "Semaphore",
+                hardhatArguments.network,
+                [semaphoreVerifierAddress],
+                {
+                    libraries: {
+                        PoseidonT3: poseidonT3Address
+                    }
                 }
-            })
-
-            const semaphore = await SemaphoreFactory.deploy(semaphoreVerifierAddress)
-
-            await semaphore.waitForDeployment()
-
-            const semaphoreAddress = await semaphore.getAddress()
+            )
 
             if (logs) {
                 console.info(`Semaphore contract has been deployed to: ${semaphoreAddress}`)
@@ -79,7 +67,7 @@ task("deploy", "Deploy a Semaphore contract")
             )
 
             return {
-                semaphore,
+                semaphore: await ethers.getContractAt("Semaphore", semaphoreAddress),
                 verifierAddress: semaphoreVerifierAddress,
                 poseidonAddress: poseidonT3Address
             }