@towns-protocol/contracts 0.0.302

package/src/base/registry/facets/distribution/v2/IRewardsDistribution.sol

@@ -0,0 +1,372 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.18;
+
+import {StakingRewards} from "./StakingRewards.sol";
+
+interface IRewardsDistributionBase {
+    /// @notice The state of the staking rewards contract
+    /// @param riverToken The token that is being staked and used for rewards
+    /// @param totalStaked The total amount of stakeToken that is staked
+    /// @param rewardDuration The duration of the reward distribution
+    /// @param rewardEndTime The time at which the reward distribution ends
+    /// @param lastUpdateTime The time at which the reward was last updated
+    /// @param rewardRate The scaled rate of reward distributed per second
+    /// @param rewardPerTokenAccumulated The scaled amount of rewardToken that has been accumulated
+    /// per staked token
+    /// @param nextDepositId The next deposit ID that will be used
+    struct StakingState {
+        address riverToken;
+        uint96 totalStaked;
+        uint256 rewardDuration;
+        uint256 rewardEndTime;
+        uint256 lastUpdateTime;
+        uint256 rewardRate;
+        uint256 rewardPerTokenAccumulated;
+        uint256 nextDepositId;
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                       CUSTOM ERRORS                        */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @dev Self-explanatory
+    error RewardsDistribution__NotBeneficiary();
+    error RewardsDistribution__NotClaimer();
+    error RewardsDistribution__NotDepositOwner();
+    error RewardsDistribution__NotRewardNotifier();
+    error RewardsDistribution__NotOperatorOrSpace();
+    error RewardsDistribution__NotActiveOperator();
+    error RewardsDistribution__ExpiredDeadline();
+    error RewardsDistribution__InvalidSignature();
+    error RewardsDistribution__CannotWithdrawFromSelf();
+    error RewardsDistribution__NoPendingWithdrawal();
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           EVENTS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Emitted when the rewards distribution facet is initialized
+    /// @param stakeToken The token that is being staked
+    /// @param rewardToken The token that is being distributed as rewards
+    /// @param rewardDuration The duration of each reward distribution period
+    event RewardsDistributionInitialized(
+        address stakeToken,
+        address rewardToken,
+        uint256 rewardDuration
+    );
+
+    /// @notice Emitted when a delegation proxy is deployed
+    /// @param depositId The ID of the deposit
+    /// @param delegatee The address of the delegatee
+    /// @param proxy The address of the delegation proxy
+    event DelegationProxyDeployed(
+        uint256 indexed depositId,
+        address indexed delegatee,
+        address proxy
+    );
+
+    /// @notice Emitted when a reward notifier is set
+    /// @param notifier The address of the notifier
+    /// @param enabled The whitelist status
+    event RewardNotifierSet(address indexed notifier, bool enabled);
+
+    /// @notice Emitted when the reward amount for a period is set
+    /// @param amount The amount of rewardToken to distribute
+    event PeriodRewardAmountSet(uint256 amount);
+
+    /// @notice Emitted when a deposit is staked
+    /// @param owner The address of the depositor
+    /// @param delegatee The address of the delegatee
+    /// @param beneficiary The address of the beneficiary
+    /// @param depositId The ID of the deposit
+    /// @param amount The amount of stakeToken that is staked
+    event Stake(
+        address indexed owner,
+        address indexed delegatee,
+        address indexed beneficiary,
+        uint256 depositId,
+        uint96 amount
+    );
+
+    /// @notice Emitted when the stake of a deposit is increased
+    /// @param depositId The ID of the deposit
+    /// @param amount The amount of stakeToken that is staked
+    event IncreaseStake(uint256 indexed depositId, uint96 amount);
+
+    /// @notice Emitted when a deposit is redelegated
+    /// @param depositId The ID of the deposit
+    /// @param delegatee The address of the delegatee
+    event Redelegate(uint256 indexed depositId, address indexed delegatee);
+
+    /// @notice Emitted when the beneficiary of a deposit is changed
+    /// @param depositId The ID of the deposit
+    /// @param newBeneficiary The address of the new beneficiary
+    event ChangeBeneficiary(uint256 indexed depositId, address indexed newBeneficiary);
+
+    /// @notice Emitted when the withdrawal of a deposit is initiated
+    /// @param owner The address of the depositor
+    /// @param depositId The ID of the deposit
+    /// @param amount The amount of stakeToken that will be withdrawn
+    event InitiateWithdraw(address indexed owner, uint256 indexed depositId, uint96 amount);
+
+    /// @notice Emitted when the stakeToken is withdrawn from a deposit
+    /// @param depositId The ID of the deposit
+    /// @param amount The amount of stakeToken that is withdrawn
+    event Withdraw(uint256 indexed depositId, uint96 amount);
+
+    /// @notice Emitted when a reward is claimed
+    /// @param beneficiary The address of the beneficiary whose reward is claimed
+    /// @param recipient The address of the recipient where the reward is sent
+    /// @param reward The amount of rewardToken that is claimed
+    event ClaimReward(address indexed beneficiary, address indexed recipient, uint256 reward);
+
+    /// @notice Emitted when a reward is notified
+    /// @param notifier The address of the notifier
+    /// @param reward The amount of rewardToken that is added
+    event NotifyRewardAmount(address indexed notifier, uint256 reward);
+
+    /// @notice Emitted when space delegation rewards are swept to the operator
+    /// @param space The address of the space
+    /// @param operator The address of the operator
+    /// @param scaledReward The scaled amount of rewardToken that is swept
+    event SpaceRewardsSwept(address indexed space, address indexed operator, uint256 scaledReward);
+}
+
+/// @title IRewardsDistribution
+/// @notice The interface for the rewards distribution facet
+interface IRewardsDistribution is IRewardsDistributionBase {
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                       ADMIN FUNCTIONS                      */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Upgrades the delegation proxy implementation in the beacon
+    /// @dev Only the owner can call this function
+    /// @param newImplementation The address of the new implementation
+    function upgradeDelegationProxy(address newImplementation) external;
+
+    /// @notice Sets whitelist status for reward notifiers
+    /// @dev Only the owner can call this function
+    /// @param notifier The address of the notifier
+    /// @param enabled The whitelist status
+    function setRewardNotifier(address notifier, bool enabled) external;
+
+    /// @notice Sets the reward amount for a period
+    /// @dev Only the owner can call this function
+    /// @param amount The amount of rewardToken to distribute
+    function setPeriodRewardAmount(uint256 amount) external;
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                       STATE MUTATING                       */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Stakes the stakeToken for rewards
+    /// @dev The caller must approve the contract to spend the stakeToken
+    /// @param amount The amount of stakeToken to stake
+    /// @param delegatee The address of the delegatee
+    /// @param beneficiary The address of the beneficiary who is receiving the rewards
+    /// @return depositId The ID of the deposit
+    function stake(
+        uint96 amount,
+        address delegatee,
+        address beneficiary
+    ) external returns (uint256 depositId);
+
+    /// @notice Approves the contract to spend the stakeToken with Permit2 and stakes the
+    /// stakeToken for rewards
+    /// @param amount The amount of stakeToken to stake
+    /// @param delegatee The address of the delegatee
+    /// @param beneficiary The address of the beneficiary who is receiving the rewards
+    /// @param nonce The nonce for the permit
+    /// @param deadline The deadline for the permit
+    /// @param signature The signature for the permit
+    /// @return depositId The ID of the deposit
+    function permitAndStake(
+        uint96 amount,
+        address delegatee,
+        address beneficiary,
+        uint256 nonce,
+        uint256 deadline,
+        bytes calldata signature
+    ) external returns (uint256 depositId);
+
+    /// @notice Stakes on behalf of a user with an EIP-712 signature
+    /// @dev The caller must approve the contract to spend the stakeToken
+    /// @param amount The amount of stakeToken to stake
+    /// @param delegatee The address of the delegatee
+    /// @param beneficiary The address of the beneficiary who is receiving the rewards
+    /// @param owner The address of the deposit owner
+    /// @return depositId The ID of the deposit
+    function stakeOnBehalf(
+        uint96 amount,
+        address delegatee,
+        address beneficiary,
+        address owner,
+        uint256,
+        bytes calldata
+    ) external returns (uint256 depositId);
+
+    /// @notice Increases the stake of an existing deposit
+    /// @dev The caller must be the owner of the deposit
+    /// @dev The caller must approve the contract to spend the stakeToken
+    /// @param depositId The ID of the deposit
+    /// @param amount The amount of stakeToken to stake
+    function increaseStake(uint256 depositId, uint96 amount) external;
+
+    /// @notice Approves the contract to spend the stakeToken with Permit2 and increases
+    /// the stake of an existing deposit
+    /// @dev The caller must be the owner of the deposit
+    /// @param depositId The ID of the deposit
+    /// @param amount The amount of stakeToken to stake
+    /// @param nonce The nonce for the permit
+    /// @param deadline The deadline for the permit
+    /// @param signature The signature for the permit
+    function permitAndIncreaseStake(
+        uint256 depositId,
+        uint96 amount,
+        uint256 nonce,
+        uint256 deadline,
+        bytes calldata signature
+    ) external;
+
+    /// @notice Redelegates an existing deposit to a new delegatee or reactivates a pending
+    /// withdrawal
+    /// @dev The caller must be the owner of the deposit
+    /// @param depositId The ID of the deposit
+    /// @param delegatee The address of the new delegatee
+    function redelegate(uint256 depositId, address delegatee) external;
+
+    /// @notice Changes the beneficiary of a deposit
+    /// @dev The caller must be the owner of the deposit
+    /// @param depositId The ID of the deposit
+    /// @param newBeneficiary The address of the new beneficiary
+    function changeBeneficiary(uint256 depositId, address newBeneficiary) external;
+
+    /// @notice Initiates the withdrawal of a deposit, subject to the lockup period
+    /// @dev The caller must be the owner of the deposit
+    /// @param depositId The ID of the deposit
+    /// @return amount The amount of stakeToken that will be withdrawn
+    function initiateWithdraw(uint256 depositId) external returns (uint96 amount);
+
+    /// @notice Withdraws the stakeToken from a deposit
+    /// @dev The caller must be the owner of the deposit
+    /// @param depositId The ID of the deposit
+    /// @return amount The amount of stakeToken that is withdrawn
+    function withdraw(uint256 depositId) external returns (uint96 amount);
+
+    /// @notice Claims accumulated rewards for a beneficiary and sends them to a recipient
+    ///
+    /// @dev **For Regular Users (Stakers):**
+    /// - Call with `beneficiary = your_address` to claim your own staking rewards
+    /// - You can send rewards to any `recipient` address (yourself or someone else)
+    ///
+    /// @dev **For Node Operators:**
+    /// - Operators earn commission from delegated stakes and can claim their own operator rewards
+    /// - Call with `beneficiary = operator_address` to claim operator commission rewards
+    /// - Only the operator's designated claimer can call this function for the operator
+    ///
+    /// @dev **For Space Rewards:**
+    /// - Spaces accumulate rewards from users who delegate to them
+    /// - Only the space's current operator's claimer can claim space rewards
+    /// - Call with `beneficiary = space_address` to claim rewards accumulated by the space
+    /// - Space rewards are automatically transferred to the operator when claimed
+    ///
+    /// @dev **Authorization Rules:**
+    /// 1. Self-claim: Anyone can claim their own rewards (`msg.sender == beneficiary`)
+    /// 2. Authorized claimer: If you're set as the authorized claimer for a beneficiary
+    /// 3. Operator claimer: Only operator's claimer can claim operator rewards
+    /// 4. Space operator claimer: Only the space's operator's claimer can claim space rewards
+    ///
+    /// @param beneficiary The address whose rewards are being claimed (user, operator, or space)
+    /// @param recipient The address where the claimed reward tokens will be sent
+    /// @return reward The amount of reward tokens claimed and transferred
+    function claimReward(address beneficiary, address recipient) external returns (uint256 reward);
+
+    /// @notice Notifies the contract of an incoming reward
+    /// @dev The caller must be a reward notifier
+    /// @param reward The amount of rewardToken that has been added
+    function notifyRewardAmount(uint256 reward) external;
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          GETTERS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Returns the current state of the staking rewards contract
+    /// @return Staking state variables
+    /// riverToken The token that is being staked and used for rewards
+    /// totalStaked The total amount of stakeToken that is staked
+    /// rewardDuration The duration of the reward distribution
+    /// rewardEndTime The time at which the reward distribution ends
+    /// lastUpdateTime The time at which the reward was last updated
+    /// rewardRate The scaled rate of reward distributed per second
+    /// rewardPerTokenAccumulated The scaled amount of rewardToken that has been accumulated per
+    /// staked token
+    /// nextDepositId The next deposit ID that will be used
+    function stakingState() external view returns (StakingState memory);
+
+    /// @notice Returns the amount of stakeToken that is staked by a particular depositor
+    /// @param depositor The address of the depositor
+    /// @return amount The amount of stakeToken that is staked by the depositor
+    function stakedByDepositor(address depositor) external view returns (uint96 amount);
+
+    /// @notice Returns the deposit IDs for a particular depositor
+    /// @param depositor The address of the depositor
+    /// @return The deposit IDs for the depositor
+    function getDepositsByDepositor(address depositor) external view returns (uint256[] memory);
+
+    /// @notice Returns the account information for a beneficiary
+    /// @param beneficiary The address of the beneficiary
+    /// @return The account information for the beneficiary
+    /// earningPower The amount of stakeToken that is yielding rewards
+    /// rewardPerTokenAccumulated The scaled amount of rewardToken that has been accumulated per
+    /// staked token
+    /// unclaimedRewardSnapshot The snapshot of the unclaimed reward scaled
+    function treasureByBeneficiary(
+        address beneficiary
+    ) external view returns (StakingRewards.Treasure memory);
+
+    /// @notice Returns the information for a deposit
+    /// @param depositId The ID of the deposit
+    /// @return The information for the deposit
+    /// amount The amount of stakeToken that is staked
+    /// owner The address of the depositor
+    /// commissionEarningPower The amount of stakeToken assigned to the commission
+    /// delegatee The address of the delegatee
+    /// pendingWithdrawal The amount of stakeToken that is pending withdrawal
+    /// beneficiary The address of the beneficiary
+    function depositById(uint256 depositId) external view returns (StakingRewards.Deposit memory);
+
+    /// @notice Returns the address of the delegation proxy for a deposit
+    /// @param depositId The ID of the deposit
+    /// @return The address of the delegation proxy
+    function delegationProxyById(uint256 depositId) external view returns (address);
+
+    /// @notice Returns whether a particular address is a reward notifier
+    /// @param notifier The address to check
+    /// @return True if the address is a reward notifier
+    function isRewardNotifier(address notifier) external view returns (bool);
+
+    /// @notice Returns the lesser of rewardEndTime and the current time
+    /// @return The lesser of rewardEndTime and the current time
+    function lastTimeRewardDistributed() external view returns (uint256);
+
+    /// @notice Returns the current scaled amount of rewardToken that has been accumulated per
+    /// staked token
+    /// @return The current scaled amount of rewardToken that has been accumulated per staked token
+    function currentRewardPerTokenAccumulated() external view returns (uint256);
+
+    /// @notice Returns the current unclaimed reward for a beneficiary
+    /// @param beneficiary The address of the beneficiary who is receiving the rewards
+    /// @return The current unclaimed reward for the beneficiary
+    function currentReward(address beneficiary) external view returns (uint256);
+
+    /// @notice Returns the current unclaimed reward for an operator from delegating spaces
+    /// @param operator The address of the operator
+    /// @return The current unclaimed reward for the operator from delegating spaces
+    function currentSpaceDelegationReward(address operator) external view returns (uint256);
+
+    /// @notice Returns the implementation stored in the beacon
+    function implementation() external view returns (address);
+
+    /// @notice Returns the period reward amount
+    function getPeriodRewardAmount() external view returns (uint256);
+}

package/src/base/registry/facets/distribution/v2/RewardsDistributionBase.sol

@@ -0,0 +1,299 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IRewardsDistributionBase} from "./IRewardsDistribution.sol";
+import {ISignatureTransfer} from "@uniswap/permit2/src/interfaces/ISignatureTransfer.sol";
+
+// libraries
+import {CustomRevert} from "../../../../../utils/libraries/CustomRevert.sol";
+import {SpaceDelegationStorage} from "../../delegation/SpaceDelegationStorage.sol";
+import {NodeOperatorStatus, NodeOperatorStorage} from "../../operator/NodeOperatorStorage.sol";
+import {RewardsDistributionStorage} from "./RewardsDistributionStorage.sol";
+import {StakingRewards} from "./StakingRewards.sol";
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+import {FixedPointMathLib} from "solady/utils/FixedPointMathLib.sol";
+import {LibClone} from "solady/utils/LibClone.sol";
+import {SafeTransferLib} from "solady/utils/SafeTransferLib.sol";
+import {SignatureCheckerLib} from "solady/utils/SignatureCheckerLib.sol";
+
+// contracts
+import {DelegationProxy} from "./DelegationProxy.sol";
+
+abstract contract RewardsDistributionBase is IRewardsDistributionBase {
+    using CustomRevert for bytes4;
+    using EnumerableSet for EnumerableSet.AddressSet;
+    using EnumerableSet for EnumerableSet.UintSet;
+    using SafeTransferLib for address;
+    using StakingRewards for StakingRewards.Layout;
+
+    /// @notice Universal Permit2 contract address
+    address internal constant PERMIT2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           STAKING                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Creates a new staking deposit for the specified owner
+    /// @dev Validates delegatee, deploys proxy, transfers tokens, and updates accounting
+    /// @param amount Amount of stake tokens to deposit
+    /// @param delegatee Address to delegate to (operator or space)
+    /// @param beneficiary Address that receives staking rewards
+    /// @param owner Address that owns the deposit
+    /// @param fromPermit Whether tokens are already in contract from permit
+    /// @return depositId The unique ID for this deposit
+    function _stake(
+        uint96 amount,
+        address delegatee,
+        address beneficiary,
+        address owner,
+        bool fromPermit
+    ) internal returns (uint256 depositId) {
+        _revertIfNotOperatorOrSpace(delegatee);
+
+        RewardsDistributionStorage.Layout storage ds = RewardsDistributionStorage.layout();
+        depositId = ds.staking.stake(
+            owner,
+            amount,
+            delegatee,
+            beneficiary,
+            _getCommissionRate(delegatee)
+        );
+
+        _sweepSpaceRewardsIfNecessary(delegatee);
+
+        if (owner != address(this)) {
+            address proxy = _deployDelegationProxy(depositId, delegatee);
+            if (!fromPermit) {
+                ds.staking.stakeToken.safeTransferFrom(msg.sender, proxy, amount);
+            } else {
+                ds.staking.stakeToken.safeTransfer(proxy, amount);
+            }
+        }
+        ds.depositsByDepositor[owner].add(depositId);
+
+        emit Stake(owner, delegatee, beneficiary, depositId, amount);
+    }
+
+    /// @notice Increases the stake amount for an existing deposit
+    /// @dev Validates ownership, transfers additional tokens, and updates deposit accounting
+    /// @param depositId The ID of the existing deposit to increase
+    /// @param amount Additional amount of stake tokens to add
+    /// @param fromPermit Whether tokens are already in contract from permit
+    function _increaseStake(uint256 depositId, uint96 amount, bool fromPermit) internal {
+        RewardsDistributionStorage.Layout storage ds = RewardsDistributionStorage.layout();
+        StakingRewards.Deposit storage deposit = ds.staking.depositById[depositId];
+        address owner = deposit.owner;
+        _revertIfNotDepositOwner(owner);
+
+        address delegatee = deposit.delegatee;
+        _revertIfNotOperatorOrSpace(delegatee);
+
+        ds.staking.increaseStake(
+            deposit,
+            owner,
+            amount,
+            delegatee,
+            deposit.beneficiary,
+            _getCommissionRate(delegatee)
+        );
+
+        _sweepSpaceRewardsIfNecessary(delegatee);
+
+        if (owner != address(this)) {
+            address proxy = ds.proxyById[depositId];
+            if (!fromPermit) {
+                ds.staking.stakeToken.safeTransferFrom(msg.sender, proxy, amount);
+            } else {
+                ds.staking.stakeToken.safeTransfer(proxy, amount);
+            }
+        }
+
+        emit IncreaseStake(depositId, amount);
+    }
+
+    /**
+     * @notice Executes a Permit2 transfer using signed permit for stake token authorization
+     * @dev This function uses Uniswap's Permit2 protocol instead of EIP-2612 to enable
+     * smart contract wallet support through ERC-1271 signature verification.
+     *
+     * Design Principles:
+     * - Uses `permitTransferFrom` (not `permitWitnessTransferFrom`) since staking doesn't
+     *   require binding signatures to additional contract-specific parameters
+     * - Transfers tokens directly from caller to RewardsDistribution contract address
+     * - Supports both EOA signatures (via ecrecover) and smart contract signatures (via ERC-1271)
+     * - Towns token gives Permit2 infinite allowance by default, so no pre-approval needed
+     *
+     * Security Considerations:
+     * - Front-running protection: The permit signature cryptographically binds the owner
+     *   field to `msg.sender`. An attacker cannot use someone else's permit signature
+     *   because the signature verification will fail when called by a different address.
+     * - The beneficiary parameter can be specified by the caller, but the attacker cannot
+     *   execute the permit without being the original signer, so no funds can be stolen.
+     * - Users must have pre-approved tokens to Permit2 contract before calling this function.
+     *
+     * @param amount The amount of stake tokens to transfer
+     * @param nonce The unique nonce for this permit to prevent replay attacks
+     * @param deadline The deadline after which the permit expires
+     * @param signature The signature authorizing the transfer (supports both EOA and smart contract wallets)
+     */
+    function _permitStakeToken(
+        uint96 amount,
+        uint256 nonce,
+        uint256 deadline,
+        bytes calldata signature
+    ) internal {
+        address stakeToken = RewardsDistributionStorage.layout().staking.stakeToken;
+
+        // execute permit transfer from the caller to this contract via Permit2
+        ISignatureTransfer(PERMIT2).permitTransferFrom(
+            ISignatureTransfer.PermitTransferFrom(
+                ISignatureTransfer.TokenPermissions(stakeToken, amount),
+                nonce,
+                deadline
+            ),
+            ISignatureTransfer.SignatureTransferDetails({
+                to: address(this),
+                requestedAmount: amount
+            }),
+            msg.sender, // owner has to be the caller
+            signature
+        );
+    }
+
+    /// @dev Deploys a beacon proxy for the delegation
+    function _deployDelegationProxy(
+        uint256 depositId,
+        address delegatee
+    ) internal returns (address proxy) {
+        RewardsDistributionStorage.Layout storage ds = RewardsDistributionStorage.layout();
+        proxy = LibClone.deployDeterministicERC1967BeaconProxy(address(this), bytes32(depositId));
+        ds.proxyById[depositId] = proxy;
+        DelegationProxy(proxy).initialize(ds.staking.stakeToken, delegatee);
+
+        emit DelegationProxyDeployed(depositId, delegatee, proxy);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          OPERATOR                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @dev Returns the commission rate of the operator or space
+    function _getCommissionRate(address delegatee) internal view returns (uint256) {
+        // if the delegatee is a space, get the active operator or revert
+        if (_isSpace(delegatee)) {
+            delegatee = _getValidOperatorOrRevert(delegatee);
+        }
+        NodeOperatorStorage.Layout storage nos = NodeOperatorStorage.layout();
+        return nos.commissionByOperator[delegatee];
+    }
+
+    /// @dev Checks if the delegatee is an operator
+    function _isOperator(address delegatee) internal view returns (bool) {
+        NodeOperatorStorage.Layout storage nos = NodeOperatorStorage.layout();
+        return nos.operators.contains(delegatee);
+    }
+
+    /// @dev Checks if the delegatee is an active operator
+    function _isValidOperator(address delegatee) internal view returns (bool) {
+        NodeOperatorStorage.Layout storage nos = NodeOperatorStorage.layout();
+        if (!nos.operators.contains(delegatee)) return false;
+        NodeOperatorStatus status = nos.statusByOperator[delegatee];
+        return status == NodeOperatorStatus.Approved || status == NodeOperatorStatus.Active;
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                      SPACE DELEGATION                      */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @dev Sweeps the rewards in the space delegation to the operator if necessary
+    function _sweepSpaceRewardsIfNecessary(address space) internal {
+        address operator = _getOperatorBySpace(space);
+        if (operator == address(0)) return;
+
+        StakingRewards.Layout storage staking = RewardsDistributionStorage.layout().staking;
+        uint256 scaledReward = staking.transferReward(space, operator);
+
+        if (scaledReward != 0) emit SpaceRewardsSwept(space, operator, scaledReward);
+    }
+
+    /// @dev Checks if the delegatee is a space
+    function _isSpace(address delegatee) internal view returns (bool) {
+        return _getOperatorBySpace(delegatee) != address(0);
+    }
+
+    /// @dev Returns the operator of the space
+    function _getOperatorBySpace(address space) internal view returns (address operator) {
+        SpaceDelegationStorage.Layout storage sd = SpaceDelegationStorage.layout();
+        operator = sd.operatorBySpace[space];
+    }
+
+    /// @dev Returns the active operator of the space or reverts
+    function _getValidOperatorOrRevert(address space) internal view returns (address operator) {
+        operator = _getOperatorBySpace(space);
+        if (!_isValidOperator(operator)) {
+            RewardsDistribution__NotActiveOperator.selector.revertWith();
+        }
+    }
+
+    function _currentSpaceDelegationReward(address operator) internal view returns (uint256 total) {
+        StakingRewards.Layout storage staking = RewardsDistributionStorage.layout().staking;
+        address[] memory spaces = SpaceDelegationStorage
+            .layout()
+            .spacesByOperator[operator]
+            .values();
+
+        uint256 currentRewardPerTokenAccumulated = staking.currentRewardPerTokenAccumulated();
+        uint256 rewardPerTokenGrowth;
+        for (uint256 i; i < spaces.length; ++i) {
+            StakingRewards.Treasure storage treasure = staking.treasureByBeneficiary[spaces[i]];
+            unchecked {
+                rewardPerTokenGrowth =
+                    currentRewardPerTokenAccumulated -
+                    treasure.rewardPerTokenAccumulated;
+            }
+            total +=
+                treasure.unclaimedRewardSnapshot +
+                (uint256(treasure.earningPower) * rewardPerTokenGrowth);
+        }
+        total /= StakingRewards.SCALE_FACTOR;
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                        SANITY CHECKS                       */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @dev Reverts if the delegatee is not an operator or space
+    function _revertIfNotOperatorOrSpace(address delegatee) internal view {
+        if (_isSpace(delegatee)) return;
+        if (!_isValidOperator(delegatee)) {
+            RewardsDistribution__NotOperatorOrSpace.selector.revertWith();
+        }
+    }
+
+    /// @dev Reverts if the caller is not the owner of the deposit
+    function _revertIfNotDepositOwner(address owner) internal view {
+        if (msg.sender != owner) RewardsDistribution__NotDepositOwner.selector.revertWith();
+    }
+
+    /// @dev Checks if the caller is the claimer of the operator
+    function _revertIfNotOperatorClaimer(address operator) internal view {
+        NodeOperatorStorage.Layout storage nos = NodeOperatorStorage.layout();
+        address claimer = nos.claimerByOperator[operator];
+        if (msg.sender != claimer) RewardsDistribution__NotClaimer.selector.revertWith();
+    }
+
+    function _revertIfPastDeadline(uint256 deadline) internal view {
+        if (block.timestamp > deadline) RewardsDistribution__ExpiredDeadline.selector.revertWith();
+    }
+
+    function _revertIfSignatureIsNotValidNow(
+        address signer,
+        bytes32 hash,
+        bytes calldata signature
+    ) internal view {
+        if (!SignatureCheckerLib.isValidSignatureNowCalldata(signer, hash, signature)) {
+            RewardsDistribution__InvalidSignature.selector.revertWith();
+        }
+    }
+}