{
  "address": "0xb882dF3A3F4c680b82751Bf4F07542039de4e809",
  "abi": [
    {
      "inputs": [
        {
          "internalType": "address",
          "name": "owner",
          "type": "address"
        }
      ],
      "stateMutability": "nonpayable",
      "type": "constructor"
    },
    {
      "anonymous": false,
      "inputs": [
        {
          "indexed": true,
          "internalType": "address",
          "name": "user",
          "type": "address"
        },
        {
          "indexed": true,
          "internalType": "address",
          "name": "newOwner",
          "type": "address"
        }
      ],
      "name": "OwnerUpdated",
      "type": "event"
    },
    {
      "inputs": [],
      "name": "addressManager",
      "outputs": [
        {
          "internalType": "contract Lib_AddressManager",
          "name": "",
          "type": "address"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "contract Proxy",
          "name": "proxy",
          "type": "address"
        },
        {
          "internalType": "address",
          "name": "newAdmin",
          "type": "address"
        }
      ],
      "name": "changeProxyAdmin",
      "outputs": [],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "contract Proxy",
          "name": "proxy",
          "type": "address"
        }
      ],
      "name": "getProxyAdmin",
      "outputs": [
        {
          "internalType": "address",
          "name": "",
          "type": "address"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "contract Proxy",
          "name": "proxy",
          "type": "address"
        }
      ],
      "name": "getProxyImplementation",
      "outputs": [
        {
          "internalType": "address",
          "name": "",
          "type": "address"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "address",
          "name": "",
          "type": "address"
        }
      ],
      "name": "implementationName",
      "outputs": [
        {
          "internalType": "string",
          "name": "",
          "type": "string"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [],
      "name": "isUpgrading",
      "outputs": [
        {
          "internalType": "bool",
          "name": "",
          "type": "bool"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [],
      "name": "owner",
      "outputs": [
        {
          "internalType": "address",
          "name": "",
          "type": "address"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "address",
          "name": "",
          "type": "address"
        }
      ],
      "name": "proxyType",
      "outputs": [
        {
          "internalType": "enum ProxyAdmin.ProxyType",
          "name": "",
          "type": "uint8"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "string",
          "name": "_name",
          "type": "string"
        },
        {
          "internalType": "address",
          "name": "_address",
          "type": "address"
        }
      ],
      "name": "setAddress",
      "outputs": [],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "address",
          "name": "_address",
          "type": "address"
        }
      ],
      "name": "setAddressManager",
      "outputs": [],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "address",
          "name": "_address",
          "type": "address"
        },
        {
          "internalType": "string",
          "name": "_name",
          "type": "string"
        }
      ],
      "name": "setImplementationName",
      "outputs": [],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "address",
          "name": "newOwner",
          "type": "address"
        }
      ],
      "name": "setOwner",
      "outputs": [],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "address",
          "name": "_address",
          "type": "address"
        },
        {
          "internalType": "enum ProxyAdmin.ProxyType",
          "name": "_type",
          "type": "uint8"
        }
      ],
      "name": "setProxyType",
      "outputs": [],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "bool",
          "name": "_upgrading",
          "type": "bool"
        }
      ],
      "name": "setUpgrading",
      "outputs": [],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "contract Proxy",
          "name": "proxy",
          "type": "address"
        },
        {
          "internalType": "address",
          "name": "implementation",
          "type": "address"
        }
      ],
      "name": "upgrade",
      "outputs": [],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "contract Proxy",
          "name": "proxy",
          "type": "address"
        },
        {
          "internalType": "address",
          "name": "implementation",
          "type": "address"
        },
        {
          "internalType": "bytes",
          "name": "data",
          "type": "bytes"
        }
      ],
      "name": "upgradeAndCall",
      "outputs": [],
      "stateMutability": "payable",
      "type": "function"
    }
  ],
  "args": [
    "0x9C6373dE60c2D3297b18A8f964618ac46E011B58"
  ],
  "numDeployments": 1,
  "solcInputHash": "9bf33bb642648b258386a9c465b5d346",
  "metadata": "{\"compiler\":{\"version\":\"0.8.9+commit.e5eed63a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnerUpdated\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"addressManager\",\"outputs\":[{\"internalType\":\"contract Lib_AddressManager\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract Proxy\",\"name\":\"proxy\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"changeProxyAdmin\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract Proxy\",\"name\":\"proxy\",\"type\":\"address\"}],\"name\":\"getProxyAdmin\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract Proxy\",\"name\":\"proxy\",\"type\":\"address\"}],\"name\":\"getProxyImplementation\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"implementationName\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isUpgrading\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"proxyType\",\"outputs\":[{\"internalType\":\"enum ProxyAdmin.ProxyType\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"_name\",\"type\":\"string\"},{\"internalType\":\"address\",\"name\":\"_address\",\"type\":\"address\"}],\"name\":\"setAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_address\",\"type\":\"address\"}],\"name\":\"setAddressManager\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_address\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"_name\",\"type\":\"string\"}],\"name\":\"setImplementationName\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"setOwner\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_address\",\"type\":\"address\"},{\"internalType\":\"enum ProxyAdmin.ProxyType\",\"name\":\"_type\",\"type\":\"uint8\"}],\"name\":\"setProxyType\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"_upgrading\",\"type\":\"bool\"}],\"name\":\"setUpgrading\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract Proxy\",\"name\":\"proxy\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"upgrade\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract Proxy\",\"name\":\"proxy\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}],\"devdoc\":{\"details\":\"This is an auxiliary contract meant to be assigned as the admin of a Proxy, based on      the OpenZeppelin implementation. It has backwards compatibility logic to work with the      various types of proxies that have been deployed by Optimism.\",\"kind\":\"dev\",\"methods\":{\"changeProxyAdmin(address,address)\":{\"details\":\"Changes the admin of `proxy` to `newAdmin`. This contract must be the current admin      of `proxy`.\",\"params\":{\"newAdmin\":\"The address of the admin to update to.\",\"proxy\":\"The proxy that will have its admin updated.\"}},\"getProxyAdmin(address)\":{\"details\":\"Returns the current admin of `proxy`.      This contract must be the admin of `proxy`.\",\"params\":{\"proxy\":\"The Proxy to return the admin of.\"},\"returns\":{\"_0\":\"The address of the admin.\"}},\"getProxyImplementation(address)\":{\"details\":\"Returns the current implementation of `proxy`.      This contract must be the admin of `proxy`.\",\"params\":{\"proxy\":\"The Proxy to return the implementation of.\"},\"returns\":{\"_0\":\"The address of the implementation.\"}},\"isUpgrading()\":{\"custom:legacy\":\"@notice Legacy function used by the old Chugsplash proxy to determine if an upgrade is         happening.\",\"returns\":{\"_0\":\"Whether or not there is an upgrade going on\"}},\"setAddress(string,address)\":{\"custom:legacy\":\"@notice Set an address in the address manager. This is required because only the owner of         the AddressManager can set the addresses in it.\",\"params\":{\"_address\":\"The address to set in the address manager.\",\"_name\":\"The name of the address to set in the address manager.\"}},\"setAddressManager(address)\":{\"params\":{\"_address\":\"The address of the address manager.\"}},\"setImplementationName(address,string)\":{\"params\":{\"_address\":\"The address to be named.\",\"_name\":\"The name of the address.\"}},\"setProxyType(address,uint8)\":{\"params\":{\"_type\":\"The type of the proxy.\"}},\"setUpgrading(bool)\":{\"custom:legacy\":\"@notice Set the upgrading status for the Chugsplash proxy type.\",\"params\":{\"_upgrading\":\"Whether or not the system is upgrading.\"}},\"upgrade(address,address)\":{\"details\":\"Upgrades `proxy` to `implementation`. This contract must be the admin of `proxy`.\",\"params\":{\"implementation\":\"The address of the implementation.\",\"proxy\":\"The address of the proxy.\"}},\"upgradeAndCall(address,address,bytes)\":{\"details\":\"Upgrades `proxy` to `implementation` and calls a function on the new implementation.      This contract must be the admin of `proxy`.\",\"params\":{\"data\":\"The calldata to pass to the implementation.\",\"implementation\":\"The implementation to upgrade the proxy to.\",\"proxy\":\"The proxy to call.\"}}},\"stateVariables\":{\"addressManager\":{\"custom:legacy\":\"@notice The address of the address manager, this is required to manage the         Lib_ResolvedDelegateProxy type.\"},\"implementationName\":{\"custom:legacy\":\"@notice A reverse mapping of addresses to names held in the AddressManager. This must be         manually kept up to date with changes in the AddressManager for this contract         to be able to work as an admin for the Lib_ResolvedDelegateProxy type.\"},\"proxyType\":{\"custom:legacy\":\"@notice         A mapping of proxy types, used for backwards compatibility.\"},\"upgrading\":{\"custom:legacy\":\"@notice A legacy upgrading indicator used by the old Chugsplash Proxy.\"}},\"title\":\"ProxyAdmin\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"constructor\":{\"notice\":\"Set the owner of the ProxyAdmin via constructor argument.\"},\"setAddressManager(address)\":{\"notice\":\"Set the address of the address manager. This is required to manage the legacy         `Lib_ResolvedDelegateProxy`.\"},\"setImplementationName(address,string)\":{\"notice\":\"Set the proxy type in the mapping. This needs to be kept up to date by the owner of         the contract.\"},\"setProxyType(address,uint8)\":{\"notice\":\"@param _address   The address of the proxy.\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"@eth-optimism/contracts-bedrock/contracts/universal/ProxyAdmin.sol\":\"ProxyAdmin\"},\"evmVersion\":\"london\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":10000},\"remappings\":[]},\"sources\":{\"@eth-optimism/contracts-bedrock/contracts/legacy/L1ChugSplashProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\n/**\\n * @title iL1ChugSplashDeployer\\n */\\ninterface iL1ChugSplashDeployer {\\n    function isUpgrading() external view returns (bool);\\n}\\n\\n/**\\n * @title L1ChugSplashProxy\\n * @dev Basic ChugSplash proxy contract for L1. Very close to being a normal proxy but has added\\n * functions `setCode` and `setStorage` for changing the code or storage of the contract. Nifty!\\n *\\n * Note for future developers: do NOT make anything in this contract 'public' unless you know what\\n * you're doing. Anything public can potentially have a function signature that conflicts with a\\n * signature attached to the implementation contract. Public functions SHOULD always have the\\n * 'proxyCallIfNotOwner' modifier unless there's some *really* good reason not to have that\\n * modifier. And there almost certainly is not a good reason to not have that modifier. Beware!\\n */\\ncontract L1ChugSplashProxy {\\n    /*************\\n     * Constants *\\n     *************/\\n\\n    // \\\"Magic\\\" prefix. When prepended to some arbitrary bytecode and used to create a contract, the\\n    // appended bytecode will be deployed as given.\\n    bytes13 internal constant DEPLOY_CODE_PREFIX = 0x600D380380600D6000396000f3;\\n\\n    // bytes32(uint256(keccak256('eip1967.proxy.implementation')) - 1)\\n    bytes32 internal constant IMPLEMENTATION_KEY =\\n        0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n    // bytes32(uint256(keccak256('eip1967.proxy.admin')) - 1)\\n    bytes32 internal constant OWNER_KEY =\\n        0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\\n\\n    /***************\\n     * Constructor *\\n     ***************/\\n\\n    /**\\n     * @param _owner Address of the initial contract owner.\\n     */\\n    constructor(address _owner) {\\n        _setOwner(_owner);\\n    }\\n\\n    /**********************\\n     * Function Modifiers *\\n     **********************/\\n\\n    /**\\n     * Blocks a function from being called when the parent signals that the system should be paused\\n     * via an isUpgrading function.\\n     */\\n    modifier onlyWhenNotPaused() {\\n        address owner = _getOwner();\\n\\n        // We do a low-level call because there's no guarantee that the owner actually *is* an\\n        // L1ChugSplashDeployer contract and Solidity will throw errors if we do a normal call and\\n        // it turns out that it isn't the right type of contract.\\n        (bool success, bytes memory returndata) = owner.staticcall(\\n            abi.encodeWithSelector(iL1ChugSplashDeployer.isUpgrading.selector)\\n        );\\n\\n        // If the call was unsuccessful then we assume that there's no \\\"isUpgrading\\\" method and we\\n        // can just continue as normal. We also expect that the return value is exactly 32 bytes\\n        // long. If this isn't the case then we can safely ignore the result.\\n        if (success && returndata.length == 32) {\\n            // Although the expected value is a *boolean*, it's safer to decode as a uint256 in the\\n            // case that the isUpgrading function returned something other than 0 or 1. But we only\\n            // really care about the case where this value is 0 (= false).\\n            uint256 ret = abi.decode(returndata, (uint256));\\n            require(ret == 0, \\\"L1ChugSplashProxy: system is currently being upgraded\\\");\\n        }\\n\\n        _;\\n    }\\n\\n    /**\\n     * Makes a proxy call instead of triggering the given function when the caller is either the\\n     * owner or the zero address. Caller can only ever be the zero address if this function is\\n     * being called off-chain via eth_call, which is totally fine and can be convenient for\\n     * client-side tooling. Avoids situations where the proxy and implementation share a sighash\\n     * and the proxy function ends up being called instead of the implementation one.\\n     *\\n     * Note: msg.sender == address(0) can ONLY be triggered off-chain via eth_call. If there's a\\n     * way for someone to send a transaction with msg.sender == address(0) in any real context then\\n     * we have much bigger problems. Primary reason to include this additional allowed sender is\\n     * because the owner address can be changed dynamically and we do not want clients to have to\\n     * keep track of the current owner in order to make an eth_call that doesn't trigger the\\n     * proxied contract.\\n     */\\n    // slither-disable-next-line incorrect-modifier\\n    modifier proxyCallIfNotOwner() {\\n        if (msg.sender == _getOwner() || msg.sender == address(0)) {\\n            _;\\n        } else {\\n            // This WILL halt the call frame on completion.\\n            _doProxyCall();\\n        }\\n    }\\n\\n    /*********************\\n     * Fallback Function *\\n     *********************/\\n\\n    // slither-disable-next-line locked-ether\\n    fallback() external payable {\\n        // Proxy call by default.\\n        _doProxyCall();\\n    }\\n\\n    /********************\\n     * Public Functions *\\n     ********************/\\n\\n    /**\\n     * Sets the code that should be running behind this proxy. Note that this scheme is a bit\\n     * different from the standard proxy scheme where one would typically deploy the code\\n     * separately and then set the implementation address. We're doing it this way because it gives\\n     * us a lot more freedom on the client side. Can only be triggered by the contract owner.\\n     * @param _code New contract code to run inside this contract.\\n     */\\n    // slither-disable-next-line external-function\\n    function setCode(bytes memory _code) public proxyCallIfNotOwner {\\n        // Get the code hash of the current implementation.\\n        address implementation = _getImplementation();\\n\\n        // If the code hash matches the new implementation then we return early.\\n        if (keccak256(_code) == _getAccountCodeHash(implementation)) {\\n            return;\\n        }\\n\\n        // Create the deploycode by appending the magic prefix.\\n        bytes memory deploycode = abi.encodePacked(DEPLOY_CODE_PREFIX, _code);\\n\\n        // Deploy the code and set the new implementation address.\\n        address newImplementation;\\n        assembly {\\n            newImplementation := create(0x0, add(deploycode, 0x20), mload(deploycode))\\n        }\\n\\n        // Check that the code was actually deployed correctly. I'm not sure if you can ever\\n        // actually fail this check. Should only happen if the contract creation from above runs\\n        // out of gas but this parent execution thread does NOT run out of gas. Seems like we\\n        // should be doing this check anyway though.\\n        require(\\n            _getAccountCodeHash(newImplementation) == keccak256(_code),\\n            \\\"L1ChugSplashProxy: code was not correctly deployed.\\\"\\n        );\\n\\n        _setImplementation(newImplementation);\\n    }\\n\\n    /**\\n     * Modifies some storage slot within the proxy contract. Gives us a lot of power to perform\\n     * upgrades in a more transparent way. Only callable by the owner.\\n     * @param _key Storage key to modify.\\n     * @param _value New value for the storage key.\\n     */\\n    // slither-disable-next-line external-function\\n    function setStorage(bytes32 _key, bytes32 _value) public proxyCallIfNotOwner {\\n        assembly {\\n            sstore(_key, _value)\\n        }\\n    }\\n\\n    /**\\n     * Changes the owner of the proxy contract. Only callable by the owner.\\n     * @param _owner New owner of the proxy contract.\\n     */\\n    // slither-disable-next-line external-function\\n    function setOwner(address _owner) public proxyCallIfNotOwner {\\n        _setOwner(_owner);\\n    }\\n\\n    /**\\n     * Queries the owner of the proxy contract. Can only be called by the owner OR by making an\\n     * eth_call and setting the \\\"from\\\" address to address(0).\\n     * @return Owner address.\\n     */\\n    // slither-disable-next-line external-function\\n    function getOwner() public proxyCallIfNotOwner returns (address) {\\n        return _getOwner();\\n    }\\n\\n    /**\\n     * Queries the implementation address. Can only be called by the owner OR by making an\\n     * eth_call and setting the \\\"from\\\" address to address(0).\\n     * @return Implementation address.\\n     */\\n    // slither-disable-next-line external-function\\n    function getImplementation() public proxyCallIfNotOwner returns (address) {\\n        return _getImplementation();\\n    }\\n\\n    /**********************\\n     * Internal Functions *\\n     **********************/\\n\\n    /**\\n     * Sets the implementation address.\\n     * @param _implementation New implementation address.\\n     */\\n    function _setImplementation(address _implementation) internal {\\n        assembly {\\n            sstore(IMPLEMENTATION_KEY, _implementation)\\n        }\\n    }\\n\\n    /**\\n     * Queries the implementation address.\\n     * @return Implementation address.\\n     */\\n    function _getImplementation() internal view returns (address) {\\n        address implementation;\\n        assembly {\\n            implementation := sload(IMPLEMENTATION_KEY)\\n        }\\n        return implementation;\\n    }\\n\\n    /**\\n     * Changes the owner of the proxy contract.\\n     * @param _owner New owner of the proxy contract.\\n     */\\n    function _setOwner(address _owner) internal {\\n        assembly {\\n            sstore(OWNER_KEY, _owner)\\n        }\\n    }\\n\\n    /**\\n     * Queries the owner of the proxy contract.\\n     * @return Owner address.\\n     */\\n    function _getOwner() internal view returns (address) {\\n        address owner;\\n        assembly {\\n            owner := sload(OWNER_KEY)\\n        }\\n        return owner;\\n    }\\n\\n    /**\\n     * Gets the code hash for a given account.\\n     * @param _account Address of the account to get a code hash for.\\n     * @return Code hash for the account.\\n     */\\n    function _getAccountCodeHash(address _account) internal view returns (bytes32) {\\n        bytes32 codeHash;\\n        assembly {\\n            codeHash := extcodehash(_account)\\n        }\\n        return codeHash;\\n    }\\n\\n    /**\\n     * Performs the proxy call via a delegatecall.\\n     */\\n    function _doProxyCall() internal onlyWhenNotPaused {\\n        address implementation = _getImplementation();\\n\\n        require(implementation != address(0), \\\"L1ChugSplashProxy: implementation is not set yet\\\");\\n\\n        assembly {\\n            // Copy calldata into memory at 0x0....calldatasize.\\n            calldatacopy(0x0, 0x0, calldatasize())\\n\\n            // Perform the delegatecall, make sure to pass all available gas.\\n            let success := delegatecall(gas(), implementation, 0x0, calldatasize(), 0x0, 0x0)\\n\\n            // Copy returndata into memory at 0x0....returndatasize. Note that this *will*\\n            // overwrite the calldata that we just copied into memory but that doesn't really\\n            // matter because we'll be returning in a second anyway.\\n            returndatacopy(0x0, 0x0, returndatasize())\\n\\n            // Success == 0 means a revert. We'll revert too and pass the data up.\\n            if iszero(success) {\\n                revert(0x0, returndatasize())\\n            }\\n\\n            // Otherwise we'll just return and pass the data up.\\n            return(0x0, returndatasize())\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x2572b6e2282bcda28bd5fcb71c33bd40ace74b2786ea42e0604ecbb46aefff1f\",\"license\":\"MIT\"},\"@eth-optimism/contracts-bedrock/contracts/legacy/Lib_AddressManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\n/* External Imports */\\nimport { Ownable } from \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\n\\n/**\\n * @title Lib_AddressManager\\n */\\ncontract Lib_AddressManager is Ownable {\\n    /**********\\n     * Events *\\n     **********/\\n\\n    event AddressSet(string indexed _name, address _newAddress, address _oldAddress);\\n\\n    /*************\\n     * Variables *\\n     *************/\\n\\n    mapping(bytes32 => address) private addresses;\\n\\n    /********************\\n     * Public Functions *\\n     ********************/\\n\\n    /**\\n     * Changes the address associated with a particular name.\\n     * @param _name String name to associate an address with.\\n     * @param _address Address to associate with the name.\\n     */\\n    function setAddress(string memory _name, address _address) external onlyOwner {\\n        bytes32 nameHash = _getNameHash(_name);\\n        address oldAddress = addresses[nameHash];\\n        addresses[nameHash] = _address;\\n\\n        emit AddressSet(_name, _address, oldAddress);\\n    }\\n\\n    /**\\n     * Retrieves the address associated with a given name.\\n     * @param _name Name to retrieve an address for.\\n     * @return Address associated with the given name.\\n     */\\n    function getAddress(string memory _name) external view returns (address) {\\n        return addresses[_getNameHash(_name)];\\n    }\\n\\n    /**********************\\n     * Internal Functions *\\n     **********************/\\n\\n    /**\\n     * Computes the hash of a name.\\n     * @param _name Name to compute a hash for.\\n     * @return Hash of the given name.\\n     */\\n    function _getNameHash(string memory _name) internal pure returns (bytes32) {\\n        return keccak256(abi.encodePacked(_name));\\n    }\\n}\\n\",\"keccak256\":\"0xcde9b29429d512c549f7c1b8a033f161fa71c18cda08b241748663854196ae14\",\"license\":\"MIT\"},\"@eth-optimism/contracts-bedrock/contracts/universal/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\n/**\\n * @title Proxy\\n * @notice Proxy is a transparent proxy that passes through the call\\n *         if the caller is the owner or if the caller is `address(0)`,\\n *         meaning that the call originated from an offchain simulation.\\n */\\ncontract Proxy {\\n    /**\\n     * @notice An event that is emitted each time the implementation is changed.\\n     *         This event is part of the EIP 1967 spec.\\n     *\\n     * @param implementation The address of the implementation contract\\n     */\\n    event Upgraded(address indexed implementation);\\n\\n    /**\\n     * @notice An event that is emitted each time the owner is upgraded.\\n     *         This event is part of the EIP 1967 spec.\\n     *\\n     * @param previousAdmin The previous owner of the contract\\n     * @param newAdmin      The new owner of the contract\\n     */\\n    event AdminChanged(address previousAdmin, address newAdmin);\\n\\n    /**\\n     * @notice The storage slot that holds the address of the implementation.\\n     *         bytes32(uint256(keccak256('eip1967.proxy.implementation')) - 1)\\n     */\\n    bytes32 internal constant IMPLEMENTATION_KEY =\\n        0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n    /**\\n     * @notice The storage slot that holds the address of the owner.\\n     *         bytes32(uint256(keccak256('eip1967.proxy.admin')) - 1)\\n     */\\n    bytes32 internal constant OWNER_KEY =\\n        0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\\n\\n    /**\\n     * @notice set the initial owner during contract deployment. The\\n     *         owner is stored at the eip1967 owner storage slot so that\\n     *         storage collision with the implementation is not possible.\\n     *\\n     * @param _admin Address of the initial contract owner. The owner has\\n     *               the ability to access the transparent proxy interface.\\n     */\\n    constructor(address _admin) {\\n        _changeAdmin(_admin);\\n    }\\n\\n    // slither-disable-next-line locked-ether\\n    fallback() external payable {\\n        // Proxy call by default.\\n        _doProxyCall();\\n    }\\n\\n    /**\\n     * @notice A modifier that reverts if not called by the owner\\n     *         or by `address(0)` to allow `eth_call` to interact\\n     *         with the proxy without needing to use low level storage\\n     *         inspection. It is assumed that nobody controls the private\\n     *         key for `address(0)`.\\n     */\\n    modifier proxyCallIfNotAdmin() {\\n        if (msg.sender == _getAdmin() || msg.sender == address(0)) {\\n            _;\\n        } else {\\n            // This WILL halt the call frame on completion.\\n            _doProxyCall();\\n        }\\n    }\\n\\n    /**\\n     * @notice Set the implementation contract address. The code at this\\n     *         address will execute when this contract is called.\\n     *\\n     * @param _implementation The address of the implementation contract\\n     */\\n    function upgradeTo(address _implementation) external proxyCallIfNotAdmin {\\n        _setImplementation(_implementation);\\n    }\\n\\n    /**\\n     * @notice Set the implementation and call a function in a single\\n     *         transaction. This is useful to ensure atomic `initialize()`\\n     *         based upgrades.\\n     *\\n     * @param _implementation The address of the implementation contract\\n     * @param _data           The calldata to delegatecall the new\\n     *                        implementation with\\n     */\\n    function upgradeToAndCall(address _implementation, bytes calldata _data)\\n        external\\n        payable\\n        proxyCallIfNotAdmin\\n        returns (bytes memory)\\n    {\\n        _setImplementation(_implementation);\\n        (bool success, bytes memory returndata) = _implementation.delegatecall(_data);\\n        require(success);\\n        return returndata;\\n    }\\n\\n    /**\\n     * @notice Changes the owner of the proxy contract. Only callable by the owner.\\n     *\\n     * @param _admin New owner of the proxy contract.\\n     */\\n    function changeAdmin(address _admin) external proxyCallIfNotAdmin {\\n        _changeAdmin(_admin);\\n    }\\n\\n    /**\\n     * @notice Gets the owner of the proxy contract.\\n     *\\n     * @return Owner address.\\n     */\\n    function admin() external proxyCallIfNotAdmin returns (address) {\\n        return _getAdmin();\\n    }\\n\\n    /**\\n     * @notice Queries the implementation address.\\n     *\\n     * @return Implementation address.\\n     */\\n    function implementation() external proxyCallIfNotAdmin returns (address) {\\n        return _getImplementation();\\n    }\\n\\n    /**\\n     * @notice Sets the implementation address.\\n     *\\n     * @param _implementation New implementation address.\\n     */\\n    function _setImplementation(address _implementation) internal {\\n        assembly {\\n            sstore(IMPLEMENTATION_KEY, _implementation)\\n        }\\n        emit Upgraded(_implementation);\\n    }\\n\\n    /**\\n     * @notice Queries the implementation address.\\n     *\\n     * @return implementation address.\\n     */\\n    function _getImplementation() internal view returns (address) {\\n        address implementation;\\n        assembly {\\n            implementation := sload(IMPLEMENTATION_KEY)\\n        }\\n        return implementation;\\n    }\\n\\n    /**\\n     * @notice Changes the owner of the proxy contract.\\n     *\\n     * @param _admin New owner of the proxy contract.\\n     */\\n    function _changeAdmin(address _admin) internal {\\n        address previous = _getAdmin();\\n        assembly {\\n            sstore(OWNER_KEY, _admin)\\n        }\\n        emit AdminChanged(previous, _admin);\\n    }\\n\\n    /**\\n     * @notice Queries the owner of the proxy contract.\\n     *\\n     * @return owner address.\\n     */\\n    function _getAdmin() internal view returns (address) {\\n        address owner;\\n        assembly {\\n            owner := sload(OWNER_KEY)\\n        }\\n        return owner;\\n    }\\n\\n    /**\\n     * @notice Performs the proxy call via a delegatecall.\\n     */\\n    function _doProxyCall() internal {\\n        address implementation = _getImplementation();\\n\\n        require(implementation != address(0), \\\"Proxy: implementation not initialized\\\");\\n\\n        assembly {\\n            // Copy calldata into memory at 0x0....calldatasize.\\n            calldatacopy(0x0, 0x0, calldatasize())\\n\\n            // Perform the delegatecall, make sure to pass all available gas.\\n            let success := delegatecall(gas(), implementation, 0x0, calldatasize(), 0x0, 0x0)\\n\\n            // Copy returndata into memory at 0x0....returndatasize. Note that this *will*\\n            // overwrite the calldata that we just copied into memory but that doesn't really\\n            // matter because we'll be returning in a second anyway.\\n            returndatacopy(0x0, 0x0, returndatasize())\\n\\n            // Success == 0 means a revert. We'll revert too and pass the data up.\\n            if iszero(success) {\\n                revert(0x0, returndatasize())\\n            }\\n\\n            // Otherwise we'll just return and pass the data up.\\n            return(0x0, returndatasize())\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x2a6719fd9a11adf0efba0243e5c68d56b255296b84cc82bd39326c902e055077\",\"license\":\"MIT\"},\"@eth-optimism/contracts-bedrock/contracts/universal/ProxyAdmin.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\nimport { Proxy } from \\\"./Proxy.sol\\\";\\nimport { Owned } from \\\"@rari-capital/solmate/src/auth/Owned.sol\\\";\\nimport { Lib_AddressManager } from \\\"../legacy/Lib_AddressManager.sol\\\";\\nimport { L1ChugSplashProxy } from \\\"../legacy/L1ChugSplashProxy.sol\\\";\\n\\n/**\\n * @title ProxyAdmin\\n * @dev This is an auxiliary contract meant to be assigned as the admin of a Proxy, based on\\n *      the OpenZeppelin implementation. It has backwards compatibility logic to work with the\\n *      various types of proxies that have been deployed by Optimism.\\n */\\ncontract ProxyAdmin is Owned {\\n    /**\\n     * @notice The proxy types that the ProxyAdmin can manage.\\n     *\\n     * @custom:value OpenZeppelin     Represents the OpenZeppelin style transparent proxy\\n     *                                interface, this is the standard.\\n     * @custom:value Chugsplash       Represents the Chugsplash proxy interface,\\n     *                                this is legacy.\\n     * @custom:value ResolvedDelegate Represents the ResolvedDelegate proxy\\n     *                                interface, this is legacy.\\n     */\\n    enum ProxyType {\\n        OpenZeppelin,\\n        Chugsplash,\\n        ResolvedDelegate\\n    }\\n\\n    /**\\n     * @custom:legacy\\n     * @notice         A mapping of proxy types, used for backwards compatibility.\\n     */\\n    mapping(address => ProxyType) public proxyType;\\n\\n    /**\\n     * @custom:legacy\\n     * @notice A reverse mapping of addresses to names held in the AddressManager. This must be\\n     *         manually kept up to date with changes in the AddressManager for this contract\\n     *         to be able to work as an admin for the Lib_ResolvedDelegateProxy type.\\n     */\\n    mapping(address => string) public implementationName;\\n\\n    /**\\n     * @custom:legacy\\n     * @notice The address of the address manager, this is required to manage the\\n     *         Lib_ResolvedDelegateProxy type.\\n     */\\n    Lib_AddressManager public addressManager;\\n\\n    /**\\n     * @custom:legacy\\n     * @notice A legacy upgrading indicator used by the old Chugsplash Proxy.\\n     */\\n    bool internal upgrading = false;\\n\\n    /**\\n     * @notice Set the owner of the ProxyAdmin via constructor argument.\\n     */\\n    constructor(address owner) Owned(owner) {}\\n\\n    /**\\n     * @notice\\n     *\\n     * @param _address   The address of the proxy.\\n     * @param _type The type of the proxy.\\n     */\\n    function setProxyType(address _address, ProxyType _type) external onlyOwner {\\n        proxyType[_address] = _type;\\n    }\\n\\n    /**\\n     * @notice Set the proxy type in the mapping. This needs to be kept up to date by the owner of\\n     *         the contract.\\n     *\\n     * @param _address The address to be named.\\n     * @param _name    The name of the address.\\n     */\\n    function setImplementationName(address _address, string memory _name) external onlyOwner {\\n        implementationName[_address] = _name;\\n    }\\n\\n    /**\\n     * @notice Set the address of the address manager. This is required to manage the legacy\\n     *         `Lib_ResolvedDelegateProxy`.\\n     *\\n     * @param _address The address of the address manager.\\n     */\\n    function setAddressManager(address _address) external onlyOwner {\\n        addressManager = Lib_AddressManager(_address);\\n    }\\n\\n    /**\\n     * @custom:legacy\\n     * @notice Set an address in the address manager. This is required because only the owner of\\n     *         the AddressManager can set the addresses in it.\\n     *\\n     * @param _name    The name of the address to set in the address manager.\\n     * @param _address The address to set in the address manager.\\n     */\\n    function setAddress(string memory _name, address _address) external onlyOwner {\\n        addressManager.setAddress(_name, _address);\\n    }\\n\\n    /**\\n     * @custom:legacy\\n     * @notice Legacy function used by the old Chugsplash proxy to determine if an upgrade is\\n     *         happening.\\n     *\\n     * @return Whether or not there is an upgrade going on\\n     */\\n    function isUpgrading() external view returns (bool) {\\n        return upgrading;\\n    }\\n\\n    /**\\n     * @custom:legacy\\n     * @notice Set the upgrading status for the Chugsplash proxy type.\\n     *\\n     * @param _upgrading Whether or not the system is upgrading.\\n     */\\n    function setUpgrading(bool _upgrading) external onlyOwner {\\n        upgrading = _upgrading;\\n    }\\n\\n    /**\\n     * @dev Returns the current implementation of `proxy`.\\n     *      This contract must be the admin of `proxy`.\\n     *\\n     * @param proxy The Proxy to return the implementation of.\\n     * @return The address of the implementation.\\n     */\\n    function getProxyImplementation(Proxy proxy) external view returns (address) {\\n        ProxyType proxyType = proxyType[address(proxy)];\\n\\n        // We need to manually run the static call since the getter cannot be flagged as view\\n        address target;\\n        bytes memory data;\\n        if (proxyType == ProxyType.OpenZeppelin) {\\n            target = address(proxy);\\n            data = abi.encodeWithSelector(Proxy.implementation.selector);\\n        } else if (proxyType == ProxyType.Chugsplash) {\\n            target = address(proxy);\\n            data = abi.encodeWithSelector(L1ChugSplashProxy.getImplementation.selector);\\n        } else if (proxyType == ProxyType.ResolvedDelegate) {\\n            target = address(addressManager);\\n            data = abi.encodeWithSelector(\\n                Lib_AddressManager.getAddress.selector,\\n                implementationName[address(proxy)]\\n            );\\n        } else {\\n            revert(\\\"ProxyAdmin: unknown proxy type\\\");\\n        }\\n\\n        (bool success, bytes memory returndata) = target.staticcall(data);\\n        require(success);\\n        return abi.decode(returndata, (address));\\n    }\\n\\n    /**\\n     * @dev Returns the current admin of `proxy`.\\n     *      This contract must be the admin of `proxy`.\\n     *\\n     * @param proxy The Proxy to return the admin of.\\n     * @return The address of the admin.\\n     */\\n    function getProxyAdmin(Proxy proxy) external view returns (address) {\\n        ProxyType proxyType = proxyType[address(proxy)];\\n\\n        // We need to manually run the static call since the getter cannot be flagged as view\\n        address target;\\n        bytes memory data;\\n        if (proxyType == ProxyType.OpenZeppelin) {\\n            target = address(proxy);\\n            data = abi.encodeWithSelector(Proxy.admin.selector);\\n        } else if (proxyType == ProxyType.Chugsplash) {\\n            target = address(proxy);\\n            data = abi.encodeWithSelector(L1ChugSplashProxy.getOwner.selector);\\n        } else if (proxyType == ProxyType.ResolvedDelegate) {\\n            target = address(addressManager);\\n            data = abi.encodeWithSignature(\\\"owner()\\\");\\n        } else {\\n            revert(\\\"ProxyAdmin: unknown proxy type\\\");\\n        }\\n\\n        (bool success, bytes memory returndata) = target.staticcall(data);\\n        require(success);\\n        return abi.decode(returndata, (address));\\n    }\\n\\n    /**\\n     * @dev Changes the admin of `proxy` to `newAdmin`. This contract must be the current admin\\n     *      of `proxy`.\\n     *\\n     * @param proxy    The proxy that will have its admin updated.\\n     * @param newAdmin The address of the admin to update to.\\n     */\\n    function changeProxyAdmin(Proxy proxy, address newAdmin) external onlyOwner {\\n        ProxyType proxyType = proxyType[address(proxy)];\\n\\n        if (proxyType == ProxyType.OpenZeppelin) {\\n            proxy.changeAdmin(newAdmin);\\n        } else if (proxyType == ProxyType.Chugsplash) {\\n            L1ChugSplashProxy(payable(proxy)).setOwner(newAdmin);\\n        } else if (proxyType == ProxyType.ResolvedDelegate) {\\n            Lib_AddressManager(addressManager).transferOwnership(newAdmin);\\n        }\\n    }\\n\\n    /**\\n     * @dev Upgrades `proxy` to `implementation`. This contract must be the admin of `proxy`.\\n     *\\n     * @param proxy          The address of the proxy.\\n     * @param implementation The address of the implementation.\\n     */\\n    function upgrade(Proxy proxy, address implementation) public onlyOwner {\\n        ProxyType proxyType = proxyType[address(proxy)];\\n\\n        if (proxyType == ProxyType.OpenZeppelin) {\\n            proxy.upgradeTo(implementation);\\n        } else if (proxyType == ProxyType.Chugsplash) {\\n            L1ChugSplashProxy(payable(proxy)).setStorage(\\n                0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc,\\n                bytes32(uint256(uint160(implementation)))\\n            );\\n        } else if (proxyType == ProxyType.ResolvedDelegate) {\\n            string memory name = implementationName[address(proxy)];\\n            Lib_AddressManager(addressManager).setAddress(name, implementation);\\n        }\\n    }\\n\\n    /**\\n     * @dev Upgrades `proxy` to `implementation` and calls a function on the new implementation.\\n     *      This contract must be the admin of `proxy`.\\n     *\\n     * @param proxy           The proxy to call.\\n     * @param implementation  The implementation to upgrade the proxy to.\\n     * @param data            The calldata to pass to the implementation.\\n     */\\n    function upgradeAndCall(\\n        Proxy proxy,\\n        address implementation,\\n        bytes memory data\\n    ) external payable onlyOwner {\\n        ProxyType proxyType = proxyType[address(proxy)];\\n\\n        if (proxyType == ProxyType.OpenZeppelin) {\\n            proxy.upgradeToAndCall{ value: msg.value }(implementation, data);\\n        } else {\\n            upgrade(proxy, implementation);\\n            (bool success, ) = address(proxy).call{ value: msg.value }(data);\\n            require(success);\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xeae8f76ab92a48720d32a388c0564781cd93ee112e995b187b2bd984c37f9ec1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n    address private _owner;\\n\\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n    /**\\n     * @dev Initializes the contract setting the deployer as the initial owner.\\n     */\\n    constructor() {\\n        _transferOwnership(_msgSender());\\n    }\\n\\n    /**\\n     * @dev Returns the address of the current owner.\\n     */\\n    function owner() public view virtual returns (address) {\\n        return _owner;\\n    }\\n\\n    /**\\n     * @dev Throws if called by any account other than the owner.\\n     */\\n    modifier onlyOwner() {\\n        require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n        _;\\n    }\\n\\n    /**\\n     * @dev Leaves the contract without owner. It will not be possible to call\\n     * `onlyOwner` functions anymore. Can only be called by the current owner.\\n     *\\n     * NOTE: Renouncing ownership will leave the contract without an owner,\\n     * thereby removing any functionality that is only available to the owner.\\n     */\\n    function renounceOwnership() public virtual onlyOwner {\\n        _transferOwnership(address(0));\\n    }\\n\\n    /**\\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n     * Can only be called by the current owner.\\n     */\\n    function transferOwnership(address newOwner) public virtual onlyOwner {\\n        require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n        _transferOwnership(newOwner);\\n    }\\n\\n    /**\\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n     * Internal function without access restriction.\\n     */\\n    function _transferOwnership(address newOwner) internal virtual {\\n        address oldOwner = _owner;\\n        _owner = newOwner;\\n        emit OwnershipTransferred(oldOwner, newOwner);\\n    }\\n}\\n\",\"keccak256\":\"0x24e0364e503a9bbde94c715d26573a76f14cd2a202d45f96f52134ab806b67b9\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n    function _msgSender() internal view virtual returns (address) {\\n        return msg.sender;\\n    }\\n\\n    function _msgData() internal view virtual returns (bytes calldata) {\\n        return msg.data;\\n    }\\n}\\n\",\"keccak256\":\"0xe2e337e6dde9ef6b680e07338c493ebea1b5fd09b43424112868e9cc1706bca7\",\"license\":\"MIT\"},\"@rari-capital/solmate/src/auth/Owned.sol\":{\"content\":\"// SPDX-License-Identifier: AGPL-3.0-only\\npragma solidity >=0.8.0;\\n\\n/// @notice Simple single owner authorization mixin.\\n/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/auth/Owned.sol)\\nabstract contract Owned {\\n    /*//////////////////////////////////////////////////////////////\\n                                 EVENTS\\n    //////////////////////////////////////////////////////////////*/\\n\\n    event OwnerUpdated(address indexed user, address indexed newOwner);\\n\\n    /*//////////////////////////////////////////////////////////////\\n                            OWNERSHIP STORAGE\\n    //////////////////////////////////////////////////////////////*/\\n\\n    address public owner;\\n\\n    modifier onlyOwner() virtual {\\n        require(msg.sender == owner, \\\"UNAUTHORIZED\\\");\\n\\n        _;\\n    }\\n\\n    /*//////////////////////////////////////////////////////////////\\n                               CONSTRUCTOR\\n    //////////////////////////////////////////////////////////////*/\\n\\n    constructor(address _owner) {\\n        owner = _owner;\\n\\n        emit OwnerUpdated(address(0), _owner);\\n    }\\n\\n    /*//////////////////////////////////////////////////////////////\\n                             OWNERSHIP LOGIC\\n    //////////////////////////////////////////////////////////////*/\\n\\n    function setOwner(address newOwner) public virtual onlyOwner {\\n        owner = newOwner;\\n\\n        emit OwnerUpdated(msg.sender, newOwner);\\n    }\\n}\\n\",\"keccak256\":\"0x7e91c80b0dd1a14a19cb9e661b99924043adab6d9d893bbfcf3a6a3dc23a6743\",\"license\":\"AGPL-3.0-only\"}},\"version\":1}",
  "bytecode": "[encoded data, 15048 characters]",
  "deployedBytecode": "[encoded data, 14644 characters]",
  "devdoc": {
    "details": "This is an auxiliary contract meant to be assigned as the admin of a Proxy, based on      the OpenZeppelin implementation. It has backwards compatibility logic to work with the      various types of proxies that have been deployed by Optimism.",
    "kind": "dev",
    "methods": {
      "changeProxyAdmin(address,address)": {
        "details": "Changes the admin of `proxy` to `newAdmin`. This contract must be the current admin      of `proxy`.",
        "params": {
          "newAdmin": "The address of the admin to update to.",
          "proxy": "The proxy that will have its admin updated."
        }
      },
      "getProxyAdmin(address)": {
        "details": "Returns the current admin of `proxy`.      This contract must be the admin of `proxy`.",
        "params": {
          "proxy": "The Proxy to return the admin of."
        },
        "returns": {
          "_0": "The address of the admin."
        }
      },
      "getProxyImplementation(address)": {
        "details": "Returns the current implementation of `proxy`.      This contract must be the admin of `proxy`.",
        "params": {
          "proxy": "The Proxy to return the implementation of."
        },
        "returns": {
          "_0": "The address of the implementation."
        }
      },
      "isUpgrading()": {
        "custom:legacy": "@notice Legacy function used by the old Chugsplash proxy to determine if an upgrade is         happening.",
        "returns": {
          "_0": "Whether or not there is an upgrade going on"
        }
      },
      "setAddress(string,address)": {
        "custom:legacy": "@notice Set an address in the address manager. This is required because only the owner of         the AddressManager can set the addresses in it.",
        "params": {
          "_address": "The address to set in the address manager.",
          "_name": "The name of the address to set in the address manager."
        }
      },
      "setAddressManager(address)": {
        "params": {
          "_address": "The address of the address manager."
        }
      },
      "setImplementationName(address,string)": {
        "params": {
          "_address": "The address to be named.",
          "_name": "The name of the address."
        }
      },
      "setProxyType(address,uint8)": {
        "params": {
          "_type": "The type of the proxy."
        }
      },
      "setUpgrading(bool)": {
        "custom:legacy": "@notice Set the upgrading status for the Chugsplash proxy type.",
        "params": {
          "_upgrading": "Whether or not the system is upgrading."
        }
      },
      "upgrade(address,address)": {
        "details": "Upgrades `proxy` to `implementation`. This contract must be the admin of `proxy`.",
        "params": {
          "implementation": "The address of the implementation.",
          "proxy": "The address of the proxy."
        }
      },
      "upgradeAndCall(address,address,bytes)": {
        "details": "Upgrades `proxy` to `implementation` and calls a function on the new implementation.      This contract must be the admin of `proxy`.",
        "params": {
          "data": "The calldata to pass to the implementation.",
          "implementation": "The implementation to upgrade the proxy to.",
          "proxy": "The proxy to call."
        }
      }
    },
    "stateVariables": {
      "addressManager": {
        "custom:legacy": "@notice The address of the address manager, this is required to manage the         Lib_ResolvedDelegateProxy type."
      },
      "implementationName": {
        "custom:legacy": "@notice A reverse mapping of addresses to names held in the AddressManager. This must be         manually kept up to date with changes in the AddressManager for this contract         to be able to work as an admin for the Lib_ResolvedDelegateProxy type."
      },
      "proxyType": {
        "custom:legacy": "@notice         A mapping of proxy types, used for backwards compatibility."
      },
      "upgrading": {
        "custom:legacy": "@notice A legacy upgrading indicator used by the old Chugsplash Proxy."
      }
    },
    "title": "ProxyAdmin",
    "version": 1
  },
  "userdoc": {
    "kind": "user",
    "methods": {
      "constructor": {
        "notice": "Set the owner of the ProxyAdmin via constructor argument."
      },
      "setAddressManager(address)": {
        "notice": "Set the address of the address manager. This is required to manage the legacy         `Lib_ResolvedDelegateProxy`."
      },
      "setImplementationName(address,string)": {
        "notice": "Set the proxy type in the mapping. This needs to be kept up to date by the owner of         the contract."
      },
      "setProxyType(address,uint8)": {
        "notice": "@param _address   The address of the proxy."
      }
    },
    "version": 1
  },
  "storageLayout": {
    "storage": [
      {
        "astId": 4446,
        "contract": "@eth-optimism/contracts-bedrock/contracts/universal/ProxyAdmin.sol:ProxyAdmin",
        "label": "owner",
        "offset": 0,
        "slot": "0",
        "type": "t_address"
      },
      {
        "astId": 624,
        "contract": "@eth-optimism/contracts-bedrock/contracts/universal/ProxyAdmin.sol:ProxyAdmin",
        "label": "proxyType",
        "offset": 0,
        "slot": "1",
        "type": "t_mapping(t_address,t_enum(ProxyType)618)"
      },
      {
        "astId": 629,
        "contract": "@eth-optimism/contracts-bedrock/contracts/universal/ProxyAdmin.sol:ProxyAdmin",
        "label": "implementationName",
        "offset": 0,
        "slot": "2",
        "type": "t_mapping(t_address,t_string_storage)"
      },
      {
        "astId": 633,
        "contract": "@eth-optimism/contracts-bedrock/contracts/universal/ProxyAdmin.sol:ProxyAdmin",
        "label": "addressManager",
        "offset": 0,
        "slot": "3",
        "type": "t_contract(Lib_AddressManager)376"
      },
      {
        "astId": 637,
        "contract": "@eth-optimism/contracts-bedrock/contracts/universal/ProxyAdmin.sol:ProxyAdmin",
        "label": "upgrading",
        "offset": 20,
        "slot": "3",
        "type": "t_bool"
      }
    ],
    "types": {
      "t_address": {
        "encoding": "inplace",
        "label": "address",
        "numberOfBytes": "20"
      },
      "t_bool": {
        "encoding": "inplace",
        "label": "bool",
        "numberOfBytes": "1"
      },
      "t_contract(Lib_AddressManager)376": {
        "encoding": "inplace",
        "label": "contract Lib_AddressManager",
        "numberOfBytes": "20"
      },
      "t_enum(ProxyType)618": {
        "encoding": "inplace",
        "label": "enum ProxyAdmin.ProxyType",
        "numberOfBytes": "1"
      },
      "t_mapping(t_address,t_enum(ProxyType)618)": {
        "encoding": "mapping",
        "key": "t_address",
        "label": "mapping(address => enum ProxyAdmin.ProxyType)",
        "numberOfBytes": "32",
        "value": "t_enum(ProxyType)618"
      },
      "t_mapping(t_address,t_string_storage)": {
        "encoding": "mapping",
        "key": "t_address",
        "label": "mapping(address => string)",
        "numberOfBytes": "32",
        "value": "t_string_storage"
      },
      "t_string_storage": {
        "encoding": "bytes",
        "label": "string",
        "numberOfBytes": "32"
      }
    }
  }
}