Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library FixedPointMathLib
•    - function mulWadDown(uint256 x, uint25 ...
•    - function mulWadUp(uint256 x, uint256 ...
•    - function divWadDown(uint256 x, uint25 ...
•    - function divWadUp(uint256 x, uint256 ...
•    - function mulDivDown(
•    - function mulDivUp(
•    - function rpow(
•    - function sqrt(uint256 x)
•    - function unsafeMod(uint256 x, uint256 ...
•    - function unsafeDiv(uint256 x, uint256 ...
•    - function unsafeDivUp(uint256 x, uint2 ...
• interface IStaking
•    - function depositContract()
•    - function treasury()
•    - function oneTimeFee()
•    - function performanceFee()
•    - function registry(address)
•    - function pendingValidators(address)
•    - function deposit(address user)
• library SafeTransferLib
•    - function safeTransferETH(address to, ...
•  contract FeeRecipient is StakingCo ... *
•    - function unclaimedRewards()
•    - function claimRewards()
•    - function treasuryClaim()
•    - function _treasuryClaim()
•    - function _calcToTreasury(uint256 amou ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2024-08-31
*/

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity =0.8.13 >=0.8.0;

// lib/solmate/src/utils/FixedPointMathLib.sol

/// @notice Arithmetic library with operations for fixed-point numbers.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/FixedPointMathLib.sol)
/// @author Inspired by USM (https://github.com/usmfum/USM/blob/master/contracts/WadMath.sol)
library FixedPointMathLib {
    /*//////////////////////////////////////////////////////////////
                    SIMPLIFIED FIXED POINT OPERATIONS
    //////////////////////////////////////////////////////////////*/

    uint256 internal constant MAX_UINT256 = 2**256 - 1;

    uint256 internal constant WAD = 1e18; // The scalar of ETH and most ERC20s.

    function mulWadDown(uint256 x, uint256 y) internal pure returns (uint256) {
        return mulDivDown(x, y, WAD); // Equivalent to (x * y) / WAD rounded down.
    }

    function mulWadUp(uint256 x, uint256 y) internal pure returns (uint256) {
        return mulDivUp(x, y, WAD); // Equivalent to (x * y) / WAD rounded up.
    }

    function divWadDown(uint256 x, uint256 y) internal pure returns (uint256) {
        return mulDivDown(x, WAD, y); // Equivalent to (x * WAD) / y rounded down.
    }

    function divWadUp(uint256 x, uint256 y) internal pure returns (uint256) {
        return mulDivUp(x, WAD, y); // Equivalent to (x * WAD) / y rounded up.
    }

    /*//////////////////////////////////////////////////////////////
                    LOW LEVEL FIXED POINT OPERATIONS
    //////////////////////////////////////////////////////////////*/

    function mulDivDown(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            // Equivalent to require(denominator != 0 && (y == 0 || x <= type(uint256).max / y))
            if iszero(mul(denominator, iszero(mul(y, gt(x, div(MAX_UINT256, y)))))) {
                revert(0, 0)
            }

            // Divide x * y by the denominator.
            z := div(mul(x, y), denominator)
        }
    }

    function mulDivUp(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            // Equivalent to require(denominator != 0 && (y == 0 || x <= type(uint256).max / y))
            if iszero(mul(denominator, iszero(mul(y, gt(x, div(MAX_UINT256, y)))))) {
                revert(0, 0)
            }

            // If x * y modulo the denominator is strictly greater than 0,
            // 1 is added to round up the division of x * y by the denominator.
            z := add(gt(mod(mul(x, y), denominator), 0), div(mul(x, y), denominator))
        }
    }

    function rpow(
        uint256 x,
        uint256 n,
        uint256 scalar
    ) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            switch x
            case 0 {
                switch n
                case 0 {
                    // 0 ** 0 = 1
                    z := scalar
                }
                default {
                    // 0 ** n = 0
                    z := 0
                }
            }
            default {
                switch mod(n, 2)
                case 0 {
                    // If n is even, store scalar in z for now.
                    z := scalar
                }
                default {
                    // If n is odd, store x in z for now.
                    z := x
                }

                // Shifting right by 1 is like dividing by 2.
                let half := shr(1, scalar)

                for {
                    // Shift n right by 1 before looping to halve it.
                    n := shr(1, n)
                } n {
                    // Shift n right by 1 each iteration to halve it.
                    n := shr(1, n)
                } {
                    // Revert immediately if x ** 2 would overflow.
                    // Equivalent to iszero(eq(div(xx, x), x)) here.
                    if shr(128, x) {
                        revert(0, 0)
                    }

                    // Store x squared.
                    let xx := mul(x, x)

                    // Round to the nearest number.
                    let xxRound := add(xx, half)

                    // Revert if xx + half overflowed.
                    if lt(xxRound, xx) {
                        revert(0, 0)
                    }

                    // Set x to scaled xxRound.
                    x := div(xxRound, scalar)

                    // If n is even:
                    if mod(n, 2) {
                        // Compute z * x.
                        let zx := mul(z, x)

                        // If z * x overflowed:
                        if iszero(eq(div(zx, x), z)) {
                            // Revert if x is non-zero.
                            if iszero(iszero(x)) {
                                revert(0, 0)
                            }
                        }

                        // Round to the nearest number.
                        let zxRound := add(zx, half)

                        // Revert if zx + half overflowed.
                        if lt(zxRound, zx) {
                            revert(0, 0)
                        }

                        // Return properly scaled zxRound.
                        z := div(zxRound, scalar)
                    }
                }
            }
        }
    }

    /*//////////////////////////////////////////////////////////////
                        GENERAL NUMBER UTILITIES
    //////////////////////////////////////////////////////////////*/

    function sqrt(uint256 x) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            let y := x // We start y at x, which will help us make our initial estimate.

            z := 181 // The "correct" value is 1, but this saves a multiplication later.

            // This segment is to get a reasonable initial estimate for the Babylonian method. With a bad
            // start, the correct # of bits increases ~linearly each iteration instead of ~quadratically.

            // We check y >= 2^(k + 8) but shift right by k bits
            // each branch to ensure that if x >= 256, then y >= 256.
            if iszero(lt(y, 0x10000000000000000000000000000000000)) {
                y := shr(128, y)
                z := shl(64, z)
            }
            if iszero(lt(y, 0x1000000000000000000)) {
                y := shr(64, y)
                z := shl(32, z)
            }
            if iszero(lt(y, 0x10000000000)) {
                y := shr(32, y)
                z := shl(16, z)
            }
            if iszero(lt(y, 0x1000000)) {
                y := shr(16, y)
                z := shl(8, z)
            }

            // Goal was to get z*z*y within a small factor of x. More iterations could
            // get y in a tighter range. Currently, we will have y in [256, 256*2^16).
            // We ensured y >= 256 so that the relative difference between y and y+1 is small.
            // That's not possible if x < 256 but we can just verify those cases exhaustively.

            // Now, z*z*y <= x < z*z*(y+1), and y <= 2^(16+8), and either y >= 256, or x < 256.
            // Correctness can be checked exhaustively for x < 256, so we assume y >= 256.
            // Then z*sqrt(y) is within sqrt(257)/sqrt(256) of sqrt(x), or about 20bps.

            // For s in the range [1/256, 256], the estimate f(s) = (181/1024) * (s+1) is in the range
            // (1/2.84 * sqrt(s), 2.84 * sqrt(s)), with largest error when s = 1 and when s = 256 or 1/256.

            // Since y is in [256, 256*2^16), let a = y/65536, so that a is in [1/256, 256). Then we can estimate
            // sqrt(y) using sqrt(65536) * 181/1024 * (a + 1) = 181/4 * (y + 65536)/65536 = 181 * (y + 65536)/2^18.

            // There is no overflow risk here since y < 2^136 after the first branch above.
            z := shr(18, mul(z, add(y, 65536))) // A mul() is saved from starting z at 181.

            // Given the worst case multiplicative error of 2.84 above, 7 iterations should be enough.
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))

            // If x+1 is a perfect square, the Babylonian method cycles between
            // floor(sqrt(x)) and ceil(sqrt(x)). This statement ensures we return floor.
            // See: https://en.wikipedia.org/wiki/Integer_square_root#Using_only_integer_division
            // Since the ceil is rare, we save gas on the assignment and repeat division in the rare case.
            // If you don't care whether the floor or ceil square root is returned, you can remove this statement.
            z := sub(z, lt(div(x, z), z))
        }
    }

    function unsafeMod(uint256 x, uint256 y) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            // Mod x by y. Note this will return
            // 0 instead of reverting if y is zero.
            z := mod(x, y)
        }
    }

    function unsafeDiv(uint256 x, uint256 y) internal pure returns (uint256 r) {
        /// @solidity memory-safe-assembly
        assembly {
            // Divide x by y. Note this will return
            // 0 instead of reverting if y is zero.
            r := div(x, y)
        }
    }

    function unsafeDivUp(uint256 x, uint256 y) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            // Add 1 to x * y if x % y > 0. Note this will
            // return 0 instead of reverting if y is zero.
            z := add(gt(mod(x, y), 0), div(x, y))
        }
    }
}

// src/StakingConstants.sol

/// @notice Contract for shared values between Staking.sol and FeeRecipient.sol.
abstract contract StakingConstants {
    /// @notice Denominator for calculating performance fees, i.e. a `performanceFee` of 10_000 represents 100%.
    uint256 public constant FEE_BASIS = 10_000;
}

// src/interfaces/IStaking.sol

interface IStaking {
    struct DepositData {
        bytes pubkey;
        bytes signature;
        bytes32 deposit_data_root;
    }

    event UserRegistered(address indexed user, address indexed feeRecipient);
    event Deposit(address indexed from, address indexed user, uint256 validators);
    event Staked(address indexed user, bytes[] pubkeys);
    event Refund(address indexed user, uint256 validators);
    event OneTimeFeeSet(uint256);
    event PerformanceFeeSet(uint256);
    event NewTreasury(address indexed oldTreasury, address indexed newTreasury);
    event RefundDelaySet(uint256);

    function depositContract() external view returns (address);

    function treasury() external view returns (address);

    function oneTimeFee() external view returns (uint256);

    function performanceFee() external view returns (uint256);

    function registry(address) external view returns (address);

    function pendingValidators(address) external view returns (uint256);

    function deposit(address user) external payable;
}

// src/lib/SafeTransferLib.sol

/// @notice Gas-efficient safe ETH transfer library that gracefully handles missing return values.
/// @author Copied from Solmate with ERC20 code removed.
/// @author https://github.com/transmissions11/solmate/blob/main/src/utils/SafeTransferLib.sol
library SafeTransferLib {
    /*//////////////////////////////////////////////////////////////
                             ETH OPERATIONS
    //////////////////////////////////////////////////////////////*/

    function safeTransferETH(address to, uint256 amount) internal {
        bool success;

        /// @solidity memory-safe-assembly
        assembly {
            // Transfer the ETH and store if it succeeded or not.
            success := call(gas(), to, amount, 0, 0, 0, 0)
        }

        require(success, "ETH_TRANSFER_FAILED");
    }
}

// src/FeeRecipient.sol

/**
 * @notice Contract set as the `fee_recipient` for all validators belonging to a user. Receives execution layer rewards
 * from block production gas tips and MEV bribes which users can claim via `claimRewards()` function.
 */
contract FeeRecipient is StakingConstants {
    using FixedPointMathLib for uint256;

    IStaking public immutable staking;
    address public immutable user;

    /// @dev Unclaimed rewards that fully belong to user.
    uint256 internal _userRewards;

    event ClaimRewards(uint256 amount);
    event TreasuryClaim(uint256 amount);

    error Unauthorized();
    error NothingToClaim();

    constructor(address user_) {
        staking = IStaking(payable(msg.sender));
        user = user_;
    }

    /// @dev To receive MEV bribes directly transferred to `fee_recipient`.
    receive() external payable {}

    function unclaimedRewards() public view returns (uint256) {
        return address(this).balance - _calcToTreasury(address(this).balance - _userRewards);
    }

    function claimRewards() external onlyUser {
        if (unclaimedRewards() == 0) revert NothingToClaim();

        _treasuryClaim();

        emit ClaimRewards(address(this).balance);
        _userRewards = 0;

        SafeTransferLib.safeTransferETH(user, address(this).balance);
    }

    function treasuryClaim() external onlyTreasury {
        if (_calcToTreasury(address(this).balance - _userRewards) == 0) revert NothingToClaim();
        _treasuryClaim();
    }

    function _treasuryClaim() internal {
        uint256 share = address(this).balance - _userRewards;
        uint256 toTreasury = _calcToTreasury(share);
        if (toTreasury == 0) return; // Do nothing as treasury has nothing to claim.

        emit TreasuryClaim(toTreasury);
        _userRewards += share - toTreasury;

        SafeTransferLib.safeTransferETH(staking.treasury(), toTreasury);
    }

    function _calcToTreasury(uint256 amount_) internal view returns (uint256) {
        return amount_.mulDivDown(staking.performanceFee(), FEE_BASIS);
    }

    modifier onlyUser() {
        if (msg.sender != user) revert Unauthorized();
        _;
    }

    modifier onlyTreasury() {
        if (msg.sender != staking.treasury()) revert Unauthorized();
        _;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"user_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"NothingToClaim","type":"error"},{"inputs":[],"name":"Unauthorized","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ClaimRewards","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TreasuryClaim","type":"event"},{"inputs":[],"name":"FEE_BASIS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claimRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"staking","outputs":[{"internalType":"contract IStaking","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"treasuryClaim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unclaimedRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"user","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

12920:2103:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13730:295;;;;;;;;;;;;;:::i;:::-;;13013:33;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;194:32:1;;;176:51;;164:2;149:18;13013:33:0;;;;;;;;13053:29;;;;;;;;;;;;;;;14033:180;;;;;;;;;;;;;:::i;10638:42::-;;;;;;;;;;;;10674:6;10638:42;;;;;592:25:1;;;580:2;565:18;10638:42:0;446:177:1;13561:161:0;;;;;;;;;;;;;:::i;13730:295::-;14837:10;-1:-1:-1;;;;;14851:4:0;14837:18;;14833:45;;14864:14;;-1:-1:-1;;;14864:14:0;;;;;;;;;;;14833:45;13787:18:::1;:16;:18::i;:::-;13809:1;13787:23:::0;13783:52:::1;;13819:16;;-1:-1:-1::0;;;13819:16:0::1;;;;;;;;;;;13783:52;13848:16;:14;:16::i;:::-;13882:35;::::0;13895:21:::1;592:25:1::0;;13882:35:0::1;::::0;580:2:1;565:18;13882:35:0::1;;;;;;;13943:1;13928:16:::0;;13957:60:::1;13989:4;13995:21;13957:31;:60::i;:::-;13730:295::o:0;14033:180::-;14959:7;-1:-1:-1;;;;;14959:16:0;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;14945:32:0;:10;-1:-1:-1;;;;;14945:32:0;;14941:59;;14986:14;;-1:-1:-1;;;14986:14:0;;;;;;;;;;;14941:59;14095:53:::1;14135:12;;14111:21;:36;;;;:::i;:::-;14095:15;:53::i;:::-;14152:1;14095:58:::0;14091:87:::1;;14162:16;;-1:-1:-1::0;;;14162:16:0::1;;;;;;;;;;;14091:87;14189:16;:14;:16::i;13561:161::-:0;13610:7;13661:53;13701:12;;13677:21;:36;;;;:::i;13661:53::-;13637:77;;:21;:77;:::i;:::-;13630:84;;13561:161;:::o;14221:410::-;14267:13;14307:12;;14283:36;;:21;:36;:::i;:::-;14267:52;;14330:18;14351:22;14367:5;14351:15;:22::i;:::-;14330:43;;14388:10;14402:1;14388:15;14384:28;;14405:7;;14221:410::o;14384:28::-;14477:25;;592::1;;;14477::0;;580:2:1;565:18;14477:25:0;;;;;;;14529:18;14537:10;14529:5;:18;:::i;:::-;14513:12;;:34;;;;;;;:::i;:::-;;;;;;;;14560:63;14592:7;-1:-1:-1;;;;;14592:16:0;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;14612:10;14560:31;:63::i;:::-;14256:375;;14221:410::o;12303:349::-;12376:12;12580:1;12577;12574;12571;12563:6;12559:2;12552:5;12547:35;12536:46;;12613:7;12605:39;;;;-1:-1:-1;;;12605:39:0;;1520:2:1;12605:39:0;;;1502:21:1;1559:2;1539:18;;;1532:30;-1:-1:-1;;;1578:18:1;;;1571:49;1637:18;;12605:39:0;;;;;;;;12365:287;12303:349;;:::o;14639:155::-;14704:7;14731:55;14750:7;-1:-1:-1;;;;;14750:22:0;;:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;14731:7;;10674:6;14731:18;:55::i;:::-;14724:62;14639:155;-1:-1:-1;;14639:155:0:o;1657:541::-;1777:9;2029:1;-1:-1:-1;;2012:19:0;2009:1;2006:26;2003:1;1999:34;1992:42;1979:11;1975:60;1965:118;;2066:1;2063;2056:12;1965:118;-1:-1:-1;2157:9:0;;2153:27;;1657:541::o;628:290:1:-;698:6;751:2;739:9;730:7;726:23;722:32;719:52;;;767:1;764;757:12;719:52;793:16;;-1:-1:-1;;;;;838:31:1;;828:42;;818:70;;884:1;881;874:12;818:70;907:5;628:290;-1:-1:-1;;;628:290:1:o;923:127::-;984:10;979:3;975:20;972:1;965:31;1015:4;1012:1;1005:15;1039:4;1036:1;1029:15;1055:125;1095:4;1123:1;1120;1117:8;1114:34;;;1128:18;;:::i;:::-;-1:-1:-1;1165:9:1;;1055:125::o;1185:128::-;1225:3;1256:1;1252:6;1249:1;1246:13;1243:39;;;1262:18;;:::i;:::-;-1:-1:-1;1298:9:1;;1185:128::o;1666:184::-;1736:6;1789:2;1777:9;1768:7;1764:23;1760:32;1757:52;;;1805:1;1802;1795:12;1757:52;-1:-1:-1;1828:16:1;;1666:184;-1:-1:-1;1666:184:1:o

ipfs://cf8c68186eb03b0415c4e1a451bafa8213a95358dfe1202ce8aa3ce231000363