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 ``` ```solidity // 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 ```solidity // 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(); } } } ``` ```bash forge script script/MultiChainDeploy.s.sol --broadcast --multi --verify ``` ## Deployment Registry Track deployments across chains: ```json { "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" } } } ``` Generate automatically in your deploy script: ```solidity 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)); } ``` ## Chain-Specific Configuration When contracts need different config per chain but the same address: ```solidity 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_; } } ``` For CREATE3 (address independent of constructor args): ```solidity 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); } } ``` ## Multi-Chain Testing ```solidity 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"); } } ``` ## Verification Across Chains ```bash #!/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 ``` ## Multi-Chain Deployment Checklist - [ ] Same CREATE2 factory exists on all target chains - [ ] Salt is unique per protocol version - [ ] Init code is identical (same compiler, settings, no chain-specific constructor args) - [ ] Predicted address verified before deployment - [ ] Idempotent script (skips chains already deployed) - [ ] Chain-specific config applied via `initialize` (not constructor) - [ ] Deployment registry updated after each chain - [ ] Contracts verified on each chain's block explorer - [ ] Cross-chain functionality tested (bridges, messaging) - [ ] Admin/governance addresses correct per chain