multichain-deployment

Multi-Chain Deployment Patterns

Strategy Overview

For protocol credibility and UX, deploy contracts at the same address on every chain. This requires deterministic deployment via CREATE2 and a consistent deployment flow.

Deterministic Deployment Factory

Use a pre-deployed CREATE2 factory that exists at the same address on all EVM chains.

Arachnid's Deterministic Deployment Proxy (available on nearly all chains):

0x4e59b44847b379578588920cA78FbF26c0B4956C

// Deploy via the keyless CREATE2 factory
function deployDeterministic(bytes memory creationCode, bytes32 salt)
    external returns (address deployed)
{
    address factory = 0x4e59b44847b379578588920cA78FbF26c0B4956C;
    bytes memory payload = abi.encodePacked(salt, creationCode);
    (bool ok, bytes memory result) = factory.call(payload);
    require(ok, "Deploy failed");
    deployed = address(uint160(uint256(keccak256(abi.encodePacked(
        bytes1(0xff), factory, salt, keccak256(creationCode)
    )))));
}

Multi-Chain Forge Script

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import {Script, console2} from "forge-std/Script.sol";
import {MyProtocol} from "../src/MyProtocol.sol";

contract MultiChainDeploy is Script {
    address constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;
    bytes32 constant SALT = keccak256("myprotocol-v1.0.0");

    struct ChainConfig {
        string rpc;
        uint256 chainId;
        address admin;
        address weth;
    }

    function configs() internal view returns (ChainConfig[] memory) {
        ChainConfig[] memory c = new ChainConfig[](4);
        address admin = vm.envAddress("ADMIN_ADDRESS");

        c[0] = ChainConfig("mainnet", 1, admin, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
        c[1] = ChainConfig("base", 8453, admin, 0x4200000000000000000000000000000000000006);
        c[2] = ChainConfig("optimism", 10, admin, 0x4200000000000000000000000000000000000006);
        c[3] = ChainConfig("arbitrum", 42161, admin, 0x82aF49447D8a07e3bd95BD0d56f35241523fBab1);
        return c;
    }

    function predictAddress() public view returns (address) {
        bytes memory initCode = type(MyProtocol).creationCode;
        return address(uint160(uint256(keccak256(abi.encodePacked(
            bytes1(0xff), CREATE2_FACTORY, SALT, keccak256(initCode)
        )))));
    }

    function run() external {
        uint256 deployerKey = vm.envUint("DEPLOYER_PRIVATE_KEY");
        ChainConfig[] memory chains = configs();
        address predicted = predictAddress();

        console2.log("Predicted address:", predicted);

        for (uint256 i = 0; i < chains.length; i++) {
            console2.log("\n--- Deploying to", chains[i].rpc, "---");
            vm.createSelectFork(chains[i].rpc);

            if (predicted.code.length > 0) {
                console2.log("  Already deployed, skipping");
                continue;
            }

            vm.startBroadcast(deployerKey);

            bytes memory initCode = type(MyProtocol).creationCode;
            bytes memory payload = abi.encodePacked(SALT, initCode);
            (bool ok,) = CREATE2_FACTORY.call(payload);
            require(ok, "Deploy failed");
            require(predicted.code.length > 0, "Code not at predicted address");

            console2.log("  Deployed at:", predicted);

            // Chain-specific initialization
            MyProtocol(predicted).initialize(chains[i].admin, chains[i].weth);

            vm.stopBroadcast();
        }
    }
}