Multichain Deployment

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)
    )))));
}

// 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();
        }
    }
}

forge script script/MultiChainDeploy.s.sol --broadcast --multi --verify

{
  "protocol": "MyProtocol",
  "version": "1.0.0",
  "salt": "0x...",
  "deployments": {
    "1": {
      "address": "0xSameOnAllChains",
      "txHash": "0x...",
      "blockNumber": 18000000,
      "deployer": "0x...",
      "timestamp": "2025-06-01T00:00:00Z"
    },
    "8453": {
      "address": "0xSameOnAllChains",
      "txHash": "0x...",
      "blockNumber": 5000000,
      "deployer": "0x...",
      "timestamp": "2025-06-01T00:05:00Z"
    }
  }
}

function _writeDeployment(uint256 chainId, address deployed, bytes32 txHash) internal {
    string memory key = vm.toString(chainId);
    string memory json = vm.serializeAddress(key, "address", deployed);
    json = vm.serializeBytes32(key, "txHash", txHash);
    json = vm.serializeUint(key, "blockNumber", block.number);
    vm.writeJson(json, "./deployments.json", string.concat(".", key));
}

contract MyProtocol {
    address public admin;
    address public weth;
    bool private _initialized;

    function initialize(address admin_, address weth_) external {
        require(!_initialized, "Already initialized");
        _initialized = true;
        admin = admin_;
        weth = weth_;
    }
}

import {CREATE3} from "solady/utils/CREATE3.sol";

contract MultiChainFactory {
    function deploy(bytes32 salt, bytes memory creationCode) external returns (address) {
        return CREATE3.deploy(salt, creationCode, 0);
    }

    function predict(bytes32 salt) external view returns (address) {
        return CREATE3.getDeployed(salt);
    }
}

contract MultiChainTest is Test {
    uint256 mainnetFork;
    uint256 baseFork;
    uint256 opFork;

    function setUp() public {
        mainnetFork = vm.createFork("mainnet");
        baseFork = vm.createFork("base");
        opFork = vm.createFork("optimism");
    }

    function test_deploysSameAddress() public {
        bytes32 salt = keccak256("test-v1");
        bytes memory initCode = type(MyProtocol).creationCode;

        vm.selectFork(mainnetFork);
        address addrMainnet = _deployViaCreate2(salt, initCode);

        vm.selectFork(baseFork);
        address addrBase = _deployViaCreate2(salt, initCode);

        vm.selectFork(opFork);
        address addrOp = _deployViaCreate2(salt, initCode);

        assertEq(addrMainnet, addrBase, "Mainnet != Base");
        assertEq(addrBase, addrOp, "Base != Optimism");
    }
}

#!/bin/bash
# verify-all.sh

CHAINS=("mainnet" "base" "optimism" "arbitrum")
CONTRACT_ADDR="0xSameOnAllChains"
CONTRACT_PATH="src/MyProtocol.sol:MyProtocol"

for chain in "${CHAINS[@]}"; do
  echo "Verifying on $chain..."
  forge verify-contract "$CONTRACT_ADDR" "$CONTRACT_PATH" \
    --chain "$chain" --watch
done