Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.23 <0.9.0;

import { IBlast, YieldMode, GasMode } from "./interface/IBlast.sol";
import { IBlastPoints } from "./interface/IBlastPoints.sol";
import { IEthStakeRegistry } from "./interface/IEthStakeRegistry.sol";
import { Initializable } from "@openzeppelin/contracts/proxy/utils/Initializable.sol";
import { Error } from "./utils/Error.sol";

contract EthStakingContract is Initializable, Error {
    address public serviceContract;
    address public stakeRegistry;

    event Deposit(uint256 amount);
    event Withdraw(address to, uint256 amount);

    /* ============ Initializer ============ */

    function init(
        address blast,
        address blastPoints,
        address _serviceContract,
        address pointsOperator
    )
        public
        initializer
    {
        stakeRegistry = msg.sender;
        serviceContract = _serviceContract;
        IBlast(blast).configureContract(address(this), YieldMode.AUTOMATIC, GasMode.CLAIMABLE, stakeRegistry);
        IBlastPoints(blastPoints).configurePointsOperator(pointsOperator);
    }

    /* ============ Modifier ============ */

    modifier onlyStakeRegistry() {
        if (msg.sender != stakeRegistry) {
            revert OnlyStakeRegistry();
        }
        _;
    }

    /* ============ External Functions ============ */

    function deposit() external payable onlyStakeRegistry {
        emit Deposit(msg.value);
    }

    function withdraw(address payable to, uint256 amount) external onlyStakeRegistry {
        to.transfer(amount);
        emit Withdraw(to, amount);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.23 <0.9.0;

enum YieldMode {
    AUTOMATIC,
    VOID,
    CLAIMABLE
}

enum GasMode {
    VOID,
    CLAIMABLE
}

interface IBlast {
    function YIELD_CONTRACT() external view returns (address);
    function GAS_CONTRACT() external view returns (address);

    // configure
    function configureContract(address contractAddress, YieldMode _yield, GasMode gasMode, address governor) external;
    function configure(YieldMode _yield, GasMode gasMode, address governor) external;

    // base configuration options
    function configureClaimableYield() external;
    function configureClaimableYieldOnBehalf(address contractAddress) external;
    function configureAutomaticYield() external;
    function configureAutomaticYieldOnBehalf(address contractAddress) external;
    function configureVoidYield() external;
    function configureVoidYieldOnBehalf(address contractAddress) external;
    function configureClaimableGas() external;
    function configureClaimableGasOnBehalf(address contractAddress) external;
    function configureVoidGas() external;
    function configureVoidGasOnBehalf(address contractAddress) external;
    function configureGovernor(address _governor) external;
    function configureGovernorOnBehalf(address _newGovernor, address contractAddress) external;

    // claim yield
    function claimYield(address contractAddress, address recipientOfYield, uint256 amount) external returns (uint256);
    function claimAllYield(address contractAddress, address recipientOfYield) external returns (uint256);

    // claim gas
    function claimAllGas(address contractAddress, address recipientOfGas) external returns (uint256);
    function claimGasAtMinClaimRate(
        address contractAddress,
        address recipientOfGas,
        uint256 minClaimRateBips
    )
        external
        returns (uint256);
    function claimMaxGas(address contractAddress, address recipientOfGas) external returns (uint256);
    function claimGas(
        address contractAddress,
        address recipientOfGas,
        uint256 gasToClaim,
        uint256 gasSecondsToConsume
    )
        external
        returns (uint256);

    // read functions
    function readClaimableYield(address contractAddress) external view returns (uint256);
    function readYieldConfiguration(address contractAddress) external view returns (uint8);
    function readGasParams(address contractAddress)
        external
        view
        returns (uint256 etherSeconds, uint256 etherBalance, uint256 lastUpdated, GasMode);
}

interface IYield {
    function configure(address contractAddress, uint8 flags) external returns (uint256);
    function claim(
        address contractAddress,
        address recipientOfYield,
        uint256 desiredAmount
    )
        external
        returns (uint256);
    function getClaimableAmount(address contractAddress) external view returns (uint256);
    function getConfiguration(address contractAddress) external view returns (uint8);
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.23 <0.9.0;

interface IBlastPoints {
    function configurePointsOperator(address operator) external;
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.23 <0.9.0;

interface IEthStakeRegistry {
    function getUserStakingContract(address service, address user) external view returns (address);
    function getUserStakingContractBalance(address service, address user) external view returns (uint256);
    function stake(address user, bytes memory data) external payable;
    function unstake(address user, address payable to, uint256 amount, bytes memory data) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/Initializable.sol)

pragma solidity ^0.8.20;

/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
 * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
 * case an upgrade adds a module that needs to be initialized.
 *
 * For example:
 *
 * [.hljs-theme-light.nopadding]
 * ```solidity
 * contract MyToken is ERC20Upgradeable {
 *     function initialize() initializer public {
 *         __ERC20_init("MyToken", "MTK");
 *     }
 * }
 *
 * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
 *     function initializeV2() reinitializer(2) public {
 *         __ERC20Permit_init("MyToken");
 *     }
 * }
 * ```
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 *
 * [CAUTION]
 * ====
 * Avoid leaving a contract uninitialized.
 *
 * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
 * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
 * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * /// @custom:oz-upgrades-unsafe-allow constructor
 * constructor() {
 *     _disableInitializers();
 * }
 * ```
 * ====
 */
abstract contract Initializable {
    /**
     * @dev Storage of the initializable contract.
     *
     * It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions
     * when using with upgradeable contracts.
     *
     * @custom:storage-location erc7201:openzeppelin.storage.Initializable
     */
    struct InitializableStorage {
        /**
         * @dev Indicates that the contract has been initialized.
         */
        uint64 _initialized;
        /**
         * @dev Indicates that the contract is in the process of being initialized.
         */
        bool _initializing;
    }

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Initializable")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;

    /**
     * @dev The contract is already initialized.
     */
    error InvalidInitialization();

    /**
     * @dev The contract is not initializing.
     */
    error NotInitializing();

    /**
     * @dev Triggered when the contract has been initialized or reinitialized.
     */
    event Initialized(uint64 version);

    /**
     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
     * `onlyInitializing` functions can be used to initialize parent contracts.
     *
     * Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any
     * number of times. This behavior in the constructor can be useful during testing and is not expected to be used in
     * production.
     *
     * Emits an {Initialized} event.
     */
    modifier initializer() {
        // solhint-disable-next-line var-name-mixedcase
        InitializableStorage storage $ = _getInitializableStorage();

        // Cache values to avoid duplicated sloads
        bool isTopLevelCall = !$._initializing;
        uint64 initialized = $._initialized;

        // Allowed calls:
        // - initialSetup: the contract is not in the initializing state and no previous version was
        //                 initialized
        // - construction: the contract is initialized at version 1 (no reininitialization) and the
        //                 current contract is just being deployed
        bool initialSetup = initialized == 0 && isTopLevelCall;
        bool construction = initialized == 1 && address(this).code.length == 0;

        if (!initialSetup && !construction) {
            revert InvalidInitialization();
        }
        $._initialized = 1;
        if (isTopLevelCall) {
            $._initializing = true;
        }
        _;
        if (isTopLevelCall) {
            $._initializing = false;
            emit Initialized(1);
        }
    }

    /**
     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
     * used to initialize parent contracts.
     *
     * A reinitializer may be used after the original initialization step. This is essential to configure modules that
     * are added through upgrades and that require initialization.
     *
     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
     * cannot be nested. If one is invoked in the context of another, execution will revert.
     *
     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
     * a contract, executing them in the right order is up to the developer or operator.
     *
     * WARNING: Setting the version to 2**64 - 1 will prevent any future reinitialization.
     *
     * Emits an {Initialized} event.
     */
    modifier reinitializer(uint64 version) {
        // solhint-disable-next-line var-name-mixedcase
        InitializableStorage storage $ = _getInitializableStorage();

        if ($._initializing || $._initialized >= version) {
            revert InvalidInitialization();
        }
        $._initialized = version;
        $._initializing = true;
        _;
        $._initializing = false;
        emit Initialized(version);
    }

    /**
     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
     * {initializer} and {reinitializer} modifiers, directly or indirectly.
     */
    modifier onlyInitializing() {
        _checkInitializing();
        _;
    }

    /**
     * @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}.
     */
    function _checkInitializing() internal view virtual {
        if (!_isInitializing()) {
            revert NotInitializing();
        }
    }

    /**
     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called
     * through proxies.
     *
     * Emits an {Initialized} event the first time it is successfully executed.
     */
    function _disableInitializers() internal virtual {
        // solhint-disable-next-line var-name-mixedcase
        InitializableStorage storage $ = _getInitializableStorage();

        if ($._initializing) {
            revert InvalidInitialization();
        }
        if ($._initialized != type(uint64).max) {
            $._initialized = type(uint64).max;
            emit Initialized(type(uint64).max);
        }
    }

    /**
     * @dev Returns the highest version that has been initialized. See {reinitializer}.
     */
    function _getInitializedVersion() internal view returns (uint64) {
        return _getInitializableStorage()._initialized;
    }

    /**
     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
     */
    function _isInitializing() internal view returns (bool) {
        return _getInitializableStorage()._initializing;
    }

    /**
     * @dev Returns a pointer to the storage namespace.
     */
    // solhint-disable-next-line var-name-mixedcase
    function _getInitializableStorage() private pure returns (InitializableStorage storage $) {
        assembly {
            $.slot := INITIALIZABLE_STORAGE
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.23 <0.9.0;

/// @title Error contract
/// @dev Contracts should inherit from this contract to use custom errors
contract Error {
    error OnlyStakeRegistry();
    error InvalidValue();
}

{
  "remappings": [
    "@openzeppelin/contracts/=node_modules/@openzeppelin/contracts/",
    "@prb/test/=node_modules/@prb/test/",
    "forge-std/=node_modules/forge-std/",
    "@nomad-xyz/=node_modules/@nomad-xyz/",
    "blast-staking-contract/=node_modules/blast-staking-contract/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 10000
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "none",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "evmVersion": "paris",
  "viaIR": false,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"name":"InvalidInitialization","type":"error"},{"inputs":[],"name":"InvalidValue","type":"error"},{"inputs":[],"name":"NotInitializing","type":"error"},{"inputs":[],"name":"OnlyStakeRegistry","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"version","type":"uint64"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"deposit","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"blast","type":"address"},{"internalType":"address","name":"blastPoints","type":"address"},{"internalType":"address","name":"_serviceContract","type":"address"},{"internalType":"address","name":"pointsOperator","type":"address"}],"name":"init","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"serviceContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stakeRegistry","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address payable","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

398:1220:1:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;660:450;;;;;;;;;;-1:-1:-1;660:450:1;;;;;:::i;:::-;;:::i;:::-;;456:30;;;;;;;;;;-1:-1:-1;456:30:1;;;;;;;;;;;1025:42:6;1013:55;;;995:74;;983:2;968:18;456:30:1;;;;;;;492:28;;;;;;;;;;-1:-1:-1;492:28:1;;;;;;;;1364:94;;;:::i;1464:152::-;;;;;;;;;;-1:-1:-1;1464:152:1;;;;;:::i;:::-;;:::i;660:450::-;8870:21:0;4302:15;;;;;;;4301:16;;4348:14;;4158:30;4726:16;;:34;;;;;4746:14;4726:34;4706:54;;4770:17;4790:11;:16;;4805:1;4790:16;:50;;;;-1:-1:-1;4818:4:0;4810:25;:30;4790:50;4770:70;;4856:12;4855:13;:30;;;;;4873:12;4872:13;4855:30;4851:91;;;4908:23;;;;;;;;;;;;;;4851:91;4951:18;;;;4968:1;4951:18;;;4979:67;;;;5013:22;;;;;;;;4979:67;847:13:1::1;:26:::0;;;;;::::1;863:10;847:26:::0;;::::1;::::0;;:13:::1;883:34:::0;;847:26:::1;883:34:::0;;::::1;::::0;;;::::1;;::::0;;927:101:::1;::::0;;;;:31;;::::1;::::0;::::1;::::0;:101:::1;::::0;967:4:::1;::::0;847:13;;927:101:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;1038:65:1::1;::::0;;;;:49:::1;1013:55:6::0;;;1038:65:1::1;::::0;::::1;995:74:6::0;1038:49:1;::::1;::::0;-1:-1:-1;1038:49:1::1;::::0;-1:-1:-1;968:18:6;;1038:65:1::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;5070:14:0::0;5066:101;;;5100:23;;;;;;5142:14;;-1:-1:-1;2357:50:6;;5142:14:0;;2345:2:6;2330:18;5142:14:0;;;;;;;5066:101;4092:1081;;;;;660:450:1;;;;:::o;1364:94::-;1219:13;;;;1205:10;:27;1201:84;;1255:19;;;;;;;;;;;;;;1201:84;1433:18:::1;::::0;1441:9:::1;2564:25:6::0;;1433:18:1::1;::::0;2552:2:6;2537:18;1433::1::1;;;;;;;1364:94::o:0;1464:152::-;1219:13;;;;1205:10;:27;1201:84;;1255:19;;;;;;;;;;;;;;1201:84;1555:19:::1;::::0;:11:::1;::::0;::::1;::::0;:19;::::1;;;::::0;1567:6;;1555:19:::1;::::0;;;1567:6;1555:11;:19;::::1;;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;1589:20:1::1;::::0;;2812:42:6;2800:55;;2782:74;;2887:2;2872:18;;2865:34;;;1589:20:1::1;::::0;2755:18:6;1589:20:1::1;;;;;;;1464:152:::0;;:::o;14:154:6:-;100:42;93:5;89:54;82:5;79:65;69:93;;158:1;155;148:12;69:93;14:154;:::o;173:671::-;259:6;267;275;283;336:3;324:9;315:7;311:23;307:33;304:53;;;353:1;350;343:12;304:53;392:9;379:23;411:31;436:5;411:31;:::i;:::-;461:5;-1:-1:-1;518:2:6;503:18;;490:32;531:33;490:32;531:33;:::i;:::-;583:7;-1:-1:-1;642:2:6;627:18;;614:32;655:33;614:32;655:33;:::i;:::-;707:7;-1:-1:-1;766:2:6;751:18;;738:32;779:33;738:32;779:33;:::i;:::-;173:671;;;;-1:-1:-1;173:671:6;;-1:-1:-1;;173:671:6:o;1080:323::-;1156:6;1164;1217:2;1205:9;1196:7;1192:23;1188:32;1185:52;;;1233:1;1230;1223:12;1185:52;1272:9;1259:23;1291:31;1316:5;1291:31;:::i;:::-;1341:5;1393:2;1378:18;;;;1365:32;;-1:-1:-1;;;1080:323:6:o;1408:184::-;1460:77;1457:1;1450:88;1557:4;1554:1;1547:15;1581:4;1578:1;1571:15;1597:602;1858:42;1927:15;;;1909:34;;1835:3;1820:19;;;1973:1;1962:13;;1952:47;;1979:18;;:::i;:::-;2035:6;2030:2;2019:9;2015:18;2008:34;2072:1;2064:6;2061:13;2051:47;;2078:18;;:::i;:::-;2134:6;2129:2;2118:9;2114:18;2107:34;2189:2;2181:6;2177:15;2172:2;2161:9;2157:18;2150:43;;1597:602;;;;;;;:::o

none://164736f6c6343000817000a