Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Is this a proxy?
• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;

import { iL1ChugSplashDeployer } from "./iL1ChugSplashDeployer.sol";

/**
 * @title L1ChugSplashProxy
 * @dev Basic ChugSplash proxy contract for L1. Very close to being a normal proxy but has added
 * functions `setCode` and `setStorage` for changing the code or storage of the contract. Nifty!
 *
 * Note for future developers: do NOT make anything in this contract 'public' unless you know what
 * you're doing. Anything public can potentially have a function signature that conflicts with a
 * signature attached to the implementation contract. Public functions SHOULD always have the
 * 'proxyCallIfNotOwner' modifier unless there's some *really* good reason not to have that
 * modifier. And there almost certainly is not a good reason to not have that modifier. Beware!
 */
contract L1ChugSplashProxy {
    /*************
     * Constants *
     *************/

    // "Magic" prefix. When prepended to some arbitrary bytecode and used to create a contract, the
    // appended bytecode will be deployed as given.
    bytes13 internal constant DEPLOY_CODE_PREFIX = 0x600D380380600D6000396000f3;

    // bytes32(uint256(keccak256('eip1967.proxy.implementation')) - 1)
    bytes32 internal constant IMPLEMENTATION_KEY =
        0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;

    // bytes32(uint256(keccak256('eip1967.proxy.admin')) - 1)
    bytes32 internal constant OWNER_KEY =
        0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;

    /***************
     * Constructor *
     ***************/

    /**
     * @param _owner Address of the initial contract owner.
     */
    constructor(address _owner) {
        _setOwner(_owner);
    }

    /**********************
     * Function Modifiers *
     **********************/

    /**
     * Blocks a function from being called when the parent signals that the system should be paused
     * via an isUpgrading function.
     */
    modifier onlyWhenNotPaused() {
        address owner = _getOwner();

        // We do a low-level call because there's no guarantee that the owner actually *is* an
        // L1ChugSplashDeployer contract and Solidity will throw errors if we do a normal call and
        // it turns out that it isn't the right type of contract.
        (bool success, bytes memory returndata) = owner.staticcall(
            abi.encodeWithSelector(iL1ChugSplashDeployer.isUpgrading.selector)
        );

        // If the call was unsuccessful then we assume that there's no "isUpgrading" method and we
        // can just continue as normal. We also expect that the return value is exactly 32 bytes
        // long. If this isn't the case then we can safely ignore the result.
        if (success && returndata.length == 32) {
            // Although the expected value is a *boolean*, it's safer to decode as a uint256 in the
            // case that the isUpgrading function returned something other than 0 or 1. But we only
            // really care about the case where this value is 0 (= false).
            uint256 ret = abi.decode(returndata, (uint256));
            require(ret == 0, "L1ChugSplashProxy: system is currently being upgraded");
        }

        _;
    }

    /**
     * Makes a proxy call instead of triggering the given function when the caller is either the
     * owner or the zero address. Caller can only ever be the zero address if this function is
     * being called off-chain via eth_call, which is totally fine and can be convenient for
     * client-side tooling. Avoids situations where the proxy and implementation share a sighash
     * and the proxy function ends up being called instead of the implementation one.
     *
     * Note: msg.sender == address(0) can ONLY be triggered off-chain via eth_call. If there's a
     * way for someone to send a transaction with msg.sender == address(0) in any real context then
     * we have much bigger problems. Primary reason to include this additional allowed sender is
     * because the owner address can be changed dynamically and we do not want clients to have to
     * keep track of the current owner in order to make an eth_call that doesn't trigger the
     * proxied contract.
     */
    // slither-disable-next-line incorrect-modifier
    modifier proxyCallIfNotOwner() {
        if (msg.sender == _getOwner() || msg.sender == address(0)) {
            _;
        } else {
            // This WILL halt the call frame on completion.
            _doProxyCall();
        }
    }

    /*********************
     * Fallback Function *
     *********************/

    // slither-disable-next-line locked-ether
    fallback() external payable {
        // Proxy call by default.
        _doProxyCall();
    }

    /********************
     * Public Functions *
     ********************/

    /**
     * Sets the code that should be running behind this proxy. Note that this scheme is a bit
     * different from the standard proxy scheme where one would typically deploy the code
     * separately and then set the implementation address. We're doing it this way because it gives
     * us a lot more freedom on the client side. Can only be triggered by the contract owner.
     * @param _code New contract code to run inside this contract.
     */
    // slither-disable-next-line external-function
    function setCode(bytes memory _code) public proxyCallIfNotOwner {
        // Get the code hash of the current implementation.
        address implementation = _getImplementation();

        // If the code hash matches the new implementation then we return early.
        if (keccak256(_code) == _getAccountCodeHash(implementation)) {
            return;
        }

        // Create the deploycode by appending the magic prefix.
        bytes memory deploycode = abi.encodePacked(DEPLOY_CODE_PREFIX, _code);

        // Deploy the code and set the new implementation address.
        address newImplementation;
        assembly {
            newImplementation := create(0x0, add(deploycode, 0x20), mload(deploycode))
        }

        // Check that the code was actually deployed correctly. I'm not sure if you can ever
        // actually fail this check. Should only happen if the contract creation from above runs
        // out of gas but this parent execution thread does NOT run out of gas. Seems like we
        // should be doing this check anyway though.
        require(
            _getAccountCodeHash(newImplementation) == keccak256(_code),
            "L1ChugSplashProxy: code was not correctly deployed."
        );

        _setImplementation(newImplementation);
    }

    /**
     * Modifies some storage slot within the proxy contract. Gives us a lot of power to perform
     * upgrades in a more transparent way. Only callable by the owner.
     * @param _key Storage key to modify.
     * @param _value New value for the storage key.
     */
    // slither-disable-next-line external-function
    function setStorage(bytes32 _key, bytes32 _value) public proxyCallIfNotOwner {
        assembly {
            sstore(_key, _value)
        }
    }

    /**
     * Changes the owner of the proxy contract. Only callable by the owner.
     * @param _owner New owner of the proxy contract.
     */
    // slither-disable-next-line external-function
    function setOwner(address _owner) public proxyCallIfNotOwner {
        _setOwner(_owner);
    }

    /**
     * Queries the owner of the proxy contract. Can only be called by the owner OR by making an
     * eth_call and setting the "from" address to address(0).
     * @return Owner address.
     */
    // slither-disable-next-line external-function
    function getOwner() public proxyCallIfNotOwner returns (address) {
        return _getOwner();
    }

    /**
     * Queries the implementation address. Can only be called by the owner OR by making an
     * eth_call and setting the "from" address to address(0).
     * @return Implementation address.
     */
    // slither-disable-next-line external-function
    function getImplementation() public proxyCallIfNotOwner returns (address) {
        return _getImplementation();
    }

    /**********************
     * Internal Functions *
     **********************/

    /**
     * Sets the implementation address.
     * @param _implementation New implementation address.
     */
    function _setImplementation(address _implementation) internal {
        assembly {
            sstore(IMPLEMENTATION_KEY, _implementation)
        }
    }

    /**
     * Queries the implementation address.
     * @return Implementation address.
     */
    function _getImplementation() internal view returns (address) {
        address implementation;
        assembly {
            implementation := sload(IMPLEMENTATION_KEY)
        }
        return implementation;
    }

    /**
     * Changes the owner of the proxy contract.
     * @param _owner New owner of the proxy contract.
     */
    function _setOwner(address _owner) internal {
        assembly {
            sstore(OWNER_KEY, _owner)
        }
    }

    /**
     * Queries the owner of the proxy contract.
     * @return Owner address.
     */
    function _getOwner() internal view returns (address) {
        address owner;
        assembly {
            owner := sload(OWNER_KEY)
        }
        return owner;
    }

    /**
     * Gets the code hash for a given account.
     * @param _account Address of the account to get a code hash for.
     * @return Code hash for the account.
     */
    function _getAccountCodeHash(address _account) internal view returns (bytes32) {
        bytes32 codeHash;
        assembly {
            codeHash := extcodehash(_account)
        }
        return codeHash;
    }

    /**
     * Performs the proxy call via a delegatecall.
     */
    function _doProxyCall() internal onlyWhenNotPaused {
        address implementation = _getImplementation();

        require(implementation != address(0), "L1ChugSplashProxy: implementation is not set yet");

        assembly {
            // Copy calldata into memory at 0x0....calldatasize.
            calldatacopy(0x0, 0x0, calldatasize())

            // Perform the delegatecall, make sure to pass all available gas.
            let success := delegatecall(gas(), implementation, 0x0, calldatasize(), 0x0, 0x0)

            // Copy returndata into memory at 0x0....returndatasize. Note that this *will*
            // overwrite the calldata that we just copied into memory but that doesn't really
            // matter because we'll be returning in a second anyway.
            returndatacopy(0x0, 0x0, returndatasize())

            // Success == 0 means a revert. We'll revert too and pass the data up.
            if iszero(success) {
                revert(0x0, returndatasize())
            }

            // Otherwise we'll just return and pass the data up.
            return(0x0, returndatasize())
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;

/**
 * @title iL1ChugSplashDeployer
 */
interface iL1ChugSplashDeployer {
    function isUpgrading() external view returns (bool);
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"stateMutability":"payable","type":"fallback"},{"inputs":[],"name":"getImplementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"_code","type":"bytes"}],"name":"setCode","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"setOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_key","type":"bytes32"},{"internalType":"bytes32","name":"_value","type":"bytes32"}],"name":"setStorage","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

838:10133:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4756:14;:12;:14::i;:::-;838:10133;7342:95;;;;;;;;;;-1:-1:-1;7342:95:0;;;;;:::i;:::-;;:::i;5375:1284::-;;;;;;;;;;-1:-1:-1;5375:1284:0;;;;;:::i;:::-;;:::i;7698:100::-;;;;;;;;;;;;;:::i;:::-;;;1678:42:2;1666:55;;;1648:74;;1636:2;1621:18;7698:100:0;;;;;;;6993:146;;;;;;;;;;-1:-1:-1;6993:146:0;;;;;:::i;:::-;;:::i;8063:118::-;;;;;;;;;;;;;:::i;9842:1127::-;2030:13;2046:11;9328:9;9322:16;;9204:172;2046:11;2400:66;;;;;;;;;;;;;;;;;;2423:42;2400:66;;;2370:106;;2030:27;;-1:-1:-1;2329:12:0;;;;2370:16;;;;:106;;2400:66;2370:106;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2328:148;;;;2765:7;:34;;;;;2776:10;:17;2797:2;2776:23;2765:34;2761:475;;;3090:11;3115:10;3104:33;;;;;;;;;;;;:::i;:::-;3090:47;-1:-1:-1;3159:8:0;;3151:74;;;;;;;2912:2:2;3151:74:0;;;2894:21:2;2951:2;2931:18;;;2924:30;2990:34;2970:18;;;2963:62;3061:23;3041:18;;;3034:51;3102:19;;3151:74:0;;;;;;;;;2801:435;2761:475;9903:22:::1;9928:20;8796:18:::0;8790:25;;8645:217;9928:20:::1;9903:45:::0;-1:-1:-1;9967:28:0::1;::::0;::::1;9959:89;;;::::0;::::1;::::0;;3334:2:2;9959:89:0::1;::::0;::::1;3316:21:2::0;3373:2;3353:18;;;3346:30;3412:34;3392:18;;;3385:62;3483:18;3463;;;3456:46;3519:19;;9959:89:0::1;3132:412:2::0;9959:89:0::1;10170:14;10165:3;10160::::0;10147:38:::1;10354:3;10349::::0;10333:14:::1;10328:3;10312:14;10305:5;10292:66;10651:16;10646:3;10641::::0;10626:42:::1;10775:7;10765:80;;10814:16;10809:3;10802:29;10765:80;;10936:16;10931:3;10924:29;7342:95:::0;9328:9;9322:16;4357:25;;:10;:25;;;:53;;;-1:-1:-1;4386:10:0;:24;4357:53;4353:190;;;7413:17:::1;7423:6;9070:9:::0;9063:25;8986:118;7413:17:::1;7342:95:::0;:::o;4353:190::-;4518:14;:12;:14::i;5375:1284::-;9328:9;9322:16;4357:25;;:10;:25;;;:53;;;-1:-1:-1;4386:10:0;:24;4357:53;4353:190;;;5509:22:::1;5534:20;8796:18:::0;8790:25;;8645:217;5534:20:::1;5509:45:::0;-1:-1:-1;9707:21:0;;5650:16;;::::1;::::0;::::1;::::0;:55:::1;5646:92;;;5721:7;7342:95:::0;:::o;5646:92::-:1;5838:43;::::0;5812:23:::1;::::0;5838:43:::1;::::0;5855:18;;5875:5;;5838:43:::1;;;:::i;:::-;;;;;;;;;;;;;5812:69;;5959:25;6079:10;6073:17;6066:4;6054:10;6050:21;6045:3;6038:53;6511:16:::0;;::::1;::::0;::::1;::::0;6017:74;;-1:-1:-1;9707:21:0;;6469:58:::1;6448:156;;;::::0;::::1;::::0;;4083:2:2;6448:156:0::1;::::0;::::1;4065:21:2::0;4122:2;4102:18;;;4095:30;4161:34;4141:18;;;4134:62;4232:21;4212:18;;;4205:49;4271:19;;6448:156:0::1;3881:415:2::0;6448:156:0::1;6615:37;6634:17;8489:18:::0;8482:43;8387:154;6615:37:::1;5439:1220;;;7342:95:::0;:::o;7698:100::-;7754:7;4371:11;9328:9;9322:16;;9204:172;4371:11;4357:25;;:10;:25;;;:53;;;-1:-1:-1;4386:10:0;:24;4357:53;4353:190;;;-1:-1:-1;9328:9:0;9322:16;;7698:100::o;4353:190::-;4518:14;:12;:14::i;:::-;7698:100;:::o;6993:146::-;9328:9;9322:16;4357:25;;:10;:25;;;:53;;;-1:-1:-1;4386:10:0;:24;4357:53;4353:190;;;7103:20;;6993:146::o;4353:190::-;4518:14;:12;:14::i;:::-;6993:146;;:::o;8063:118::-;8128:7;4371:11;9328:9;9322:16;;9204:172;4371:11;4357:25;;:10;:25;;;:53;;;-1:-1:-1;4386:10:0;:24;4357:53;4353:190;;;-1:-1:-1;8796:18:0;8790:25;;7698:100::o;14:309:2:-;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;181:9;168:23;231:42;224:5;220:54;213:5;210:65;200:93;;289:1;286;279:12;200:93;312:5;14:309;-1:-1:-1;;;14:309:2:o;328:184::-;380:77;377:1;370:88;477:4;474:1;467:15;501:4;498:1;491:15;517:980;585:6;638:2;626:9;617:7;613:23;609:32;606:52;;;654:1;651;644:12;606:52;694:9;681:23;723:18;764:2;756:6;753:14;750:34;;;780:1;777;770:12;750:34;818:6;807:9;803:22;793:32;;863:7;856:4;852:2;848:13;844:27;834:55;;885:1;882;875:12;834:55;921:2;908:16;943:2;939;936:10;933:36;;;949:18;;:::i;:::-;1083:2;1077:9;1145:4;1137:13;;988:66;1133:22;;;1157:2;1129:31;1125:40;1113:53;;;1181:18;;;1201:22;;;1178:46;1175:72;;;1227:18;;:::i;:::-;1267:10;1263:2;1256:22;1302:2;1294:6;1287:18;1342:7;1337:2;1332;1328;1324:11;1320:20;1317:33;1314:53;;;1363:1;1360;1353:12;1314:53;1419:2;1414;1410;1406:11;1401:2;1393:6;1389:15;1376:46;1464:1;1442:15;;;1459:2;1438:24;1431:35;;;;-1:-1:-1;1446:6:2;517:980;-1:-1:-1;;;;;517:980:2:o;1733:248::-;1801:6;1809;1862:2;1850:9;1841:7;1837:23;1833:32;1830:52;;;1878:1;1875;1868:12;1830:52;-1:-1:-1;;1901:23:2;;;1971:2;1956:18;;;1943:32;;-1:-1:-1;1733:248:2:o;1986:336::-;2027:3;2065:5;2059:12;2089:1;2099:128;2113:6;2110:1;2107:13;2099:128;;;2210:4;2195:13;;;2191:24;;2185:31;2172:11;;;2165:52;2128:12;2099:128;;;2245:6;2242:1;2239:13;2236:48;;;2280:1;2271:6;2266:3;2262:16;2255:27;2236:48;-1:-1:-1;2300:16:2;;;;;1986:336;-1:-1:-1;;1986:336:2:o;2327:189::-;2456:3;2481:29;2506:3;2498:6;2481:29;:::i;2521:184::-;2591:6;2644:2;2632:9;2623:7;2619:23;2615:32;2612:52;;;2660:1;2657;2650:12;2612:52;-1:-1:-1;2683:16:2;;2521:184;-1:-1:-1;2521:184:2:o;3549:327::-;3748:66;3740:6;3736:79;3731:3;3724:92;3706:3;3832:38;3866:2;3861:3;3857:12;3849:6;3832:38;:::i;:::-;3825:45;3549:327;-1:-1:-1;;;;3549:327:2:o

ipfs://aea34fd8cdcf3a9cced029d5f7b1e628f42ad1514501878e0040df2afddb6e71