OPContractsManager.sol

// SPDX-License-Identifier: MIT
pragma solidity 0.8.15;

// Libraries
import { Blueprint } from "src/libraries/Blueprint.sol";
import { Constants } from "src/libraries/Constants.sol";
import { Bytes } from "src/libraries/Bytes.sol";
import { Claim, Duration, GameType, GameTypes, OutputRoot, Hash } from "src/dispute/lib/Types.sol";
import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";

// Interfaces
import { ISemver } from "interfaces/universal/ISemver.sol";
import { IResourceMetering } from "interfaces/L1/IResourceMetering.sol";
import { IBigStepper } from "interfaces/dispute/IBigStepper.sol";
import { IDelayedWETH } from "interfaces/dispute/IDelayedWETH.sol";
import { IAnchorStateRegistry } from "interfaces/dispute/IAnchorStateRegistry.sol";
import { IDisputeGame } from "interfaces/dispute/IDisputeGame.sol";
import { IAddressManager } from "interfaces/legacy/IAddressManager.sol";
import { IProxyAdmin } from "interfaces/universal/IProxyAdmin.sol";
import { IDisputeGameFactory } from "interfaces/dispute/IDisputeGameFactory.sol";
import { IFaultDisputeGame } from "interfaces/dispute/IFaultDisputeGame.sol";
import { IPermissionedDisputeGame } from "interfaces/dispute/IPermissionedDisputeGame.sol";
import { ISuperchainConfig } from "interfaces/L1/ISuperchainConfig.sol";
import { IProtocolVersions } from "interfaces/L1/IProtocolVersions.sol";
import { IOptimismPortal2 as IOptimismPortal } from "interfaces/L1/IOptimismPortal2.sol";
import { ISystemConfig } from "interfaces/L1/ISystemConfig.sol";
import { IL1CrossDomainMessenger } from "interfaces/L1/IL1CrossDomainMessenger.sol";
import { IL1ERC721Bridge } from "interfaces/L1/IL1ERC721Bridge.sol";
import { IL1StandardBridge } from "interfaces/L1/IL1StandardBridge.sol";
import { IOptimismMintableERC20Factory } from "interfaces/universal/IOptimismMintableERC20Factory.sol";
import { IHasSuperchainConfig } from "interfaces/L1/IHasSuperchainConfig.sol";
import { IETHLockbox } from "interfaces/L1/IETHLockbox.sol";

contract OPContractsManagerContractsContainer {
    /// @notice Addresses of the Blueprint contracts.
    /// This is internal because if public the autogenerated getter method would return a tuple of
    /// addresses, but we want it to return a struct.
    OPContractsManager.Blueprints internal blueprint;

    /// @notice Addresses of the latest implementation contracts.
    OPContractsManager.Implementations internal implementation;

    constructor(
        OPContractsManager.Blueprints memory _blueprints,
        OPContractsManager.Implementations memory _implementations
    ) {
        blueprint = _blueprints;
        implementation = _implementations;
    }

    function blueprints() public view returns (OPContractsManager.Blueprints memory) {
        return blueprint;
    }

    function implementations() public view returns (OPContractsManager.Implementations memory) {
        return implementation;
    }
}

abstract contract OPContractsManagerBase {
    /// @notice The blueprint contract addresses contract.
    OPContractsManagerContractsContainer public immutable contractsContainer;

    /// @notice The OPContractsManager contract that is currently being used.
    OPContractsManagerBase internal immutable thisOPCM;

    /// @notice Constructor to initialize the immutable thisOPCM variable and contract addresses
    /// @param _contractsContainer The blueprint contract addresses and implementation contract addresses
    constructor(OPContractsManagerContractsContainer _contractsContainer) {
        contractsContainer = _contractsContainer;
        thisOPCM = this;
    }

    /// @notice Retrieves the implementation addresses stored in this OPCM contract
    function getImplementations() internal view returns (OPContractsManager.Implementations memory) {
        return thisOPCM.implementations();
    }

    /// @notice Retrieves the blueprint addresses stored in this OPCM contract
    function getBlueprints() internal view returns (OPContractsManager.Blueprints memory) {
        return thisOPCM.blueprints();
    }

    /// @notice Retrieves the implementation addresses stored in this OPCM contract
    function implementations() public view returns (OPContractsManager.Implementations memory) {
        return contractsContainer.implementations();
    }

    /// @notice Retrieves the blueprint addresses stored in this OPCM contract
    function blueprints() public view returns (OPContractsManager.Blueprints memory) {
        return contractsContainer.blueprints();
    }

    /// @notice Maps an L2 chain ID to an L1 batch inbox address as defined by the standard
    /// configuration's convention. This convention is `versionByte || keccak256(bytes32(chainId))[:19]`,
    /// where || denotes concatenation`, versionByte is 0x00, and chainId is a uint256.
    /// https://specs.optimism.io/protocol/configurability.html#consensus-parameters
    function chainIdToBatchInboxAddress(uint256 _l2ChainId) public pure returns (address) {
        bytes1 versionByte = 0x00;
        bytes32 hashedChainId = keccak256(bytes.concat(bytes32(_l2ChainId)));
        bytes19 first19Bytes = bytes19(hashedChainId);
        return address(uint160(bytes20(bytes.concat(versionByte, first19Bytes))));
    }

    /// @notice Helper method for computing a salt that's used in CREATE2 deployments.
    /// Including the contract name ensures that the resultant address from CREATE2 is unique
    /// across our smart contract system. For example, we deploy multiple proxy contracts
    /// with the same bytecode from this contract, so they each require a unique salt for determinism.
    function computeSalt(
        uint256 _l2ChainId,
        string memory _saltMixer,
        string memory _contractName
    )
        internal
        pure
        returns (bytes32)
    {
        return keccak256(abi.encode(_l2ChainId, _saltMixer, _contractName));
    }

    /// @notice Helper method for computing a reusable salt mixer
    /// This method should be used as the salt mixer when deploying contracts when there is no user
    /// provided salt mixer. This protects against a situation where multiple chains with the same
    /// L2 chain ID exist, which would otherwise result in address collisions.
    function reusableSaltMixer(OPContractsManager.OpChainConfig memory _opChainConfig)
        internal
        pure
        returns (string memory)
    {
        return string(bytes.concat(bytes32(uint256(uint160(address(_opChainConfig.systemConfigProxy))))));
    }

    /// @notice Deterministically deploys a new proxy contract owned by the provided ProxyAdmin.
    /// The salt is computed as a function of the L2 chain ID, the salt mixer and the contract name.
    /// This is required because we deploy many identical proxies, so they each require a unique salt for determinism.
    function deployProxy(
        uint256 _l2ChainId,
        IProxyAdmin _proxyAdmin,
        string memory _saltMixer,
        string memory _contractName
    )
        internal
        returns (address)
    {
        bytes32 salt = computeSalt(_l2ChainId, _saltMixer, _contractName);
        return Blueprint.deployFrom(getBlueprints().proxy, salt, abi.encode(_proxyAdmin));
    }

    /// @notice Makes an internal call to the target to initialize the proxy with the specified data.
    /// First performs safety checks to ensure the target, implementation, and proxy admin are valid.
    function upgradeToAndCall(
        IProxyAdmin _proxyAdmin,
        address _target,
        address _implementation,
        bytes memory _data
    )
        internal
    {
        assertValidContractAddress(_implementation);

        _proxyAdmin.upgradeAndCall(payable(address(_target)), _implementation, _data);
    }

    function assertValidContractAddress(address _who) public view {
        if (_who.code.length == 0) revert OPContractsManager.AddressHasNoCode(_who);
    }

    function encodePermissionlessFDGConstructor(IFaultDisputeGame.GameConstructorParams memory _params)
        internal
        view
        virtual
        returns (bytes memory)
    {
        bytes memory dataWithSelector = abi.encodeCall(IFaultDisputeGame.__constructor__, (_params));
        return Bytes.slice(dataWithSelector, 4);
    }

    function encodePermissionedFDGConstructor(
        IFaultDisputeGame.GameConstructorParams memory _params,
        address _proposer,
        address _challenger
    )
        internal
        view
        virtual
        returns (bytes memory)
    {
        bytes memory dataWithSelector =
            abi.encodeCall(IPermissionedDisputeGame.__constructor__, (_params, _proposer, _challenger));
        return Bytes.slice(dataWithSelector, 4);
    }

    /// @notice Returns the implementation contract address for a given game type.
    function getGameImplementation(
        IDisputeGameFactory _disputeGameFactory,
        GameType _gameType
    )
        internal
        view
        returns (IDisputeGame)
    {
        return _disputeGameFactory.gameImpls(_gameType);
    }

    /// @notice Retrieves the Anchor State Registry for a given game
    function getAnchorStateRegistry(IFaultDisputeGame _disputeGame) internal view returns (IAnchorStateRegistry) {
        return _disputeGame.anchorStateRegistry();
    }

    /// @notice Retrieves the L2 chain ID for a given game
    function getL2ChainId(IFaultDisputeGame _disputeGame) internal view returns (uint256) {
        return _disputeGame.l2ChainId();
    }

    /// @notice Retrieves the proposer address for a given game
    function getProposer(IPermissionedDisputeGame _disputeGame) internal view returns (address) {
        return _disputeGame.proposer();
    }

    /// @notice Retrieves the challenger address for a given game
    function getChallenger(IPermissionedDisputeGame _disputeGame) internal view returns (address) {
        return _disputeGame.challenger();
    }

    /// @notice Retrieves the DisputeGameFactory address for a given SystemConfig
    function getDisputeGameFactory(ISystemConfig _systemConfig) internal view returns (IDisputeGameFactory) {
        return IDisputeGameFactory(_systemConfig.disputeGameFactory());
    }

    /// @notice Retrieves the constructor params for a given game.
    function getGameConstructorParams(IFaultDisputeGame _disputeGame)
        internal
        view
        returns (IFaultDisputeGame.GameConstructorParams memory)
    {
        IFaultDisputeGame.GameConstructorParams memory params = IFaultDisputeGame.GameConstructorParams({
            gameType: _disputeGame.gameType(),
            absolutePrestate: _disputeGame.absolutePrestate(),
            maxGameDepth: _disputeGame.maxGameDepth(),
            splitDepth: _disputeGame.splitDepth(),
            clockExtension: _disputeGame.clockExtension(),
            maxClockDuration: _disputeGame.maxClockDuration(),
            vm: _disputeGame.vm(),
            weth: getWETH(_disputeGame),
            anchorStateRegistry: getAnchorStateRegistry(_disputeGame),
            l2ChainId: getL2ChainId(_disputeGame)
        });
        return params;
    }

    /// @notice Retrieves the DelayedWETH address for a given game
    function getWETH(IFaultDisputeGame _disputeGame) internal view returns (IDelayedWETH) {
        return _disputeGame.weth();
    }

    /// @notice Sets a game implementation on the dispute game factory
    function setDGFImplementation(IDisputeGameFactory _dgf, GameType _gameType, IDisputeGame _newGame) internal {
        _dgf.setImplementation(_gameType, _newGame);
    }
}

contract OPContractsManagerGameTypeAdder is OPContractsManagerBase {
    /// @notice Emitted when a new game type is added to a chain
    /// @param l2ChainId Chain ID of the chain
    /// @param gameType Type of the game being
    /// @param newDisputeGame Address of the deployed dispute game
    /// @param oldDisputeGame Address of the old dispute game
    event GameTypeAdded(
        uint256 indexed l2ChainId, GameType indexed gameType, IDisputeGame newDisputeGame, IDisputeGame oldDisputeGame
    );

    /// @notice Constructor to initialize the immutable thisOPCM variable and contract addresses
    /// @param _contractsContainer The blueprint contract addresses and implementation contract addresses
    constructor(OPContractsManagerContractsContainer _contractsContainer) OPContractsManagerBase(_contractsContainer) { }

    /// @notice addGameType deploys a new dispute game and links it to the DisputeGameFactory. The inputted _gameConfigs
    /// must be added in ascending GameType order.
    function addGameType(
        OPContractsManager.AddGameInput[] memory _gameConfigs,
        ISuperchainConfig _superchainConfig
    )
        public
        virtual
        returns (OPContractsManager.AddGameOutput[] memory)
    {
        if (_gameConfigs.length == 0) revert OPContractsManager.InvalidGameConfigs();

        OPContractsManager.AddGameOutput[] memory outputs = new OPContractsManager.AddGameOutput[](_gameConfigs.length);
        OPContractsManager.Blueprints memory bps = getBlueprints();

        // Store last game config as an int256 so that we can ensure that the same game config is not added twice.
        // Using int256 generates cheaper, simpler bytecode.
        int256 lastGameConfig = -1;

        for (uint256 i = 0; i < _gameConfigs.length; i++) {
            OPContractsManager.AddGameInput memory gameConfig = _gameConfigs[i];

            // This conversion is safe because the GameType is a uint32, which will always fit in an int256.
            int256 gameTypeInt = int256(uint256(gameConfig.disputeGameType.raw()));

            // Ensure that the game configs are added in ascending order, and not duplicated.
            if (lastGameConfig >= gameTypeInt) revert OPContractsManager.InvalidGameConfigs();
            lastGameConfig = gameTypeInt;

            // Grab the permissioned and fault dispute games from the SystemConfig.
            // We keep the FDG type as it reduces casting below.
            IFaultDisputeGame pdg = IFaultDisputeGame(
                address(
                    getGameImplementation(getDisputeGameFactory(gameConfig.systemConfig), GameTypes.PERMISSIONED_CANNON)
                )
            );

            // Pull out the chain ID.
            uint256 l2ChainId = getL2ChainId(pdg);

            // Deploy a new DelayedWETH proxy for this game if one hasn't already been specified. Leaving
            /// gameConfig.delayedWETH as the zero address will cause a new DelayedWETH to be deployed for this game.
            if (address(gameConfig.delayedWETH) == address(0)) {
                string memory contractName = string.concat(
                    "DelayedWETH-",
                    // This is a safe cast because GameType is a uint256 under the hood and no operation has been done
                    // on it at this point
                    Strings.toString(uint256(gameTypeInt))
                );
                outputs[i].delayedWETH = IDelayedWETH(
                    payable(deployProxy(l2ChainId, gameConfig.proxyAdmin, gameConfig.saltMixer, contractName))
                );

                // Initialize the proxy.
                upgradeToAndCall(
                    gameConfig.proxyAdmin,
                    address(outputs[i].delayedWETH),
                    getImplementations().delayedWETHImpl,
                    abi.encodeCall(IDelayedWETH.initialize, (gameConfig.proxyAdmin.owner(), _superchainConfig))
                );
            } else {
                outputs[i].delayedWETH = gameConfig.delayedWETH;
            }

            // The FDG is only used for the event below, and only if it is being replaced,
            // so we declare it here, but only assign it below if needed.
            IFaultDisputeGame fdg;

            // The below sections are functionally the same. Both deploy a new dispute game. The dispute game type is
            // either permissioned or permissionless depending on game config.
            if (gameConfig.permissioned) {
                outputs[i].faultDisputeGame = IFaultDisputeGame(
                    Blueprint.deployFrom(
                        bps.permissionedDisputeGame1,
                        bps.permissionedDisputeGame2,
                        computeSalt(l2ChainId, gameConfig.saltMixer, "PermissionedDisputeGame"),
                        encodePermissionedFDGConstructor(
                            IFaultDisputeGame.GameConstructorParams(
                                gameConfig.disputeGameType,
                                gameConfig.disputeAbsolutePrestate,
                                gameConfig.disputeMaxGameDepth,
                                gameConfig.disputeSplitDepth,
                                gameConfig.disputeClockExtension,
                                gameConfig.disputeMaxClockDuration,
                                gameConfig.vm,
                                outputs[i].delayedWETH,
                                getAnchorStateRegistry(pdg),
                                l2ChainId
                            ),
                            getProposer(IPermissionedDisputeGame(address(pdg))),
                            getChallenger(IPermissionedDisputeGame(address(pdg)))
                        )
                    )
                );
            } else {
                fdg = IFaultDisputeGame(
                    address(getGameImplementation(getDisputeGameFactory(gameConfig.systemConfig), GameTypes.CANNON))
                );
                outputs[i].faultDisputeGame = IFaultDisputeGame(
                    Blueprint.deployFrom(
                        bps.permissionlessDisputeGame1,
                        bps.permissionlessDisputeGame2,
                        computeSalt(l2ChainId, gameConfig.saltMixer, "PermissionlessDisputeGame"),
                        encodePermissionlessFDGConstructor(
                            IFaultDisputeGame.GameConstructorParams(
                                gameConfig.disputeGameType,
                                gameConfig.disputeAbsolutePrestate,
                                gameConfig.disputeMaxGameDepth,
                                gameConfig.disputeSplitDepth,
                                gameConfig.disputeClockExtension,
                                gameConfig.disputeMaxClockDuration,
                                gameConfig.vm,
                                outputs[i].delayedWETH,
                                // We can't assume that there is an existing fault dispute game,
                                // so get the Anchor State Registry from the permissioned game.
                                getAnchorStateRegistry(pdg),
                                l2ChainId
                            )
                        )
                    )
                );
            }

            // As a last step, register the new game type with the DisputeGameFactory. If the game type already exists,
            // then its implementation will be overwritten.
            IDisputeGameFactory dgf = getDisputeGameFactory(gameConfig.systemConfig);
            setDGFImplementation(dgf, gameConfig.disputeGameType, IDisputeGame(address(outputs[i].faultDisputeGame)));
            dgf.setInitBond(gameConfig.disputeGameType, gameConfig.initialBond);

            if (gameConfig.permissioned) {
                // Emit event for the newly added game type with the old permissioned dispute game
                emit GameTypeAdded(
                    l2ChainId, gameConfig.disputeGameType, outputs[i].faultDisputeGame, IDisputeGame(address(pdg))
                );
            } else {
                // Emit event for the newly added game type with the old fault dispute game
                emit GameTypeAdded(
                    l2ChainId, gameConfig.disputeGameType, outputs[i].faultDisputeGame, IDisputeGame(address(fdg))
                );
            }
        }

        return outputs;
    }

    /// @notice Updates the prestate hash for a new game type while keeping all other parameters the same
    /// @param _prestateUpdateInputs The new prestate hash to use
    function updatePrestate(
        OPContractsManager.OpChainConfig[] memory _prestateUpdateInputs,
        ISuperchainConfig _superchainConfig
    )
        public
    {
        // Loop through each chain and prestate hash
        for (uint256 i = 0; i < _prestateUpdateInputs.length; i++) {
            if (Claim.unwrap(_prestateUpdateInputs[i].absolutePrestate) == bytes32(0)) {
                revert OPContractsManager.PrestateRequired();
            }

            // Get the DisputeGameFactory and existing game implementations
            IDisputeGameFactory dgf =
                IDisputeGameFactory(_prestateUpdateInputs[i].systemConfigProxy.disputeGameFactory());
            IFaultDisputeGame fdg = IFaultDisputeGame(address(getGameImplementation(dgf, GameTypes.CANNON)));
            IPermissionedDisputeGame pdg =
                IPermissionedDisputeGame(address(getGameImplementation(dgf, GameTypes.PERMISSIONED_CANNON)));

            // All chains must have a permissioned game, but not all chains must have a fault dispute game.
            // Whether a chain has a fault dispute game determines how many AddGameInput objects are needed.
            bool hasFDG = address(fdg) != address(0);

            OPContractsManager.AddGameInput[] memory inputs = new OPContractsManager.AddGameInput[](hasFDG ? 2 : 1);
            OPContractsManager.AddGameInput memory pdgInput;
            OPContractsManager.AddGameInput memory fdgInput;

            // Get the existing game parameters and init bond for the permissioned game
            IFaultDisputeGame.GameConstructorParams memory pdgParams =
                getGameConstructorParams(IFaultDisputeGame(address(pdg)));
            uint256 initBond = dgf.initBonds(GameTypes.PERMISSIONED_CANNON);

            string memory saltMixer = reusableSaltMixer(_prestateUpdateInputs[i]);
            // Create game input with updated prestate but same other params
            pdgInput = OPContractsManager.AddGameInput({
                disputeAbsolutePrestate: _prestateUpdateInputs[i].absolutePrestate,
                saltMixer: saltMixer,
                systemConfig: _prestateUpdateInputs[i].systemConfigProxy,
                proxyAdmin: _prestateUpdateInputs[i].proxyAdmin,
                delayedWETH: IDelayedWETH(payable(address(pdgParams.weth))),
                disputeGameType: pdgParams.gameType,
                disputeMaxGameDepth: pdgParams.maxGameDepth,
                disputeSplitDepth: pdgParams.splitDepth,
                disputeClockExtension: pdgParams.clockExtension,
                disputeMaxClockDuration: pdgParams.maxClockDuration,
                initialBond: initBond,
                vm: pdgParams.vm,
                permissioned: true
            });

            // If a fault dispute game exists, create a new game with the same parameters but updated prestate.
            if (hasFDG) {
                // Get the existing game parameters and init bond for the fault dispute game
                IFaultDisputeGame.GameConstructorParams memory fdgParams =
                    getGameConstructorParams(IFaultDisputeGame(address(fdg)));
                initBond = dgf.initBonds(GameTypes.CANNON);

                // Create game input with updated prestate but same other params
                fdgInput = OPContractsManager.AddGameInput({
                    disputeAbsolutePrestate: _prestateUpdateInputs[i].absolutePrestate,
                    saltMixer: saltMixer,
                    systemConfig: _prestateUpdateInputs[i].systemConfigProxy,
                    proxyAdmin: _prestateUpdateInputs[i].proxyAdmin,
                    delayedWETH: IDelayedWETH(payable(address(fdgParams.weth))),
                    disputeGameType: fdgParams.gameType,
                    disputeMaxGameDepth: fdgParams.maxGameDepth,
                    disputeSplitDepth: fdgParams.splitDepth,
                    disputeClockExtension: fdgParams.clockExtension,
                    disputeMaxClockDuration: fdgParams.maxClockDuration,
                    initialBond: initBond,
                    vm: fdgParams.vm,
                    permissioned: false
                });
            }

            // Game inputs must be ordered with increasing game type values. So FDG is first if it exists.
            if (hasFDG) {
                inputs[0] = fdgInput;
                inputs[1] = pdgInput;
            } else {
                inputs[0] = pdgInput;
            }
            // Add the new game type with updated prestate
            addGameType(inputs, _superchainConfig);
        }
    }
}

contract OPContractsManagerUpgrader is OPContractsManagerBase {
    struct UpgradeInput {
        ISuperchainConfig superchainConfig;
        IProtocolVersions protocolVersions;
        IProxyAdmin superchainProxyAdmin;
    }

    /// @notice Emitted when a chain is upgraded
    /// @param systemConfig Address of the chain's SystemConfig contract
    /// @param upgrader Address that initiated the upgrade
    event Upgraded(uint256 indexed l2ChainId, ISystemConfig indexed systemConfig, address indexed upgrader);

    constructor(OPContractsManagerContractsContainer _contractsContainer) OPContractsManagerBase(_contractsContainer) { }

    /// @notice Upgrades a set of chains to the latest implementation contracts
    /// @param _opChainConfigs Array of OpChain structs, one per chain to upgrade
    /// @dev This function is intended to be called via DELEGATECALL from the Upgrade Controller Safe
    function upgrade(OPContractsManager.OpChainConfig[] memory _opChainConfigs) external virtual {
        OPContractsManager.Implementations memory impls = getImplementations();

        for (uint256 i = 0; i < _opChainConfigs.length; i++) {
            assertValidOpChainConfig(_opChainConfigs[i]);

            // Use the SystemConfig to grab the DisputeGameFactory address.
            IDisputeGameFactory dgf = IDisputeGameFactory(_opChainConfigs[i].systemConfigProxy.disputeGameFactory());

            // All chains have the PermissionedDisputeGame, grab that.
            IPermissionedDisputeGame permissionedDisputeGame =
                IPermissionedDisputeGame(address(getGameImplementation(dgf, GameTypes.PERMISSIONED_CANNON)));

            // Grab the L2 chain ID from the PermissionedDisputeGame.
            uint256 l2ChainId = getL2ChainId(IFaultDisputeGame(address(permissionedDisputeGame)));

            // Start by upgrading the SystemConfig contract to have the l2ChainId.
            upgradeToAndCall(
                _opChainConfigs[i].proxyAdmin,
                address(_opChainConfigs[i].systemConfigProxy),
                impls.systemConfigImpl,
                abi.encodeCall(ISystemConfig.upgrade, (l2ChainId))
            );

            // Grab chain addresses here. We need to do this after the SystemConfig upgrade or the
            // addresses will be incorrect.
            ISystemConfig.Addresses memory opChainAddrs = _opChainConfigs[i].systemConfigProxy.getAddresses();

            // Grab the current respectedGameType from the OptimismPortal contract before the upgrade.
            GameType respectedGameType = IOptimismPortal(payable(opChainAddrs.optimismPortal)).respectedGameType();

            // Grab the current SuperchainConfig from the OptimismPortal contract before the upgrade.
            ISuperchainConfig superchainConfig =
                IOptimismPortal(payable(opChainAddrs.optimismPortal)).superchainConfig();

            // Separate context to avoid stack too deep.
            IAnchorStateRegistry newAnchorStateRegistryProxy;
            {
                // Deploy a new AnchorStateRegistry contract.
                // We use the SOT suffix to avoid CREATE2 conflicts with the existing ASR.
                newAnchorStateRegistryProxy = IAnchorStateRegistry(
                    deployProxy({
                        _l2ChainId: l2ChainId,
                        _proxyAdmin: _opChainConfigs[i].proxyAdmin,
                        _saltMixer: reusableSaltMixer(_opChainConfigs[i]),
                        _contractName: "AnchorStateRegistry-SOT"
                    })
                );

                // Separate context to avoid stack too deep.
                {
                    // Get the existing anchor root from the old AnchorStateRegistry contract.
                    // Get the AnchorStateRegistry from the PermissionedDisputeGame.
                    (Hash root, uint256 l2BlockNumber) = getAnchorStateRegistry(
                        IFaultDisputeGame(address(permissionedDisputeGame))
                    ).anchors(respectedGameType);

                    // Upgrade and initialize the AnchorStateRegistry contract.
                    // Since this is a net-new contract, we need to initialize it.
                    upgradeToAndCall(
                        _opChainConfigs[i].proxyAdmin,
                        address(newAnchorStateRegistryProxy),
                        impls.anchorStateRegistryImpl,
                        abi.encodeCall(
                            IAnchorStateRegistry.initialize,
                            (
                                superchainConfig,
                                dgf,
                                OutputRoot({ root: root, l2BlockNumber: l2BlockNumber }),
                                respectedGameType
                            )
                        )
                    );
                }
            }

            // Upgrade the OptimismPortal contract implementation.
            upgradeTo(_opChainConfigs[i].proxyAdmin, opChainAddrs.optimismPortal, impls.optimismPortalImpl);

            // Separate context to avoid stack too deep.
            {
                // Deploy the ETHLockbox proxy.
                IETHLockbox ethLockbox;
                {
                    ethLockbox = IETHLockbox(
                        deployProxy({
                            _l2ChainId: l2ChainId,
                            _proxyAdmin: _opChainConfigs[i].proxyAdmin,
                            _saltMixer: reusableSaltMixer(_opChainConfigs[i]),
                            _contractName: "ETHLockbox"
                        })
                    );

                    // Initialize the ETHLockbox setting the OptimismPortal as an authorized portal.
                    IOptimismPortal[] memory portals = new IOptimismPortal[](1);
                    portals[0] = IOptimismPortal(payable(opChainAddrs.optimismPortal));
                    upgradeToAndCall(
                        _opChainConfigs[i].proxyAdmin,
                        address(ethLockbox),
                        impls.ethLockboxImpl,
                        abi.encodeCall(IETHLockbox.initialize, (superchainConfig, portals))
                    );
                }

                // Call `upgrade` on the OptimismPortal contract.
                IOptimismPortal(payable(opChainAddrs.optimismPortal)).upgrade(newAnchorStateRegistryProxy, ethLockbox);
            }

            // We also need to redeploy the dispute games because the AnchorStateRegistry is new.
            // Separate context to avoid stack too deep.
            {
                // Deploy and set a new permissioned game to update its prestate.
                deployAndSetNewGameImpl({
                    _l2ChainId: l2ChainId,
                    _disputeGame: IDisputeGame(address(permissionedDisputeGame)),
                    _newAnchorStateRegistryProxy: newAnchorStateRegistryProxy,
                    _gameType: GameTypes.PERMISSIONED_CANNON,
                    _opChainConfig: _opChainConfigs[i]
                });
            }

            // Separate context to avoid stack too deep.
            {
                // Now retrieve the permissionless game.
                IFaultDisputeGame permissionlessDisputeGame =
                    IFaultDisputeGame(address(getGameImplementation(dgf, GameTypes.CANNON)));

                // If it exists, replace its implementation.
                if (address(permissionlessDisputeGame) != address(0)) {
                    // Deploy and set a new permissionless game to update its prestate
                    deployAndSetNewGameImpl({
                        _l2ChainId: l2ChainId,
                        _disputeGame: IDisputeGame(address(permissionlessDisputeGame)),
                        _newAnchorStateRegistryProxy: newAnchorStateRegistryProxy,
                        _gameType: GameTypes.CANNON,
                        _opChainConfig: _opChainConfigs[i]
                    });
                }
            }

            // Emit the upgraded event with the address of the caller. Since this will be a delegatecall,
            // the caller will be the value of the ADDRESS opcode.
            emit Upgraded(l2ChainId, _opChainConfigs[i].systemConfigProxy, address(this));
        }
    }

    /// @notice Retrieves the Superchain Config for a bridge contract
    function getSuperchainConfig(address _hasSuperchainConfig) internal view returns (ISuperchainConfig) {
        return IHasSuperchainConfig(_hasSuperchainConfig).superchainConfig();
    }

    /// @notice Updates the implementation of a proxy without calling the initializer.
    /// First performs safety checks to ensure the target, implementation, and proxy admin are valid.
    function upgradeTo(IProxyAdmin _proxyAdmin, address _target, address _implementation) internal {
        assertValidContractAddress(_implementation);

        _proxyAdmin.upgrade(payable(address(_target)), _implementation);
    }

    /// @notice Verifies that all OpChainConfig inputs are valid and reverts if any are invalid.
    function assertValidOpChainConfig(OPContractsManager.OpChainConfig memory _config) internal view {
        assertValidContractAddress(address(_config.systemConfigProxy));
        assertValidContractAddress(address(_config.proxyAdmin));
    }

    /// @notice Deploys and sets a new dispute game implementation
    /// @param _l2ChainId The L2 chain ID
    /// @param _disputeGame The current dispute game implementation
    /// @param _newAnchorStateRegistryProxy The new anchor state registry proxy
    /// @param _gameType The type of game to deploy
    /// @param _opChainConfig The OP chain configuration
    function deployAndSetNewGameImpl(
        uint256 _l2ChainId,
        IDisputeGame _disputeGame,
        IAnchorStateRegistry _newAnchorStateRegistryProxy,
        GameType _gameType,
        OPContractsManager.OpChainConfig memory _opChainConfig
    )
        internal
    {
        OPContractsManager.Blueprints memory bps = getBlueprints();
        OPContractsManager.Implementations memory impls = getImplementations();

        // Get the constructor params for the game
        IFaultDisputeGame.GameConstructorParams memory params =
            getGameConstructorParams(IFaultDisputeGame(address(_disputeGame)));

        // Modify the params with the new vm values.
        params.anchorStateRegistry = IAnchorStateRegistry(address(_newAnchorStateRegistryProxy));
        params.vm = IBigStepper(impls.mipsImpl);

        // If the prestate is set in the config, use it. If not set, we'll try to use the prestate
        // that already exists on the current dispute game.
        if (Claim.unwrap(_opChainConfig.absolutePrestate) != bytes32(0)) {
            params.absolutePrestate = _opChainConfig.absolutePrestate;
        }

        // As a sanity check, if the prestate is zero here, revert.
        if (params.absolutePrestate.raw() == bytes32(0)) {
            revert OPContractsManager.PrestateNotSet();
        }

        IDisputeGame newGame;
        if (GameType.unwrap(_gameType) == GameType.unwrap(GameTypes.PERMISSIONED_CANNON)) {
            address proposer = getProposer(IPermissionedDisputeGame(address(_disputeGame)));
            address challenger = getChallenger(IPermissionedDisputeGame(address(_disputeGame)));
            newGame = IDisputeGame(
                Blueprint.deployFrom(
                    bps.permissionedDisputeGame1,
                    bps.permissionedDisputeGame2,
                    computeSalt(_l2ChainId, reusableSaltMixer(_opChainConfig), "PermissionedDisputeGame"),
                    encodePermissionedFDGConstructor(params, proposer, challenger)
                )
            );
        } else {
            newGame = IDisputeGame(
                Blueprint.deployFrom(
                    bps.permissionlessDisputeGame1,
                    bps.permissionlessDisputeGame2,
                    computeSalt(_l2ChainId, reusableSaltMixer(_opChainConfig), "PermissionlessDisputeGame"),
                    encodePermissionlessFDGConstructor(params)
                )
            );
        }

        // Grab the DisputeGameFactory from the SystemConfig.
        IDisputeGameFactory dgf = IDisputeGameFactory(_opChainConfig.systemConfigProxy.disputeGameFactory());

        // Set the new implementation.
        setDGFImplementation(dgf, _gameType, IDisputeGame(newGame));
    }
}

contract OPContractsManagerDeployer is OPContractsManagerBase {
    /// @notice Emitted when a new OP Stack chain is deployed.
    /// @param l2ChainId Chain ID of the new chain.
    /// @param deployer Address that deployed the chain.
    /// @param deployOutput ABI-encoded output of the deployment.
    event Deployed(uint256 indexed l2ChainId, address indexed deployer, bytes deployOutput);

    constructor(OPContractsManagerContractsContainer _contractsContainer) OPContractsManagerBase(_contractsContainer) { }

    function deploy(
        OPContractsManager.DeployInput calldata _input,
        ISuperchainConfig _superchainConfig,
        address _deployer
    )
        external
        virtual
        returns (OPContractsManager.DeployOutput memory)
    {
        assertValidInputs(_input);
        OPContractsManager.DeployOutput memory output;
        OPContractsManager.Blueprints memory blueprint = getBlueprints();
        OPContractsManager.Implementations memory implementation = getImplementations();

        // -------- Deploy Chain Singletons --------

        // The AddressManager is used to store the implementation for the L1CrossDomainMessenger
        // due to it's usage of the legacy ResolvedDelegateProxy.
        output.addressManager = IAddressManager(
            Blueprint.deployFrom(
                blueprint.addressManager,
                computeSalt(_input.l2ChainId, _input.saltMixer, "AddressManager"),
                abi.encode()
            )
        );
        // The ProxyAdmin is the owner of all proxies for the chain. We temporarily set the owner to
        // this contract, and then transfer ownership to the specified owner at the end of deployment.
        output.opChainProxyAdmin = IProxyAdmin(
            Blueprint.deployFrom(
                blueprint.proxyAdmin,
                computeSalt(_input.l2ChainId, _input.saltMixer, "ProxyAdmin"),
                abi.encode(address(this))
            )
        );
        // Set the AddressManager on the ProxyAdmin.
        output.opChainProxyAdmin.setAddressManager(output.addressManager);
        // Transfer ownership of the AddressManager to the ProxyAdmin.
        transferOwnership(address(output.addressManager), address(output.opChainProxyAdmin));

        // -------- Deploy Proxy Contracts --------

        // Deploy ERC-1967 proxied contracts.
        output.l1ERC721BridgeProxy =
            IL1ERC721Bridge(deployProxy(_input.l2ChainId, output.opChainProxyAdmin, _input.saltMixer, "L1ERC721Bridge"));
        output.optimismPortalProxy = IOptimismPortal(
            payable(deployProxy(_input.l2ChainId, output.opChainProxyAdmin, _input.saltMixer, "OptimismPortal"))
        );
        output.ethLockboxProxy =
            IETHLockbox(deployProxy(_input.l2ChainId, output.opChainProxyAdmin, _input.saltMixer, "ETHLockbox"));
        output.systemConfigProxy =
            ISystemConfig(deployProxy(_input.l2ChainId, output.opChainProxyAdmin, _input.saltMixer, "SystemConfig"));
        output.optimismMintableERC20FactoryProxy = IOptimismMintableERC20Factory(
            deployProxy(_input.l2ChainId, output.opChainProxyAdmin, _input.saltMixer, "OptimismMintableERC20Factory")
        );
        output.disputeGameFactoryProxy = IDisputeGameFactory(
            deployProxy(_input.l2ChainId, output.opChainProxyAdmin, _input.saltMixer, "DisputeGameFactory")
        );
        output.anchorStateRegistryProxy = IAnchorStateRegistry(
            deployProxy(_input.l2ChainId, output.opChainProxyAdmin, _input.saltMixer, "AnchorStateRegistry")
        );

        // Deploy legacy proxied contracts.
        output.l1StandardBridgeProxy = IL1StandardBridge(
            payable(
                Blueprint.deployFrom(
                    blueprint.l1ChugSplashProxy,
                    computeSalt(_input.l2ChainId, _input.saltMixer, "L1StandardBridge"),
                    abi.encode(output.opChainProxyAdmin)
                )
            )
        );
        output.opChainProxyAdmin.setProxyType(address(output.l1StandardBridgeProxy), IProxyAdmin.ProxyType.CHUGSPLASH);
        string memory contractName = "OVM_L1CrossDomainMessenger";
        output.l1CrossDomainMessengerProxy = IL1CrossDomainMessenger(
            Blueprint.deployFrom(
                blueprint.resolvedDelegateProxy,
                computeSalt(_input.l2ChainId, _input.saltMixer, "L1CrossDomainMessenger"),
                abi.encode(output.addressManager, contractName)
            )
        );
        output.opChainProxyAdmin.setProxyType(
            address(output.l1CrossDomainMessengerProxy), IProxyAdmin.ProxyType.RESOLVED
        );
        output.opChainProxyAdmin.setImplementationName(address(output.l1CrossDomainMessengerProxy), contractName);

        // Eventually we will switch from DelayedWETHPermissionedGameProxy to DelayedWETHPermissionlessGameProxy.
        output.delayedWETHPermissionedGameProxy = IDelayedWETH(
            payable(
                deployProxy(_input.l2ChainId, output.opChainProxyAdmin, _input.saltMixer, "DelayedWETHPermissionedGame")
            )
        );

        // While not a proxy, we deploy the PermissionedDisputeGame here as well because it's bespoke per chain.
        output.permissionedDisputeGame = IPermissionedDisputeGame(
            Blueprint.deployFrom(
                blueprint.permissionedDisputeGame1,
                blueprint.permissionedDisputeGame2,
                computeSalt(_input.l2ChainId, _input.saltMixer, "PermissionedDisputeGame"),
                encodePermissionedFDGConstructor(
                    IFaultDisputeGame.GameConstructorParams({
                        gameType: _input.disputeGameType,
                        absolutePrestate: _input.disputeAbsolutePrestate,
                        maxGameDepth: _input.disputeMaxGameDepth,
                        splitDepth: _input.disputeSplitDepth,
                        clockExtension: _input.disputeClockExtension,
                        maxClockDuration: _input.disputeMaxClockDuration,
                        vm: IBigStepper(implementation.mipsImpl),
                        weth: IDelayedWETH(payable(address(output.delayedWETHPermissionedGameProxy))),
                        anchorStateRegistry: IAnchorStateRegistry(address(output.anchorStateRegistryProxy)),
                        l2ChainId: _input.l2ChainId
                    }),
                    _input.roles.proposer,
                    _input.roles.challenger
                )
            )
        );

        // -------- Set and Initialize Proxy Implementations --------
        bytes memory data;

        data = encodeL1ERC721BridgeInitializer(output, _superchainConfig);
        upgradeToAndCall(
            output.opChainProxyAdmin, address(output.l1ERC721BridgeProxy), implementation.l1ERC721BridgeImpl, data
        );

        data = encodeOptimismPortalInitializer(output, _superchainConfig);
        upgradeToAndCall(
            output.opChainProxyAdmin, address(output.optimismPortalProxy), implementation.optimismPortalImpl, data
        );

        // Initialize the ETHLockbox.
        IOptimismPortal[] memory portals = new IOptimismPortal[](1);
        portals[0] = output.optimismPortalProxy;
        data = encodeETHLockboxInitializer(_superchainConfig, portals);
        upgradeToAndCall(output.opChainProxyAdmin, address(output.ethLockboxProxy), implementation.ethLockboxImpl, data);

        data = encodeSystemConfigInitializer(_input, output);
        upgradeToAndCall(
            output.opChainProxyAdmin, address(output.systemConfigProxy), implementation.systemConfigImpl, data
        );

        data = encodeOptimismMintableERC20FactoryInitializer(output);
        upgradeToAndCall(
            output.opChainProxyAdmin,
            address(output.optimismMintableERC20FactoryProxy),
            implementation.optimismMintableERC20FactoryImpl,
            data
        );

        data = encodeL1CrossDomainMessengerInitializer(output, _superchainConfig);
        upgradeToAndCall(
            output.opChainProxyAdmin,
            address(output.l1CrossDomainMessengerProxy),
            implementation.l1CrossDomainMessengerImpl,
            data
        );

        data = encodeL1StandardBridgeInitializer(output, _superchainConfig);
        upgradeToAndCall(
            output.opChainProxyAdmin, address(output.l1StandardBridgeProxy), implementation.l1StandardBridgeImpl, data
        );

        data = encodeDelayedWETHInitializer(_input, _superchainConfig);
        // Eventually we will switch from DelayedWETHPermissionedGameProxy to DelayedWETHPermissionlessGameProxy.
        upgradeToAndCall(
            output.opChainProxyAdmin,
            address(output.delayedWETHPermissionedGameProxy),
            implementation.delayedWETHImpl,
            data
        );

        // We set the initial owner to this contract, set game implementations, then transfer ownership.
        data = encodeDisputeGameFactoryInitializer();
        upgradeToAndCall(
            output.opChainProxyAdmin,
            address(output.disputeGameFactoryProxy),
            implementation.disputeGameFactoryImpl,
            data
        );
        setDGFImplementation(
            output.disputeGameFactoryProxy,
            GameTypes.PERMISSIONED_CANNON,
            IDisputeGame(address(output.permissionedDisputeGame))
        );

        transferOwnership(address(output.disputeGameFactoryProxy), address(_input.roles.opChainProxyAdminOwner));

        data = encodeAnchorStateRegistryInitializer(_input, _superchainConfig, output);
        upgradeToAndCall(
            output.opChainProxyAdmin,
            address(output.anchorStateRegistryProxy),
            implementation.anchorStateRegistryImpl,
            data
        );

        // -------- Finalize Deployment --------
        // Transfer ownership of the ProxyAdmin from this contract to the specified owner.
        transferOwnership(address(output.opChainProxyAdmin), _input.roles.opChainProxyAdminOwner);

        emit Deployed(_input.l2ChainId, _deployer, abi.encode(output));
        return output;
    }

    /// @notice Returns default, standard config arguments for the SystemConfig initializer.
    /// This is used by subclasses to reduce code duplication.
    function defaultSystemConfigParams(
        OPContractsManager.DeployInput memory, /* _input */
        OPContractsManager.DeployOutput memory _output
    )
        internal
        view
        virtual
        returns (IResourceMetering.ResourceConfig memory resourceConfig_, ISystemConfig.Addresses memory opChainAddrs_)
    {
        resourceConfig_ = Constants.DEFAULT_RESOURCE_CONFIG();

        opChainAddrs_ = ISystemConfig.Addresses({
            l1CrossDomainMessenger: address(_output.l1CrossDomainMessengerProxy),
            l1ERC721Bridge: address(_output.l1ERC721BridgeProxy),
            l1StandardBridge: address(_output.l1StandardBridgeProxy),
            optimismPortal: address(_output.optimismPortalProxy),
            optimismMintableERC20Factory: address(_output.optimismMintableERC20FactoryProxy)
        });

        assertValidContractAddress(opChainAddrs_.l1CrossDomainMessenger);
        assertValidContractAddress(opChainAddrs_.l1ERC721Bridge);
        assertValidContractAddress(opChainAddrs_.l1StandardBridge);
        assertValidContractAddress(opChainAddrs_.optimismPortal);
        assertValidContractAddress(opChainAddrs_.optimismMintableERC20Factory);
    }

    // -------- Utilities --------

    /// @notice Verifies that all inputs are valid and reverts if any are invalid.
    /// Typically the proxy admin owner is expected to have code, but this is not enforced here.
    function assertValidInputs(OPContractsManager.DeployInput calldata _input) internal view {
        if (_input.l2ChainId == 0 || _input.l2ChainId == block.chainid) revert OPContractsManager.InvalidChainId();

        if (_input.roles.opChainProxyAdminOwner == address(0)) {
            revert OPContractsManager.InvalidRoleAddress("opChainProxyAdminOwner");
        }
        if (_input.roles.systemConfigOwner == address(0)) {
            revert OPContractsManager.InvalidRoleAddress("systemConfigOwner");
        }
        if (_input.roles.batcher == address(0)) revert OPContractsManager.InvalidRoleAddress("batcher");
        if (_input.roles.unsafeBlockSigner == address(0)) {
            revert OPContractsManager.InvalidRoleAddress("unsafeBlockSigner");
        }
        if (_input.roles.proposer == address(0)) revert OPContractsManager.InvalidRoleAddress("proposer");
        if (_input.roles.challenger == address(0)) revert OPContractsManager.InvalidRoleAddress("challenger");

        if (_input.startingAnchorRoot.length == 0) revert OPContractsManager.InvalidStartingAnchorRoot();
        if (bytes32(_input.startingAnchorRoot) == bytes32(0)) revert OPContractsManager.InvalidStartingAnchorRoot();
    }

    /// @notice Transfers ownership
    function transferOwnership(address _target, address _newOwner) internal {
        // All transferOwnership targets have the same selector, so we just use IAddressManager
        IAddressManager(_target).transferOwnership(_newOwner);
    }

    // -------- Initializer Encoding --------

    /// @notice Helper method for encoding the L1ERC721Bridge initializer data.
    function encodeL1ERC721BridgeInitializer(
        OPContractsManager.DeployOutput memory _output,
        ISuperchainConfig _superchainConfig
    )
        internal
        view
        virtual
        returns (bytes memory)
    {
        return abi.encodeCall(IL1ERC721Bridge.initialize, (_output.l1CrossDomainMessengerProxy, _superchainConfig));
    }

    /// @notice Helper method for encoding the OptimismPortal initializer data.
    function encodeOptimismPortalInitializer(
        OPContractsManager.DeployOutput memory _output,
        ISuperchainConfig _superchainConfig
    )
        internal
        view
        virtual
        returns (bytes memory)
    {
        return abi.encodeCall(
            IOptimismPortal.initialize,
            (_output.systemConfigProxy, _superchainConfig, _output.anchorStateRegistryProxy, _output.ethLockboxProxy)
        );
    }

    /// @notice Helper method for encoding the ETHLockbox initializer data.
    function encodeETHLockboxInitializer(
        ISuperchainConfig _superchainConfig,
        IOptimismPortal[] memory _portals
    )
        internal
        view
        virtual
        returns (bytes memory)
    {
        return abi.encodeCall(IETHLockbox.initialize, (_superchainConfig, _portals));
    }

    /// @notice Helper method for encoding the SystemConfig initializer data.
    function encodeSystemConfigInitializer(
        OPContractsManager.DeployInput memory _input,
        OPContractsManager.DeployOutput memory _output
    )
        internal
        view
        virtual
        returns (bytes memory)
    {
        (IResourceMetering.ResourceConfig memory referenceResourceConfig, ISystemConfig.Addresses memory opChainAddrs) =
            defaultSystemConfigParams(_input, _output);

        return abi.encodeCall(
            ISystemConfig.initialize,
            (
                _input.roles.systemConfigOwner,
                _input.basefeeScalar,
                _input.blobBasefeeScalar,
                bytes32(uint256(uint160(_input.roles.batcher))), // batcherHash
                _input.gasLimit,
                _input.roles.unsafeBlockSigner,
                referenceResourceConfig,
                chainIdToBatchInboxAddress(_input.l2ChainId),
                opChainAddrs,
                _input.l2ChainId
            )
        );
    }

    /// @notice Helper method for encoding the OptimismMintableERC20Factory initializer data.
    function encodeOptimismMintableERC20FactoryInitializer(OPContractsManager.DeployOutput memory _output)
        internal
        pure
        virtual
        returns (bytes memory)
    {
        return abi.encodeCall(IOptimismMintableERC20Factory.initialize, (address(_output.l1StandardBridgeProxy)));
    }

    /// @notice Helper method for encoding the L1CrossDomainMessenger initializer data.
    function encodeL1CrossDomainMessengerInitializer(
        OPContractsManager.DeployOutput memory _output,
        ISuperchainConfig _superchainConfig
    )
        internal
        view
        virtual
        returns (bytes memory)
    {
        return abi.encodeCall(IL1CrossDomainMessenger.initialize, (_superchainConfig, _output.optimismPortalProxy));
    }

    /// @notice Helper method for encoding the L1StandardBridge initializer data.
    function encodeL1StandardBridgeInitializer(
        OPContractsManager.DeployOutput memory _output,
        ISuperchainConfig _superchainConfig
    )
        internal
        view
        virtual
        returns (bytes memory)
    {
        return abi.encodeCall(IL1StandardBridge.initialize, (_output.l1CrossDomainMessengerProxy, _superchainConfig));
    }

    function encodeDisputeGameFactoryInitializer() internal view virtual returns (bytes memory) {
        // This contract must be the initial owner so we can set game implementations, then
        // ownership is transferred after.
        return abi.encodeCall(IDisputeGameFactory.initialize, (address(this)));
    }

    function encodeAnchorStateRegistryInitializer(
        OPContractsManager.DeployInput memory _input,
        ISuperchainConfig _superchainConfig,
        OPContractsManager.DeployOutput memory _output
    )
        internal
        view
        virtual
        returns (bytes memory)
    {
        OutputRoot memory startingAnchorRoot = abi.decode(_input.startingAnchorRoot, (OutputRoot));
        return abi.encodeCall(
            IAnchorStateRegistry.initialize,
            (_superchainConfig, _output.disputeGameFactoryProxy, startingAnchorRoot, GameTypes.PERMISSIONED_CANNON)
        );
    }

    function encodeDelayedWETHInitializer(
        OPContractsManager.DeployInput memory _input,
        ISuperchainConfig _superchainConfig
    )
        internal
        view
        virtual
        returns (bytes memory)
    {
        return abi.encodeCall(IDelayedWETH.initialize, (_input.roles.opChainProxyAdminOwner, _superchainConfig));
    }
}

contract OPContractsManager is ISemver {
    // -------- Structs --------

    /// @notice Represents the roles that can be set when deploying a standard OP Stack chain.
    struct Roles {
        address opChainProxyAdminOwner;
        address systemConfigOwner;
        address batcher;
        address unsafeBlockSigner;
        address proposer;
        address challenger;
    }

    /// @notice The full set of inputs to deploy a new OP Stack chain.
    struct DeployInput {
        Roles roles;
        uint32 basefeeScalar;
        uint32 blobBasefeeScalar;
        uint256 l2ChainId;
        // The correct type is OutputRoot memory but OP Deployer does not yet support structs.
        bytes startingAnchorRoot;
        // The salt mixer is used as part of making the resulting salt unique.
        string saltMixer;
        uint64 gasLimit;
        // Configurable dispute game parameters.
        GameType disputeGameType;
        Claim disputeAbsolutePrestate;
        uint256 disputeMaxGameDepth;
        uint256 disputeSplitDepth;
        Duration disputeClockExtension;
        Duration disputeMaxClockDuration;
    }

    /// @notice The full set of outputs from deploying a new OP Stack chain.
    struct DeployOutput {
        IProxyAdmin opChainProxyAdmin;
        IAddressManager addressManager;
        IL1ERC721Bridge l1ERC721BridgeProxy;
        ISystemConfig systemConfigProxy;
        IOptimismMintableERC20Factory optimismMintableERC20FactoryProxy;
        IL1StandardBridge l1StandardBridgeProxy;
        IL1CrossDomainMessenger l1CrossDomainMessengerProxy;
        IETHLockbox ethLockboxProxy;
        // Fault proof contracts below.
        IOptimismPortal optimismPortalProxy;
        IDisputeGameFactory disputeGameFactoryProxy;
        IAnchorStateRegistry anchorStateRegistryProxy;
        IFaultDisputeGame faultDisputeGame;
        IPermissionedDisputeGame permissionedDisputeGame;
        IDelayedWETH delayedWETHPermissionedGameProxy;
        IDelayedWETH delayedWETHPermissionlessGameProxy;
    }

    /// @notice Addresses of ERC-5202 Blueprint contracts. There are used for deploying full size
    /// contracts, to reduce the code size of this factory contract. If it deployed full contracts
    /// using the `new Proxy()` syntax, the code size would get large fast, since this contract would
    /// contain the bytecode of every contract it deploys. Therefore we instead use Blueprints to
    /// reduce the code size of this contract.
    struct Blueprints {
        address addressManager;
        address proxy;
        address proxyAdmin;
        address l1ChugSplashProxy;
        address resolvedDelegateProxy;
        address permissionedDisputeGame1;
        address permissionedDisputeGame2;
        address permissionlessDisputeGame1;
        address permissionlessDisputeGame2;
    }

    /// @notice The latest implementation contracts for the OP Stack.
    struct Implementations {
        address superchainConfigImpl;
        address protocolVersionsImpl;
        address l1ERC721BridgeImpl;
        address optimismPortalImpl;
        address ethLockboxImpl;
        address systemConfigImpl;
        address optimismMintableERC20FactoryImpl;
        address l1CrossDomainMessengerImpl;
        address l1StandardBridgeImpl;
        address disputeGameFactoryImpl;
        address anchorStateRegistryImpl;
        address delayedWETHImpl;
        address mipsImpl;
    }

    /// @notice The input required to identify a chain for upgrading, along with new prestate hashes
    struct OpChainConfig {
        ISystemConfig systemConfigProxy;
        IProxyAdmin proxyAdmin;
        Claim absolutePrestate;
    }

    struct AddGameInput {
        string saltMixer;
        ISystemConfig systemConfig;
        IProxyAdmin proxyAdmin;
        IDelayedWETH delayedWETH;
        GameType disputeGameType;
        Claim disputeAbsolutePrestate;
        uint256 disputeMaxGameDepth;
        uint256 disputeSplitDepth;
        Duration disputeClockExtension;
        Duration disputeMaxClockDuration;
        uint256 initialBond;
        IBigStepper vm;
        bool permissioned;
    }

    struct AddGameOutput {
        IDelayedWETH delayedWETH;
        IFaultDisputeGame faultDisputeGame;
    }

    // -------- Constants and Variables --------

    /// @custom:semver 1.12.0
    function version() public pure virtual returns (string memory) {
        return "1.12.0";
    }

    OPContractsManagerGameTypeAdder public immutable opcmGameTypeAdder;

    OPContractsManagerDeployer public immutable opcmDeployer;

    OPContractsManagerUpgrader public immutable opcmUpgrader;

    /// @notice Address of the SuperchainConfig contract shared by all chains.
    ISuperchainConfig public immutable superchainConfig;

    /// @notice Address of the ProtocolVersions contract shared by all chains.
    IProtocolVersions public immutable protocolVersions;

    /// @notice Address of the SuperchainProxyAdmin contract shared by all chains.
    IProxyAdmin public immutable superchainProxyAdmin;

    /// @notice L1 smart contracts release deployed by this version of OPCM. This is used in opcm to signal which
    /// version of the L1 smart contracts is deployed. It takes the format of `op-contracts/vX.Y.Z`.
    string internal L1_CONTRACTS_RELEASE;

    /// @notice The OPContractsManager contract that is currently being used. This is needed in the upgrade function
    /// which is intended to be DELEGATECALLed.
    OPContractsManager internal immutable thisOPCM;

    /// @notice The address of the upgrade controller.
    address public immutable upgradeController;

    /// @notice Whether this is a release candidate.
    bool public isRC = true;

    /// @notice Returns the release string. Appends "-rc" if this is a release candidate.
    function l1ContractsRelease() external view virtual returns (string memory) {
        return isRC ? string.concat(L1_CONTRACTS_RELEASE, "-rc") : L1_CONTRACTS_RELEASE;
    }

    // -------- Errors --------

    /// @notice Thrown when an address other than the upgrade controller calls the setRC function.
    error OnlyUpgradeController();

    /// @notice Thrown when an address is the zero address.
    error AddressNotFound(address who);

    /// @notice Throw when a contract address has no code.
    error AddressHasNoCode(address who);

    /// @notice Thrown when a release version is already set.
    error AlreadyReleased();

    /// @notice Thrown when an invalid `l2ChainId` is provided to `deploy`.
    error InvalidChainId();

    /// @notice Thrown when a role's address is not valid.
    error InvalidRoleAddress(string role);

    /// @notice Thrown when the latest release is not set upon initialization.
    error LatestReleaseNotSet();

    /// @notice Thrown when the starting anchor root is not provided.
    error InvalidStartingAnchorRoot();

    /// @notice Thrown when certain methods are called outside of a DELEGATECALL.
    error OnlyDelegatecall();

    /// @notice Thrown when game configs passed to addGameType are invalid.
    error InvalidGameConfigs();

    /// @notice Thrown when the SuperchainConfig of the chain does not match the SuperchainConfig of this OPCM.
    error SuperchainConfigMismatch(ISystemConfig systemConfig);

    /// @notice Thrown when the SuperchainProxyAdmin does not match the SuperchainConfig's admin.
    error SuperchainProxyAdminMismatch();

    /// @notice Thrown when a prestate is not set for a game.
    error PrestateNotSet();

    /// @notice Thrown when the prestate of a permissioned disputed game is 0.
    error PrestateRequired();

    // -------- Methods --------

    constructor(
        OPContractsManagerGameTypeAdder _opcmGameTypeAdder,
        OPContractsManagerDeployer _opcmDeployer,
        OPContractsManagerUpgrader _opcmUpgrader,
        ISuperchainConfig _superchainConfig,
        IProtocolVersions _protocolVersions,
        IProxyAdmin _superchainProxyAdmin,
        string memory _l1ContractsRelease,
        address _upgradeController
    ) {
        _opcmDeployer.assertValidContractAddress(address(_superchainConfig));
        _opcmDeployer.assertValidContractAddress(address(_protocolVersions));
        _opcmDeployer.assertValidContractAddress(address(_opcmGameTypeAdder));
        _opcmDeployer.assertValidContractAddress(address(_opcmDeployer));
        _opcmDeployer.assertValidContractAddress(address(_opcmUpgrader));
        opcmGameTypeAdder = _opcmGameTypeAdder;
        opcmDeployer = _opcmDeployer;
        opcmUpgrader = _opcmUpgrader;
        superchainConfig = _superchainConfig;
        protocolVersions = _protocolVersions;
        superchainProxyAdmin = _superchainProxyAdmin;
        L1_CONTRACTS_RELEASE = _l1ContractsRelease;
        thisOPCM = this;
        upgradeController = _upgradeController;
    }

    function deploy(DeployInput calldata _input) external virtual returns (DeployOutput memory) {
        return opcmDeployer.deploy(_input, superchainConfig, msg.sender);
    }

    /// @notice Upgrades a set of chains to the latest implementation contracts
    /// @param _opChainConfigs Array of OpChain structs, one per chain to upgrade
    /// @dev This function is intended to be called via DELEGATECALL from the Upgrade Controller Safe
    function upgrade(OpChainConfig[] memory _opChainConfigs) external virtual {
        if (address(this) == address(thisOPCM)) revert OnlyDelegatecall();

        // If this is delegatecalled by the upgrade controller, set isRC to false first, else, continue execution.
        if (address(this) == upgradeController) {
            // Set isRC to false.
            // This function asserts that the caller is the upgrade controller.
            thisOPCM.setRC(false);
        }

        bytes memory data = abi.encodeWithSelector(OPContractsManagerUpgrader.upgrade.selector, _opChainConfigs);
        _performDelegateCall(address(opcmUpgrader), data);
    }

    /// @notice addGameType deploys a new dispute game and links it to the DisputeGameFactory. The inputted _gameConfigs
    /// must be added in ascending GameType order.
    function addGameType(AddGameInput[] memory _gameConfigs) public virtual returns (AddGameOutput[] memory) {
        if (address(this) == address(thisOPCM)) revert OnlyDelegatecall();

        bytes memory data =
            abi.encodeWithSelector(OPContractsManagerGameTypeAdder.addGameType.selector, _gameConfigs, superchainConfig);

        bytes memory returnData = _performDelegateCall(address(opcmGameTypeAdder), data);
        return abi.decode(returnData, (AddGameOutput[]));
    }

    /// @notice Updates the prestate hash for a new game type while keeping all other parameters the same
    /// @param _prestateUpdateInputs The new prestate hash to use
    function updatePrestate(OpChainConfig[] memory _prestateUpdateInputs) public {
        bytes memory data = abi.encodeWithSelector(
            OPContractsManagerGameTypeAdder.updatePrestate.selector, _prestateUpdateInputs, superchainConfig
        );

        _performDelegateCall(address(opcmGameTypeAdder), data);
    }

    /// @notice Maps an L2 chain ID to an L1 batch inbox address as defined by the standard
    /// configuration's convention. This convention is `versionByte || keccak256(bytes32(chainId))[:19]`,
    /// where || denotes concatenation`, versionByte is 0x00, and chainId is a uint256.
    /// https://specs.optimism.io/protocol/configurability.html#consensus-parameters
    function chainIdToBatchInboxAddress(uint256 _l2ChainId) public view returns (address) {
        return opcmDeployer.chainIdToBatchInboxAddress(_l2ChainId);
    }

    /// @notice Returns the blueprint contract addresses.
    function blueprints() public view returns (Blueprints memory) {
        return opcmDeployer.blueprints();
    }

    /// @notice Returns the implementation contract addresses.
    function implementations() public view returns (Implementations memory) {
        return opcmDeployer.implementations();
    }

    /// @notice Sets the RC flag.
    function setRC(bool _isRC) external {
        if (msg.sender != upgradeController) revert OnlyUpgradeController();
        isRC = _isRC;
    }

    /// @notice Helper function to perform a delegatecall to a target contract
    /// @param _target The target contract address
    /// @param _data The calldata to send to the target
    /// @return bytes The return data from the delegatecall
    function _performDelegateCall(address _target, bytes memory _data) internal returns (bytes memory) {
        // Perform the delegatecall
        (bool success, bytes memory returnData) = _target.delegatecall(_data);

        // Check if the delegatecall was successful
        if (!success) {
            // If there was a revert message, bubble it up
            assembly {
                revert(add(returnData, 32), mload(returnData))
            }
        }

        return returnData;
    }
}