This is part 2 of How to deploy a contract to the same address on multiple networks. Navigate to part 1 and complete the setup and deployment steps before continuing:

How to deploy a contract to the same address on multiple networks (part 1)

Now that we have learned how to set equivalent nonces on all networks, let’s explore another solution to deterministic deployment. In this section, we will deploy a contract factory with create2.

Create2 is an alternative to deriving contract addresses that do not involve the nonce. Instead, a contract can be deployed using the deployer address, bytecode, and salt, as illustrated below:

• Deployer address: The Ethereum wallet address used to deploy a contract.

• bytecode: A low level compiled version of a Solidity smart contract that can be read by the EVM.

• salt: A required but arbitrary value provided by the user.

Instead of the nonce, create2 uses a random salt hex set by the user. In the image above, the salt used is “HELLO”. With the salt hex, a specific contract address can then be derived with the wallet address and bytecode. If this transaction is run again on the same network, it will fail because a contract has already been deployed to that address.

Because create2 is a solidity feature, we can only utilize it on the Ethereum network. Hence, we will code a contract deployment factory with a create2 function and deploy the factory. Then our factory should be able to deploy any contract deterministically using a given salt.

Create2 contract factory

In the contracts folder, create a new solidity file named DeterministicDeployFactory.sol, and add the following lines:

1
// SPDX-License-Identifier: MIT
2
pragma solidity ^0.8.9;
3
4
contract DeterministicDeployFactory {
5
    
6
}

Inside our contract, let’s add a deploy function and pass in a bytecode and salt parameter:

1
function deploy(bytes memory bytecode, uint _salt) external {
2
 
3
}

Inside, let’s add an address named addr and an inline assembly statement to communicate with the EVM at a low level:

1
address addr;
2
assembly {
3
}

Within the assembly statement, we can use Yul to call create2 and instruct the EVM to deploy our contract’s bytecode:

1
addr := create2(0, add(bytecode, 0x20), mload(bytecode), _salt)
2
if iszero(extcodesize(addr)) {
3
revert(0, 0)
4
}

Then, let’s create an event that will emit our deployed address when the function is called. Above the function, add the following event:

1
event Deploy(address addr);

Finally, at the end of the function body, add an emit statement:

1
emit Deploy(addr);

If successful, your contract should look like this:

1
// SPDX-License-Identifier: MIT
2
pragma solidity ^0.8.9;
3
4
contract DeterministicDeployFactory {
5
    event Deploy(address addr);
6
7
    function deploy(bytes memory bytecode, uint _salt) external {
8
        address addr;
9
        assembly {
10
            addr := create2(0, add(bytecode, 0x20), mload(bytecode), _salt)
11
            if iszero(extcodesize(addr)) {
12
        revert(0, 0)
13
      }
14
    }
15
16
    emit Deploy(addr);
17
    }
18
}

Before we continue, let’s compile our contract with the following Hardhat command:

$
npx hardhat compile

If successful, you should see:

$
Compiled 1 Solidity file successfully

Great work! We are almost there. All that’s left is to create a deploy script and deploy our factory!

Factory deploy script

In your scripts folder, create a new file named deployFactory.js and paste the following async function and catch statement:

1
const main = async () => {
2
3
  }
4
  
5
  main().catch((error) => {
6
    console.error(error);
7
    process.exitCode = 1;
8
  });

Inside our function body, add the following lines:

1
const Factory = await ethers.getContractFactory("DeterministicDeployFactory");
2
// Here, we tell Hardhat which contract we want to deploy. 
3
// Hardhat then knows how to handle the signer and contract ABI used for deployment. 
4
const factory = await Factory.deploy();
5
// deploying our contract
6
await factory.deployed();
7
console.log("Factory deployed to:", factory.address);

Your entire deploy script should look like this:

1
const main = async () => {
2
    const Factory = await ethers.getContractFactory("DeterministicDeployFactory");
3
    const factory = await Factory.deploy();
4
    await factory.deployed();
5
    console.log("Factory deployed to:", factory.address);
6
  }
7
  
8
  main().catch((error) => {
9
    console.error(error);
10
    process.exitCode = 1;
11
  });

Now, let’s deploy! Because our nonces are set equally on each network, this factory will deploy to the same address everywhere. Let’s deploy to each network by running the following Hardhat commands:

$
npx hardhat run scripts/deployFactory.js --network goerli
>
npx hardhat run scripts/deployFactory.js --network mumbai
>
npx hardhat run scripts/deployFactory.js --network arbitrum
>
npx hardhat run scripts/deployFactory.js --network optimism

If successful, each deployment should return the same address on every network:

$
Factory deployed to: 0x3bdcbd275741bd33D4A3e3469793065b528F1A93
>
Factory deployed to: 0x3bdcbd275741bd33D4A3e3469793065b528F1A93
>
Factory deployed to: 0x3bdcbd275741bd33D4A3e3469793065b528F1A93
>
Factory deployed to: 0x3bdcbd275741bd33D4A3e3469793065b528F1A93

✨Congratulations✨ You just created your own deployment factory and deployed it deterministically on four test networks!

Deploy a contract with the factory

Now that we’ve deployed our factory, let’s test its functionality by sending our vault contract to our factory for deployment with create2.

First, let’s make an important change to Vault.sol. Because we are now deploying from a factory, we can no longer set the owner of our contract as msg.sender. This will set the factory address as the owner because it is technically the deployer. Since we don’t have the factory’s private key, the funds would then be locked indefinitely.

Instead, set your own Metamask address as the owner:

1
owner = payable(0x5DAAC14781a5C4AF2B0673467364Cba46Da935dB); //CHANGE TO YOUR ADDRESS

Now, recompile the contract by typing the following in the terminal:

$
npx hardhat compile

If successful, Hardhat will return:

$
Compiled 1 Solidity file successfully

Utility functions

Before we deploy, we need to create two helper functions. The first will encode and hash our constructor parameter (unlock time), so it is readable to the EVM. This is necessary because our deployment factory requires both the bytecode and constructor arguments to deploy. The second function will compute the Vault contract’s deployed address, which we need in both the depositVault and withdrawVault scripts.

In your project folder, create a new folder called utils:

$
mkdir utils

Inside utils create, a file named utils.js and add the following lines:

1
const { ethers } = require("ethers");
2
3
const encoder = (types, values) => {
4
5
};
6
7
const create2Address = (factoryAddress, saltHex, initCode) => {
8
9
}
10
11
exports.encoder = encoder;
12
exports.create2Address = create2Address;

Let’s start with the encoder function. We are passing the types and values of our constructor arguments. For example, in our Vault contract, the constructor is passed an unlock time. So to encode the time, we provide its type “uint” and Unix timestamp value (“1657434348”) to the encoder.

Inside the encoder function, add the following lines:

1
const encoder = (types, values) => {
2
  const abiCoder = ethers.utils.defaultAbiCoder;
3
  const encodedParams = abiCoder.encode(types, values);
4
  return encodedParams.slice(2);
5
};

Here, we use the AbiCoder from ethers.js and encode our constructor arguments into a hexadecimal value the EVM can read.

Next, let’s add to the create2address function. Our function receives the deployer address(factory address) + salt(saltHex) + bytecode(initCode). These are all the necessary components to compute a create2 address.

Inside the function body, add the following:

1
const create2Address = (factoryAddress, saltHex, initCode) => {
2
  const create2Addr = ethers.utils.getCreate2Address(factoryAddress, saltHex, ethers.utils.keccak256(initCode));
3
  return create2Addr;
4
}

We are using another ethers.js function which computes the create2 address and returns our deployed address.

Your utils.js file should look like this:

1
const { ethers } = require("ethers");
2
3
const encoder = (types, values) => {
4
    const abiCoder = ethers.utils.defaultAbiCoder;
5
    const encodedParams = abiCoder.encode(types, values);
6
    return encodedParams.slice(2);
7
};
8
9
const create2Address = (factoryAddress, saltHex, initCode) => {
10
    const create2Addr = ethers.utils.getCreate2Address(factoryAddress, saltHex, ethers.utils.keccak256(initCode));
11
    return create2Addr;
12
13
}
14
15
exports.encoder = encoder;
16
exports.create2Address = create2Address;

Awesome! Now we can move on to the deploy script!

Edit Vault deploy script

Replace the contents of your vaultDeploy.js file with the following:

1
const { bytecode } = require("../artifacts/contracts/Vault.sol/Vault.json");
2
const { encoder, create2Address } = require("../utils/utils.js")
3
4
const main = async () => {
5
6
};
7
8
main()
9
  .then(() => process.exit(0))
10
  .catch((error) => {
11
    console.error(error);
12
    process.exit(1);
13
  });

Above, we have imported our Vault contract bytecode. Hardhat generates contract bytecode in the artifacts folder after you compile a contract. Additionally, we have imported our encoder and create2Address functions from utils.

We know our updated deploy script will need to do the following:

• Generate the create2 address.

• Connect to our deployed factory.

• Call the deploy function, pass the Vault bytecode, and pass a salt.

• Wait for the deployment event and print the deployed address.

To generate our create2 address, we need to create a timestamp, salt hex, and configure our deployment bytecode.

First, let’s generate another Unix timestamp and set the unlock time with our Hardhat task:

$
npx hardhat unlocktimer --set 30

Navigate back to vaultDeploy.js and create a variable inside the main function to store your new Unix timestamp:

1
const unlockTime = "1657835239"

Also, create a variable to store your deployed factory address, as we will need this to connect to the factory:

1
const factoryAddr = "0x7B514ecfA2d02e085706d3EE6D63DE4a33CFc4e0" //YOUR FACTORY ADDRESS

Now, let’s create a variable to store our salt hex. We can take an arbitrary value and get its hex value with the following ethers function:

1
const saltHex = ethers.utils.id("1234");

The last parameter we will need to compute the create2 address is the contract deployment code. We can configure the deployment code by adding the encoded constructor arguments to the end of the bytecode like so:

1
const initCode = bytecode + encoder(["uint"], [unlockTime]);

Next, we call our imported create2Address function, pass in our parameters and store it in a variable:

1
const create2Addr = create2Address(factoryAddr, saltHex, initCode);
2
console.log("precomputed address:", create2Addr);

Your vaultDeploy.js file should appear as follows:

1
const { bytecode } = require("../artifacts/contracts/Vault.sol/Vault.json");
2
const { encoder, create2Address } = require("../utils/utils.js")
3
4
const main = async () => {
5
    const factoryAddr = "0x3bdcbd275741bd33D4A3e3469793065b528F1A93";
6
    const unlockTime = "1657835239"
7
    const saltHex = ethers.utils.id("1234");
8
    const initCode = bytecode + encoder(["uint"], [unlockTime]);
9
10
    const create2Addr = create2Address(factoryAddr, saltHex, initCode);
11
    console.log("precomputed address:", create2Addr);
12
};
13
14
main()
15
  .then(() => process.exit(0))
16
  .catch((error) => {
17
    console.error(error);
18
    process.exit(1);
19
  });

In console, run the following Hardhat command:

$
npx hardhat run scripts/vaultDeploy.js

If successful, you will get your precomputed Vault contract address:

$
precomputed address: 0xd216001476CC8F8a277F45d9bFE3996c3f38da5a

Now, create a connection to your factory using ethers by adding the following:

1
const Factory = await ethers.getContractFactory("DeterministicDeployFactory");
2
const factory = await Factory.attach(factoryAddr);

Lastly, call the factory deploy function and pass in our init code and salt hex. Then wait for the transaction receipt and print the deployed address:

1
const lockDeploy = await factory.deploy(initCode, saltHex);
2
const txReceipt = await lockDeploy.wait();
3
console.log("Deployed to:", txReceipt.events[0].args[0]);

Your vaultDeploy.js file should look as follows:

1
const { bytecode } = require("../artifacts/contracts/Vault.sol/Vault.json");
2
const { encoder, create2Address } = require("../utils/utils.js")
3
4
const main = async () => {
5
    const factoryAddr = "0x3bdcbd275741bd33D4A3e3469793065b528F1A93";
6
    const unlockTime = "1657852422"
7
    const saltHex = ethers.utils.id("1234");
8
    const initCode = bytecode + encoder(["uint"], [unlockTime]);
9
10
    const create2Addr = create2Address(factoryAddr, saltHex, initCode);
11
    console.log("precomputed address:", create2Addr);
12
    
13
    const Factory = await ethers.getContractFactory("DeterministicDeployFactory");
14
    const factory = await Factory.attach(factoryAddr);
15
16
    const lockDeploy = await factory.deploy(initCode, saltHex);
17
    const txReceipt = await lockDeploy.wait();
18
    console.log("Deployed to:", txReceipt.events[0].args[0]);
19
};
20
21
main()
22
  .then(() => process.exit(0))
23
  .catch((error) => {
24
    console.error(error);
25
    process.exit(1);
26
  });

Ensure your timestamp is still set ahead of the current time and run the deploy script for each network with this Hardhat command:

$
npx hardhat run scripts/vaultDeploy.js --network goerli
>
npx hardhat run scripts/vaultDeploy.js --network mumbai
>
npx hardhat run scripts/vaultDeploy.js --network arbitrum
>
npx hardhat run scripts/vaultDeploy.js --network optimism

If successful, your vault contract will deploy to your precomputed create2 address on each testnet:

$
Deployed to: 0xd216001476CC8F8a277F45d9bFE3996c3f38da5a
>
Deployed to: 0xd216001476CC8F8a277F45d9bFE3996c3f38da5a
>
Deployed to: 0xd216001476CC8F8a277F45d9bFE3996c3f38da5a
>
Deployed to: 0xd216001476CC8F8a277F45d9bFE3996c3f38da5a

Woohoo, nice job!! 🥳🥳 You can now use your factory to deploy deterministically without maintaining your account nonces! If you have come this far, you’re ready to build some awesome projects! 🌠🌠🌠

Learning recap

In this tutorial, you learned:

• How contract addresses are derived with nonces and salts.

• The difference between standard and create2 deployment.

• How to build, test, and deploy smart contracts in Hardhat.

• How to deploy a contract to the same address on multiple networks by setting the nonce.

• How to deploy a contract to the same precomputed address on multiple networks with create2.

Feel free to reach out to us in the Alchemy Discord for help or chat with us @Alchemy on Twitter!