[evm]: EvmHost CREATE2 refactor (#866)

Author: seunlanlege

evm/script/DeployHFT.s.sol

@@ -19,6 +19,7 @@ contract DeployHFT is BaseScript {
             dispatcher: address(dispatcher)
         }));
 
+        vm.stopBroadcast();
         console.log("=== HFT Deployment ===");
         console.log("HyperFungibleToken:", address(hft));
         console.log("CallDispatcher:", address(dispatcher));

evm/script/DeployIsmp.s.sol

@@ -8,25 +8,14 @@ import "../src/core/HandlerV2.sol";
 import "../src/core/EvmHost.sol";
 import "../src/core/HostManager.sol";
 
+import {TestnetHost} from "../src/core/TestnetHost.sol";
+
 import "../src/consensus/EcdsaBeefy.sol";
 import "../src/consensus/ConsensusRouter.sol";
-import "../src/hosts/Ethereum.sol";
-import "../src/hosts/Arbitrum.sol";
-import "../src/hosts/Optimism.sol";
-import "../src/hosts/Base.sol";
-import "../src/hosts/Gnosis.sol";
-import "../src/hosts/Soneium.sol";
-import "../src/hosts/Unichain.sol";
-import "../src/hosts/Sei.sol";
 
 import {HyperFungibleTokenImpl} from "../src/utils/HyperFungibleTokenImpl.sol";
 import {TokenFaucet} from "../src/utils/TokenFaucet.sol";
 
-import {BscHost} from "../src/hosts/Bsc.sol";
-import {PolygonHost} from "../src/hosts/Polygon.sol";
-import {PolkadotHost} from "../src/hosts/Polkadot.sol";
-import {PharosHost} from "../src/hosts/Pharos.sol";
-
 import {SP1Verifier} from "@sp1-contracts/v5.0.0/SP1VerifierGroth16.sol";
 import {SP1Beefy} from "../src/consensus/SP1Beefy.sol";
 import {EcdsaBeefy} from "../src/consensus/EcdsaBeefy.sol";
@@ -63,10 +52,8 @@ contract DeployScript is BaseScript {
         // Deploy SP1 ZK consensus client
         SP1Verifier verifier = new SP1Verifier{salt: salt}();
         SP1Beefy sp1Beefy = new SP1Beefy{salt: salt}(verifier, sp1VerificationKey);
-
         // Deploy EcdsaBeefy naive consensus client
         EcdsaBeefy ecdsaBeefy = new EcdsaBeefy{salt: salt}();
-
         // Deploy ConsensusRouter wrapping both consensus clients
         ConsensusRouter consensusRouter = new ConsensusRouter{salt: salt}(
             IConsensus(address(sp1Beefy)), IConsensus(address(ecdsaBeefy))
@@ -108,7 +95,6 @@ contract DeployScript is BaseScript {
 
         // handler
         HandlerV2 handler = new HandlerV2{salt: salt}();
-
         // Host manager
         HostManager manager = new HostManager{salt: salt}(HostManagerParams({admin: admin, host: address(0)}));
         uint256[] memory stateMachines = new uint256[](1);
@@ -128,12 +114,15 @@ contract DeployScript is BaseScript {
             stateMachines: stateMachines
         });
 
-        address hostAddress = initHost(params);
+        EvmHost host = isMainnet
+            ? new EvmHost{salt: salt}(admin)
+            : EvmHost(payable(address(new TestnetHost{salt: salt}(admin))));
+        host.initialize(params);
         // set the host address on the host manager
-        manager.setIsmpHost(hostAddress);
+        manager.setIsmpHost(address(host));
 
         // Set the consensus state
-        EvmHost(payable(hostAddress))
+        EvmHost(payable(address(host)))
             .setConsensusState(
                 consensusState,
                 StateMachineHeight({stateMachineId: paraId, height: 1}),
@@ -143,81 +132,12 @@ contract DeployScript is BaseScript {
         // ============= Deploy applications =============
         CallDispatcher callDispatcher = new CallDispatcher{salt: salt}();
 
-        if (!isMainnet) {
-            config.set("TOKEN_FAUCET", address(faucet));
-        }
-
+        vm.stopBroadcast();
         // ============= Write addresses to config =============
-        config.set("HOST", hostAddress);
+        if (!isMainnet) config.set("TOKEN_FAUCET", address(faucet));
+        config.set("HOST", address(host));
         config.set("HANDLER", address(handler));
         config.set("FEE_TOKEN", feeToken);
         config.set("CALL_DISPATCHER", address(callDispatcher));
     }
-
-    function initHost(HostParams memory params) public returns (address) {
-        uint256 chainId = block.chainid;
-
-        // Ethereum (mainnet: 1, sepolia: 11155111)
-        if (chainId == 1 || chainId == 11155111) {
-            EthereumHost h = new EthereumHost{salt: salt}(params);
-            return address(h);
-        }
-        // Arbitrum (mainnet: 42161, sepolia: 421614)
-        else if (chainId == 42161 || chainId == 421614) {
-            ArbitrumHost h = new ArbitrumHost{salt: salt}(params);
-            return address(h);
-        }
-        // Optimism (mainnet: 10, sepolia: 11155420)
-        else if (chainId == 10 || chainId == 11155420) {
-            OptimismHost h = new OptimismHost{salt: salt}(params);
-            return address(h);
-        }
-        // Base (mainnet: 8453, sepolia: 84532)
-        else if (chainId == 8453 || chainId == 84532) {
-            BaseHost h = new BaseHost{salt: salt}(params);
-            return address(h);
-        }
-        // BSC (mainnet: 56, testnet: 97)
-        else if (chainId == 56 || chainId == 97) {
-            BscHost h = new BscHost{salt: salt}(params);
-            return address(h);
-        }
-        // Polygon (mainnet: 137, amoy: 80002)
-        else if (chainId == 137 || chainId == 80002) {
-            PolygonHost h = new PolygonHost{salt: salt}(params);
-            return address(h);
-        }
-        // Gnosis (mainnet: 100, chiado: 10200)
-        else if (chainId == 100 || chainId == 10200) {
-            GnosisHost h = new GnosisHost{salt: salt}(params);
-            return address(h);
-        }
-        // Soneium (mainnet: 1868)
-        else if (chainId == 1868) {
-            SoneiumHost h = new SoneiumHost{salt: salt}(params);
-            return address(h);
-        }
-        // Unichain (mainnet: 1301)
-        else if (chainId == 1301) {
-            UnichainHost h = new UnichainHost{salt: salt}(params);
-            return address(h);
-        }
-        // Sei (mainnet: 1329, arctic testnet: 1328)
-        else if (chainId == 1329 || chainId == 1328) {
-            SeiHost h = new SeiHost{salt: salt}(params);
-            return address(h);
-        }
-        // Polkadot Asset Hub (mainnet: 420420419, testnet: 420420417)
-        else if (chainId == 420420419 || chainId == 420420417) {
-            PolkadotHost h = new PolkadotHost{salt: salt}(params);
-            return address(h);
-        }
-        // Pharos (mainnet: 688600, testnet: 688689)
-        else if (chainId == 688600 || chainId == 688689) {
-            PharosHost h = new PharosHost{salt: salt}(params);
-            return address(h);
-        }
-
-        revert("Unknown chain ID");
-    }
 }

evm/script/DeployUniV3Wrapper.sol

@@ -21,13 +21,13 @@ contract DeployScript is BaseScript {
         address uniswapV2 = IDispatcher(HOST_ADDRESS).uniswapV2Router();
 
         UniV3UniswapV2Wrapper wrapper = new UniV3UniswapV2Wrapper{salt: salt}(admin);
-        console.log("UniV3UniswapV2Wrapper deployed at:", address(wrapper));
-
         wrapper.init(
             UniV3UniswapV2Wrapper.Params({
                 WETH: IUniswapV2Router02(uniswapV2).WETH(), swapRouter: swapRouter, quoter: quoter, maxFee: maxFee
             })
         );
+        vm.stopBroadcast();
+        console.log("UniV3UniswapV2Wrapper deployed at:", address(wrapper));
         console.log("UniV3UniswapV2Wrapper initialized");
     }
 }

evm/script/DeployUniV4Wrapper.sol

@@ -20,7 +20,6 @@ contract DeployScript is BaseScript {
         address weth = config.get("WETH").toAddress();
 
         UniV4UniswapV2Wrapper wrapper = new UniV4UniswapV2Wrapper{salt: salt}(admin);
-        console.log("UniV4UniswapV2Wrapper deployed at:", address(wrapper));
 
         wrapper.init(
             UniV4UniswapV2Wrapper.Params({
@@ -31,6 +30,8 @@ contract DeployScript is BaseScript {
                 defaultTickSpacing: defaultTickSpacing
             })
         );
+        vm.stopBroadcast();
+        console.log("UniV4UniswapV2Wrapper deployed at:", address(wrapper));
         console.log("UniV4UniswapV2Wrapper initialized");
     }
 }

evm/script/DeployWrappedHFT.s.sol

@@ -21,6 +21,7 @@ contract DeployWrappedHFT is BaseScript {
             isWeth: isWeth
         }));
 
+        vm.stopBroadcast();
         console.log("=== WrappedHFT Deployment ===");
         console.log("WrappedHyperFungibleToken:", address(whft));
         console.log("CallDispatcher:", address(dispatcher));

evm/src/core/EvmHost.sol

@@ -108,7 +108,7 @@ struct WithdrawParams {
  * It is only responsible for dispatching incoming & outgoing requests/responses. As well as managing
  * the state of the ISMP protocol.
  */
-abstract contract EvmHost is IHost, IHostManager, Context {
+contract EvmHost is IHost, IHostManager, Context {
     using Message for PostRequest;
     using Message for GetRequest;
     using Message for GetResponse;
@@ -134,15 +134,15 @@ abstract contract EvmHost is IHost, IHostManager, Context {
 
     // mapping of state machine identifier to latest known height
     // (stateMachineId => blockHeight)
-    mapping(uint256 => uint256) private _latestStateMachineHeight;
+    mapping(uint256 => uint256) internal _latestStateMachineHeight;
 
     // mapping of state machine identifier to height vetoed to fisherman
     // useful for rewarding fishermen on hyperbridge
     // (stateMachineId => (blockHeight => fisherman))
     mapping(uint256 => mapping(uint256 => address)) private _vetoes;
 
     // Parameters for the host
-    HostParams private _hostParams;
+    HostParams internal _hostParams;
 
     // Monotonically increasing nonce for outgoing requests
     uint256 private _nonce;
@@ -163,6 +163,10 @@ abstract contract EvmHost is IHost, IHostManager, Context {
     // The most recent authority set ID for which a consensus proof has been submitted.
     uint256 private _currentEpoch;
 
+    // One-shot guard for `initialize`. Appended after all existing storage so
+    // this change does not shift any pre-existing storage slots.
+    bool private _initialized;
+
     // Emitted when an incoming POST request is handled
     event PostRequestHandled(
         // Commitment of the incoming request
@@ -352,9 +356,28 @@ abstract contract EvmHost is IHost, IHostManager, Context {
         _;
     }
 
-    constructor(HostParams memory params) {
-        updateHostParamsInternal(params);
+    /**
+     * @dev Constructor only sets the initial admin and the consensus update
+     * timestamp. All other configuration is deferred to `initialize` so that
+     * the constructor's init code is identical on every chain (assuming the
+     * same `admin` is used everywhere), which is required for CREATE2 address
+     * parity across chains.
+     */
+    constructor(address _admin) {
         _consensusUpdateTimestamp = block.timestamp;
+        _hostParams.admin = _admin;
+    }
+
+    /**
+     * @dev One-shot initializer. Can only be called once, and only by the
+     * admin set in the constructor. Applies the initial `HostParams` via
+     * the internal updater.
+     */
+    function initialize(HostParams memory params) external {
+        if (_msgSender() != _hostParams.admin) revert UnauthorizedAction();
+        if (_initialized) revert UnauthorizedAction();
+        _initialized = true;
+        updateHostParamsInternal(params);
     }
 
     /*
@@ -369,11 +392,6 @@ abstract contract EvmHost is IHost, IHostManager, Context {
         return StateMachine.evm(block.chainid);
     }
 
-    /**
-     * @return the mainnet evm chainId for this host
-     */
-    function chainId() public virtual returns (uint256);
-
     /**
      * @return the host timestamp
      */
@@ -544,26 +562,15 @@ abstract contract EvmHost is IHost, IHostManager, Context {
     }
 
     /**
-     * @dev Updates the HostParams. On mainnet it can only be called by cross-chain governance.
+     * @dev Updates the HostParams. Only callable by cross-chain governance
+     * via the configured `hostManager`. The admin has no privileges here —
+     * environments that need a privileged admin override (testnets, forks)
+     * should use `TestnetHost`, which extends this contract.
+     *
+     * Marked `virtual` so subclasses can broaden the authorization
      * @param params, the new host params.
      */
-    function updateHostParams(HostParams memory params) external {
-        address caller = _msgSender();
-        if (caller != _hostParams.hostManager && caller != _hostParams.admin) {
-            revert UnauthorizedAction();
-        }
-
-        if (caller == _hostParams.admin) {
-            // admin cannot change host params on mainnet
-            if (chainId() == block.chainid) revert UnauthorizedAction();
-
-            // reset all state machines, on testnet
-            uint256 whitelistLength = params.stateMachines.length;
-            for (uint256 i = 0; i < whitelistLength; ++i) {
-                delete _latestStateMachineHeight[params.stateMachines[i]];
-            }
-        }
-
+    function updateHostParams(HostParams memory params) external virtual restrict(_hostParams.hostManager) {
         updateHostParamsInternal(params);
     }
 
@@ -746,17 +753,31 @@ abstract contract EvmHost is IHost, IHostManager, Context {
     }
 
     /**
-     * @dev sets the initial consensus state
+     * @dev Whether the admin is permitted to (re)initialize the consensus
+     * state. On mainnet hosts the consensus state may only be set once via
+     * `setConsensusState` and is thereafter only updated through consensus
+     * proofs. `TestnetHost` overrides this to permit repeated admin
+     * re-initialization.
+     */
+    function _canReinitConsensus() internal view virtual returns (bool) {
+        return keccak256(_consensusState) == keccak256(bytes(""));
+    }
+
+    /**
+     * @dev sets the initial consensus state. By default this is a one-shot
+     * operation: once `_consensusState` is non-empty the admin can no longer
+     * call this and consensus state moves only through `storeConsensusState`
+     * (handler-only, driven by consensus proofs). `TestnetHost` overrides
+     * `_canReinitConsensus` to lift this restriction.
      * @param state initial consensus state
+     * @param height initial state-machine height
+     * @param commitment initial state commitment at `height`
      */
     function setConsensusState(bytes memory state, StateMachineHeight memory height, StateCommitment memory commitment)
         public
         restrict(_hostParams.admin)
     {
-        // if we're on mainnet, then consensus state can only be initialized once
-        // and updated subsequently through consensus proofs
-        bool canUpdate = chainId() == block.chainid ? keccak256(_consensusState) == keccak256(bytes("")) : true;
-        if (!canUpdate) revert UnauthorizedAction();
+        if (!_canReinitConsensus()) revert UnauthorizedAction();
 
         _consensusState = state;
         _consensusUpdateTimestamp = block.timestamp;