The Create2 Factory is a minimal proxy contract that enables deterministic contract deployment using the CREATE2 opcode. This allows developers to deploy contracts to addresses that can be computed in advance, regardless of the deployer’s nonce or transaction order. Contract Address: 0x4e59b44847b379578588920ca78fbf26c0b4956c Deployment Status: Default preinstall Gas Cost: Deployment cost + ~32,000 gas overhead

​
Key Features

  • Deterministic Addresses: Compute contract addresses before deployment
  • Cross-chain Consistency: Same address on all chains with the same bytecode and salt
  • Minimal Implementation: Only 45 bytes of optimized assembly code
  • No Storage or State: Pure function contract with no storage variables

​
How It Works

The CREATE2 opcode computes addresses using: 
address = keccak256(0xff ++ deployerAddress ++ salt ++ keccak256(bytecode))[12:]
This formula ensures that the same inputs always produce the same address, enabling:
  • Pre-funding of contract addresses before deployment
  • Cross-chain address consistency
  • Gasless contract deployment patterns

​
Usage

​
Deploy a Contract

import { ethers } from "ethers";

const provider = new ethers.JsonRpcProvider("YOUR_RPC_URL");
const signer = new ethers.Wallet("YOUR_PRIVATE_KEY", provider);

// Create2 Factory address
const CREATE2_FACTORY = "0x4e59b44847b379578588920ca78fbf26c0b4956c";

// Your contract bytecode (including constructor args)
const bytecode = "0x608060405234801561001057600080fd5b50..."; // Your compiled bytecode

// Choose a salt (32 bytes)
const salt = ethers.id("my-unique-salt-v1"); // Or use ethers.randomBytes(32)

// Deploy using Create2
async function deployWithCreate2() {
  // Compute the deployment address
  const deployAddress = ethers.getCreate2Address(
    CREATE2_FACTORY,
    salt,
    ethers.keccak256(bytecode)
  );

  console.log("Contract will be deployed to:", deployAddress);

  // Send deployment transaction
  const tx = await signer.sendTransaction({
    to: CREATE2_FACTORY,
    data: salt + bytecode.slice(2), // Concatenate salt and bytecode
    gasLimit: 3000000, // Adjust based on your contract
  });

  console.log("Deployment tx:", tx.hash);
  await tx.wait();

  console.log("Contract deployed to:", deployAddress);
  return deployAddress;
}

deployWithCreate2();

​
Compute Deployment Address

You can calculate the deployment address without actually deploying: 
import { ethers } from "ethers";

function computeCreate2Address(salt, bytecode) {
  const factoryAddress = "0x4e59b44847b379578588920ca78fbf26c0b4956c";

  const address = ethers.getCreate2Address(
    factoryAddress,
    salt,
    ethers.keccak256(bytecode)
  );

  return address;
}

// Example usage
const salt = ethers.id("my-deployment-v1");
const bytecode = "0x608060405234801561001057600080fd5b50...";
const futureAddress = computeCreate2Address(salt, bytecode);
console.log("Contract will deploy to:", futureAddress);

​
Common Use Cases

​
Implementation Details

The Create2 factory contract is extremely minimal: 
// Entire contract bytecode (45 bytes)
0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe03601600081602082378035828234f58015156039578182fd5b8082525050506014600cf3
This assembly code:
  1. Reads the salt (32 bytes) and bytecode from calldata
  2. Uses the CREATE2 opcode to deploy the contract
  3. Returns the deployed contract address

​
Best Practices

Security Considerations:
  • Always verify bytecode integrity before deployment
  • Be aware that anyone can deploy to a CREATE2 address if they have the bytecode and salt
  • Consider using access controls in your factory contracts

​
Salt Selection

Choose salts carefully for your use case: 
// Sequential salts for multiple instances
const salt1 = ethers.solidityPacked(["uint256"], [1]);
const salt2 = ethers.solidityPacked(["uint256"], [2]);

// User-specific salts
const userSalt = ethers.solidityPacked(["address", "uint256"], [userAddress, nonce]);

// Version-based salts
const versionSalt = ethers.id("v1.2.3");

// Random salts for uniqueness
const randomSalt = ethers.randomBytes(32);

​
Gas Optimization

  • The Create2 factory adds ~32,000 gas overhead
  • Batch deployments in a single transaction when possible
  • Pre-compute addresses to avoid on-chain calculations

​
Comparison with CREATE

AspectCREATECREATE2
Address CalculationBased on deployer + nonceBased on deployer + salt + bytecode
PredictabilityRequires knowing nonceFully deterministic
Cross-chainDifferent addressesSame address possible
Gas CostBaseline~32,000 gas overhead
Use CaseStandard deploymentsDeterministic deployments

​
Troubleshooting

Common issues and solutions:
IssueSolution
”Create2 deployment failed”Ensure sufficient gas and correct bytecode format
Address mismatchVerify salt and bytecode are identical to computation
Contract already deployedCREATE2 can’t deploy to the same address twice
Invalid bytecodeEnsure bytecode includes constructor arguments if needed

​
Example: Multi-chain Token Deployment

Deploy an ERC20 token to the same address across multiple chains: 
import { ethers } from "ethers";

async function deployTokenMultichain(chains) {
  const bytecode = "0x..."; // ERC20 bytecode with constructor args
  const salt = ethers.id("MyToken-v1.0.0");

  // Compute address (same on all chains)
  const tokenAddress = ethers.getCreate2Address(
    "0x4e59b44847b379578588920ca78fbf26c0b4956c",
    salt,
    ethers.keccak256(bytecode)
  );

  console.log("Token will deploy to:", tokenAddress);

  // Deploy on each chain
  for (const chain of chains) {
    const provider = new ethers.JsonRpcProvider(chain.rpc);
    const signer = new ethers.Wallet(privateKey, provider);

    // Check if already deployed
    const code = await provider.getCode(tokenAddress);
    if (code !== "0x") {
      console.log(`Already deployed on ${chain.name}`);
      continue;
    }

    // Deploy
    const tx = await signer.sendTransaction({
      to: "0x4e59b44847b379578588920ca78fbf26c0b4956c",
      data: salt + bytecode.slice(2),
      gasLimit: 3000000,
    });

    await tx.wait();
    console.log(`Deployed on ${chain.name}`);
  }
}

​
Further Reading