Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.27;

import "@openzeppelin-upgrades/contracts/proxy/utils/Initializable.sol";
import "@openzeppelin-upgrades/contracts/access/OwnableUpgradeable.sol";
import "@openzeppelin-upgrades/contracts/security/ReentrancyGuardUpgradeable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

import "../libraries/Merkle.sol";
import "../permissions/Pausable.sol";
import "./storage/RewardsCoordinatorStorage.sol";
import "../mixins/PermissionControllerMixin.sol";

/// @title RewardsCoordinator
/// @author Eigen Labs Inc.
/// @notice Terms of Service: https://docs.eigenlayer.xyz/overview/terms-of-service
/// @notice  This is the contract for rewards in EigenLayer. The main functionalities of this contract are
/// - enabling any ERC20 rewards from AVSs to their operators and stakers for a given time range
/// - allowing stakers and operators to claim their earnings including a split bips for operators
/// - allowing the protocol to provide ERC20 tokens to stakers over a specified time range
contract RewardsCoordinator is
    Initializable,
    OwnableUpgradeable,
    Pausable,
    ReentrancyGuardUpgradeable,
    RewardsCoordinatorStorage,
    PermissionControllerMixin
{
    using SafeERC20 for IERC20;
    using OperatorSetLib for OperatorSet;

    modifier onlyRewardsUpdater() {
        require(msg.sender == rewardsUpdater, UnauthorizedCaller());
        _;
    }

    modifier onlyRewardsForAllSubmitter() {
        require(isRewardsForAllSubmitter[msg.sender], UnauthorizedCaller());
        _;
    }

    /// @dev Sets the immutable variables for the contract
    constructor(
        RewardsCoordinatorConstructorParams memory params
    )
        RewardsCoordinatorStorage(
            params.delegationManager,
            params.strategyManager,
            params.allocationManager,
            params.CALCULATION_INTERVAL_SECONDS,
            params.MAX_REWARDS_DURATION,
            params.MAX_RETROACTIVE_LENGTH,
            params.MAX_FUTURE_LENGTH,
            params.GENESIS_REWARDS_TIMESTAMP
        )
        Pausable(params.pauserRegistry)
        PermissionControllerMixin(params.permissionController)
    {
        _disableInitializers();
    }

    /// @dev Initializes the addresses of the initial owner, pauser registry, rewardsUpdater and
    /// configures the initial paused status, activationDelay, and defaultOperatorSplitBips.
    /// @inheritdoc IRewardsCoordinator
    function initialize(
        address initialOwner,
        uint256 initialPausedStatus,
        address _rewardsUpdater,
        uint32 _activationDelay,
        uint16 _defaultSplitBips
    ) external initializer {
        _setPausedStatus(initialPausedStatus);
        _transferOwnership(initialOwner);
        _setRewardsUpdater(_rewardsUpdater);
        _setActivationDelay(_activationDelay);
        _setDefaultOperatorSplit(_defaultSplitBips);
    }

    ///
    ///                         EXTERNAL FUNCTIONS
    ///

    /// @inheritdoc IRewardsCoordinator
    function createAVSRewardsSubmission(
        RewardsSubmission[] calldata rewardsSubmissions
    ) external onlyWhenNotPaused(PAUSED_AVS_REWARDS_SUBMISSION) nonReentrant {
        for (uint256 i = 0; i < rewardsSubmissions.length; i++) {
            RewardsSubmission calldata rewardsSubmission = rewardsSubmissions[i];
            uint256 nonce = submissionNonce[msg.sender];
            bytes32 rewardsSubmissionHash = keccak256(abi.encode(msg.sender, nonce, rewardsSubmission));

            _validateRewardsSubmission(rewardsSubmission);

            isAVSRewardsSubmissionHash[msg.sender][rewardsSubmissionHash] = true;
            submissionNonce[msg.sender] = nonce + 1;

            emit AVSRewardsSubmissionCreated(msg.sender, nonce, rewardsSubmissionHash, rewardsSubmission);
            rewardsSubmission.token.safeTransferFrom(msg.sender, address(this), rewardsSubmission.amount);
        }
    }

    /// @inheritdoc IRewardsCoordinator
    function createRewardsForAllSubmission(
        RewardsSubmission[] calldata rewardsSubmissions
    ) external onlyWhenNotPaused(PAUSED_REWARDS_FOR_ALL_SUBMISSION) onlyRewardsForAllSubmitter nonReentrant {
        for (uint256 i = 0; i < rewardsSubmissions.length; i++) {
            RewardsSubmission calldata rewardsSubmission = rewardsSubmissions[i];
            uint256 nonce = submissionNonce[msg.sender];
            bytes32 rewardsSubmissionForAllHash = keccak256(abi.encode(msg.sender, nonce, rewardsSubmission));

            _validateRewardsSubmission(rewardsSubmission);

            isRewardsSubmissionForAllHash[msg.sender][rewardsSubmissionForAllHash] = true;
            submissionNonce[msg.sender] = nonce + 1;

            emit RewardsSubmissionForAllCreated(msg.sender, nonce, rewardsSubmissionForAllHash, rewardsSubmission);
            rewardsSubmission.token.safeTransferFrom(msg.sender, address(this), rewardsSubmission.amount);
        }
    }

    /// @inheritdoc IRewardsCoordinator
    function createRewardsForAllEarners(
        RewardsSubmission[] calldata rewardsSubmissions
    ) external onlyWhenNotPaused(PAUSED_REWARD_ALL_STAKERS_AND_OPERATORS) onlyRewardsForAllSubmitter nonReentrant {
        for (uint256 i = 0; i < rewardsSubmissions.length; i++) {
            RewardsSubmission calldata rewardsSubmission = rewardsSubmissions[i];
            uint256 nonce = submissionNonce[msg.sender];
            bytes32 rewardsSubmissionForAllEarnersHash = keccak256(abi.encode(msg.sender, nonce, rewardsSubmission));

            _validateRewardsSubmission(rewardsSubmission);

            isRewardsSubmissionForAllEarnersHash[msg.sender][rewardsSubmissionForAllEarnersHash] = true;
            submissionNonce[msg.sender] = nonce + 1;

            emit RewardsSubmissionForAllEarnersCreated(
                msg.sender,
                nonce,
                rewardsSubmissionForAllEarnersHash,
                rewardsSubmission
            );
            rewardsSubmission.token.safeTransferFrom(msg.sender, address(this), rewardsSubmission.amount);
        }
    }

    /// @inheritdoc IRewardsCoordinator
    function createOperatorDirectedAVSRewardsSubmission(
        address avs,
        OperatorDirectedRewardsSubmission[] calldata operatorDirectedRewardsSubmissions
    ) external onlyWhenNotPaused(PAUSED_OPERATOR_DIRECTED_AVS_REWARDS_SUBMISSION) checkCanCall(avs) nonReentrant {
        for (uint256 i = 0; i < operatorDirectedRewardsSubmissions.length; i++) {
            OperatorDirectedRewardsSubmission calldata operatorDirectedRewardsSubmission =
                operatorDirectedRewardsSubmissions[i];
            uint256 nonce = submissionNonce[avs];
            bytes32 operatorDirectedRewardsSubmissionHash =
                keccak256(abi.encode(avs, nonce, operatorDirectedRewardsSubmission));

            uint256 totalAmount = _validateOperatorDirectedRewardsSubmission(operatorDirectedRewardsSubmission);

            isOperatorDirectedAVSRewardsSubmissionHash[avs][operatorDirectedRewardsSubmissionHash] = true;
            submissionNonce[avs] = nonce + 1;

            emit OperatorDirectedAVSRewardsSubmissionCreated(
                msg.sender,
                avs,
                operatorDirectedRewardsSubmissionHash,
                nonce,
                operatorDirectedRewardsSubmission
            );
            operatorDirectedRewardsSubmission.token.safeTransferFrom(msg.sender, address(this), totalAmount);
        }
    }

    /// @inheritdoc IRewardsCoordinator
    function createOperatorDirectedOperatorSetRewardsSubmission(
        OperatorSet calldata operatorSet,
        OperatorDirectedRewardsSubmission[] calldata operatorDirectedRewardsSubmissions
    )
        external
        onlyWhenNotPaused(PAUSED_OPERATOR_DIRECTED_OPERATOR_SET_REWARDS_SUBMISSION)
        checkCanCall(operatorSet.avs)
        nonReentrant
    {
        require(allocationManager.isOperatorSet(operatorSet), InvalidOperatorSet());
        for (uint256 i = 0; i < operatorDirectedRewardsSubmissions.length; i++) {
            OperatorDirectedRewardsSubmission calldata operatorDirectedRewardsSubmission =
                operatorDirectedRewardsSubmissions[i];
            uint256 nonce = submissionNonce[operatorSet.avs];
            bytes32 operatorDirectedRewardsSubmissionHash =
                keccak256(abi.encode(operatorSet.avs, nonce, operatorDirectedRewardsSubmission));

            uint256 totalAmount = _validateOperatorDirectedRewardsSubmission(operatorDirectedRewardsSubmission);

            isOperatorDirectedOperatorSetRewardsSubmissionHash[operatorSet.avs][operatorDirectedRewardsSubmissionHash] =
                true;
            submissionNonce[operatorSet.avs] = nonce + 1;

            emit OperatorDirectedOperatorSetRewardsSubmissionCreated(
                msg.sender,
                operatorDirectedRewardsSubmissionHash,
                operatorSet,
                nonce,
                operatorDirectedRewardsSubmission
            );
            operatorDirectedRewardsSubmission.token.safeTransferFrom(msg.sender, address(this), totalAmount);
        }
    }

    /// @inheritdoc IRewardsCoordinator
    function processClaim(
        RewardsMerkleClaim calldata claim,
        address recipient
    ) external onlyWhenNotPaused(PAUSED_PROCESS_CLAIM) nonReentrant {
        _processClaim(claim, recipient);
    }

    /// @inheritdoc IRewardsCoordinator
    function processClaims(
        RewardsMerkleClaim[] calldata claims,
        address recipient
    ) external onlyWhenNotPaused(PAUSED_PROCESS_CLAIM) nonReentrant {
        for (uint256 i = 0; i < claims.length; i++) {
            _processClaim(claims[i], recipient);
        }
    }

    /// @inheritdoc IRewardsCoordinator
    function submitRoot(
        bytes32 root,
        uint32 rewardsCalculationEndTimestamp
    ) external onlyWhenNotPaused(PAUSED_SUBMIT_DISABLE_ROOTS) onlyRewardsUpdater {
        require(
            rewardsCalculationEndTimestamp > currRewardsCalculationEndTimestamp, NewRootMustBeForNewCalculatedPeriod()
        );
        require(rewardsCalculationEndTimestamp < block.timestamp, RewardsEndTimestampNotElapsed());
        uint32 rootIndex = uint32(_distributionRoots.length);
        uint32 activatedAt = uint32(block.timestamp) + activationDelay;
        _distributionRoots.push(
            DistributionRoot({
                root: root,
                activatedAt: activatedAt,
                rewardsCalculationEndTimestamp: rewardsCalculationEndTimestamp,
                disabled: false
            })
        );
        currRewardsCalculationEndTimestamp = rewardsCalculationEndTimestamp;
        emit DistributionRootSubmitted(rootIndex, root, rewardsCalculationEndTimestamp, activatedAt);
    }

    /// @inheritdoc IRewardsCoordinator
    function disableRoot(
        uint32 rootIndex
    ) external onlyWhenNotPaused(PAUSED_SUBMIT_DISABLE_ROOTS) onlyRewardsUpdater {
        require(rootIndex < _distributionRoots.length, InvalidRootIndex());
        DistributionRoot storage root = _distributionRoots[rootIndex];
        require(!root.disabled, RootDisabled());
        require(block.timestamp < root.activatedAt, RootAlreadyActivated());
        root.disabled = true;
        emit DistributionRootDisabled(rootIndex);
    }

    /// @inheritdoc IRewardsCoordinator
    function setClaimerFor(
        address claimer
    ) external {
        address earner = msg.sender;
        _setClaimer(earner, claimer);
    }

    /// @inheritdoc IRewardsCoordinator
    function setClaimerFor(
        address earner,
        address claimer
    ) external checkCanCall(earner) {
        // Require that the earner is an operator or AVS
        require(
            delegationManager.isOperator(earner) || allocationManager.getOperatorSetCount(earner) > 0, InvalidEarner()
        );
        _setClaimer(earner, claimer);
    }

    /// @inheritdoc IRewardsCoordinator
    function setActivationDelay(
        uint32 _activationDelay
    ) external onlyOwner {
        _setActivationDelay(_activationDelay);
    }

    /// @inheritdoc IRewardsCoordinator
    function setDefaultOperatorSplit(
        uint16 split
    ) external onlyOwner {
        _setDefaultOperatorSplit(split);
    }

    /// @inheritdoc IRewardsCoordinator
    function setOperatorAVSSplit(
        address operator,
        address avs,
        uint16 split
    ) external onlyWhenNotPaused(PAUSED_OPERATOR_AVS_SPLIT) checkCanCall(operator) {
        uint32 activatedAt = uint32(block.timestamp) + activationDelay;
        uint16 oldSplit = _getOperatorSplit(_operatorAVSSplitBips[operator][avs]);
        _setOperatorSplit(_operatorAVSSplitBips[operator][avs], split, activatedAt);

        emit OperatorAVSSplitBipsSet(msg.sender, operator, avs, activatedAt, oldSplit, split);
    }

    /// @inheritdoc IRewardsCoordinator
    function setOperatorPISplit(
        address operator,
        uint16 split
    ) external onlyWhenNotPaused(PAUSED_OPERATOR_PI_SPLIT) checkCanCall(operator) {
        uint32 activatedAt = uint32(block.timestamp) + activationDelay;
        uint16 oldSplit = _getOperatorSplit(_operatorPISplitBips[operator]);
        _setOperatorSplit(_operatorPISplitBips[operator], split, activatedAt);

        emit OperatorPISplitBipsSet(msg.sender, operator, activatedAt, oldSplit, split);
    }

    /// @inheritdoc IRewardsCoordinator
    function setOperatorSetSplit(
        address operator,
        OperatorSet calldata operatorSet,
        uint16 split
    ) external onlyWhenNotPaused(PAUSED_OPERATOR_SET_SPLIT) checkCanCall(operator) {
        require(allocationManager.isOperatorSet(operatorSet), InvalidOperatorSet());

        uint32 activatedAt = uint32(block.timestamp) + activationDelay;
        uint16 oldSplit = _getOperatorSplit(_operatorSetSplitBips[operator][operatorSet.key()]);
        _setOperatorSplit(_operatorSetSplitBips[operator][operatorSet.key()], split, activatedAt);

        emit OperatorSetSplitBipsSet(msg.sender, operator, operatorSet, activatedAt, oldSplit, split);
    }

    /// @inheritdoc IRewardsCoordinator
    function setRewardsUpdater(
        address _rewardsUpdater
    ) external onlyOwner {
        _setRewardsUpdater(_rewardsUpdater);
    }

    /// @inheritdoc IRewardsCoordinator
    function setRewardsForAllSubmitter(
        address _submitter,
        bool _newValue
    ) external onlyOwner {
        bool prevValue = isRewardsForAllSubmitter[_submitter];
        emit RewardsForAllSubmitterSet(_submitter, prevValue, _newValue);
        isRewardsForAllSubmitter[_submitter] = _newValue;
    }

    ///
    ///                         INTERNAL FUNCTIONS
    ///

    /// @notice Internal helper to process reward claims.
    /// @param claim The RewardsMerkleClaims to be processed.
    /// @param recipient The address recipient that receives the ERC20 rewards
    function _processClaim(
        RewardsMerkleClaim calldata claim,
        address recipient
    ) internal {
        DistributionRoot memory root = _distributionRoots[claim.rootIndex];
        _checkClaim(claim, root);
        // If claimerFor earner is not set, claimer is by default the earner. Else set to claimerFor
        address earner = claim.earnerLeaf.earner;
        address claimer = claimerFor[earner];
        if (claimer == address(0)) {
            claimer = earner;
        }
        require(msg.sender == claimer, UnauthorizedCaller());
        for (uint256 i = 0; i < claim.tokenIndices.length; i++) {
            TokenTreeMerkleLeaf calldata tokenLeaf = claim.tokenLeaves[i];

            uint256 currCumulativeClaimed = cumulativeClaimed[earner][tokenLeaf.token];
            require(tokenLeaf.cumulativeEarnings > currCumulativeClaimed, EarningsNotGreaterThanClaimed());

            // Calculate amount to claim and update cumulativeClaimed
            uint256 claimAmount = tokenLeaf.cumulativeEarnings - currCumulativeClaimed;
            cumulativeClaimed[earner][tokenLeaf.token] = tokenLeaf.cumulativeEarnings;

            tokenLeaf.token.safeTransfer(recipient, claimAmount);
            emit RewardsClaimed(root.root, earner, claimer, recipient, tokenLeaf.token, claimAmount);
        }
    }

    function _setActivationDelay(
        uint32 _activationDelay
    ) internal {
        emit ActivationDelaySet(activationDelay, _activationDelay);
        activationDelay = _activationDelay;
    }

    function _setDefaultOperatorSplit(
        uint16 split
    ) internal {
        emit DefaultOperatorSplitBipsSet(defaultOperatorSplitBips, split);
        defaultOperatorSplitBips = split;
    }

    function _setRewardsUpdater(
        address _rewardsUpdater
    ) internal {
        emit RewardsUpdaterSet(rewardsUpdater, _rewardsUpdater);
        rewardsUpdater = _rewardsUpdater;
    }

    function _setClaimer(
        address earner,
        address claimer
    ) internal {
        address prevClaimer = claimerFor[earner];
        claimerFor[earner] = claimer;
        emit ClaimerForSet(earner, prevClaimer, claimer);
    }

    /// @notice Internal helper to set the operator split.
    /// @param operatorSplit The split struct for an Operator
    /// @param split The split in basis points.
    /// @param activatedAt The timestamp when the split is activated.
    function _setOperatorSplit(
        OperatorSplit storage operatorSplit,
        uint16 split,
        uint32 activatedAt
    ) internal {
        require(split <= ONE_HUNDRED_IN_BIPS, SplitExceedsMax());

        require(block.timestamp > operatorSplit.activatedAt, PreviousSplitPending());

        if (operatorSplit.activatedAt == 0) {
            // If the operator split has not been initialized yet, set the old split to `type(uint16).max` as a flag.
            operatorSplit.oldSplitBips = type(uint16).max;
        } else {
            operatorSplit.oldSplitBips = operatorSplit.newSplitBips;
        }

        operatorSplit.newSplitBips = split;
        operatorSplit.activatedAt = activatedAt;
    }

    /// @notice Common checks for all RewardsSubmissions.
    function _validateCommonRewardsSubmission(
        StrategyAndMultiplier[] calldata strategiesAndMultipliers,
        uint32 startTimestamp,
        uint32 duration
    ) internal view {
        require(strategiesAndMultipliers.length > 0, InputArrayLengthZero());
        require(duration <= MAX_REWARDS_DURATION, DurationExceedsMax());
        require(duration % CALCULATION_INTERVAL_SECONDS == 0, InvalidDurationRemainder());
        require(duration > 0, DurationIsZero());
        require(startTimestamp % CALCULATION_INTERVAL_SECONDS == 0, InvalidStartTimestampRemainder());
        require(
            block.timestamp - MAX_RETROACTIVE_LENGTH <= startTimestamp && GENESIS_REWARDS_TIMESTAMP <= startTimestamp,
            StartTimestampTooFarInPast()
        );

        // Require reward submission is for whitelisted strategy or beaconChainETHStrategy
        address currAddress = address(0);
        for (uint256 i = 0; i < strategiesAndMultipliers.length; ++i) {
            IStrategy strategy = strategiesAndMultipliers[i].strategy;
            require(
                strategyManager.strategyIsWhitelistedForDeposit(strategy) || strategy == beaconChainETHStrategy,
                StrategyNotWhitelisted()
            );
            require(currAddress < address(strategy), StrategiesNotInAscendingOrder());
            currAddress = address(strategy);
        }
    }

    /// @notice Validate a RewardsSubmission. Called from both `createAVSRewardsSubmission` and `createRewardsForAllSubmission`
    function _validateRewardsSubmission(
        RewardsSubmission calldata rewardsSubmission
    ) internal view {
        _validateCommonRewardsSubmission(
            rewardsSubmission.strategiesAndMultipliers, rewardsSubmission.startTimestamp, rewardsSubmission.duration
        );
        require(rewardsSubmission.amount > 0, AmountIsZero());
        require(rewardsSubmission.amount <= MAX_REWARDS_AMOUNT, AmountExceedsMax());
        require(rewardsSubmission.startTimestamp <= block.timestamp + MAX_FUTURE_LENGTH, StartTimestampTooFarInFuture());
    }

    /// @notice Validate a OperatorDirectedRewardsSubmission. Called from `createOperatorDirectedAVSRewardsSubmission`.
    /// @dev Not checking for `MAX_FUTURE_LENGTH` (Since operator-directed reward submissions are strictly retroactive).
    /// @param submission OperatorDirectedRewardsSubmission to validate.
    /// @return total amount to be transferred from the avs to the contract.
    function _validateOperatorDirectedRewardsSubmission(
        OperatorDirectedRewardsSubmission calldata submission
    ) internal view returns (uint256) {
        _validateCommonRewardsSubmission(
            submission.strategiesAndMultipliers, submission.startTimestamp, submission.duration
        );

        require(submission.operatorRewards.length > 0, InputArrayLengthZero());
        require(submission.startTimestamp + submission.duration < block.timestamp, SubmissionNotRetroactive());

        uint256 totalAmount = 0;
        address currOperatorAddress = address(0);
        for (uint256 i = 0; i < submission.operatorRewards.length; ++i) {
            OperatorReward calldata operatorReward = submission.operatorRewards[i];
            require(operatorReward.operator != address(0), InvalidAddressZero());
            require(currOperatorAddress < operatorReward.operator, OperatorsNotInAscendingOrder());
            require(operatorReward.amount > 0, AmountIsZero());

            currOperatorAddress = operatorReward.operator;
            totalAmount += operatorReward.amount;
        }

        require(totalAmount <= MAX_REWARDS_AMOUNT, AmountExceedsMax());

        return totalAmount;
    }

    function _checkClaim(
        RewardsMerkleClaim calldata claim,
        DistributionRoot memory root
    ) internal view {
        require(!root.disabled, RootDisabled());
        require(block.timestamp >= root.activatedAt, RootNotActivated());
        require(claim.tokenIndices.length == claim.tokenTreeProofs.length, InputArrayLengthMismatch());
        require(claim.tokenTreeProofs.length == claim.tokenLeaves.length, InputArrayLengthMismatch());

        // Verify inclusion of earners leaf (earner, earnerTokenRoot) in the distribution root
        _verifyEarnerClaimProof({
            root: root.root,
            earnerLeafIndex: claim.earnerIndex,
            earnerProof: claim.earnerTreeProof,
            earnerLeaf: claim.earnerLeaf
        });
        // For each of the tokenLeaf proofs, verify inclusion of token tree leaf again the earnerTokenRoot
        for (uint256 i = 0; i < claim.tokenIndices.length; ++i) {
            _verifyTokenClaimProof({
                earnerTokenRoot: claim.earnerLeaf.earnerTokenRoot,
                tokenLeafIndex: claim.tokenIndices[i],
                tokenProof: claim.tokenTreeProofs[i],
                tokenLeaf: claim.tokenLeaves[i]
            });
        }
    }

    /// @notice verify inclusion of the token claim proof in the earner token root hash (earnerTokenRoot).
    /// The token leaf comprises of the IERC20 token and cumulativeAmount of earnings.
    /// @param earnerTokenRoot root hash of the earner token subtree
    /// @param tokenLeafIndex index of the token leaf
    /// @param tokenProof proof of the token leaf in the earner token subtree
    /// @param tokenLeaf token leaf to be verified
    function _verifyTokenClaimProof(
        bytes32 earnerTokenRoot,
        uint32 tokenLeafIndex,
        bytes calldata tokenProof,
        TokenTreeMerkleLeaf calldata tokenLeaf
    ) internal pure {
        // Validate index size so that there aren't multiple valid indices for the given proof
        // index can't be greater than 2**(tokenProof/32)
        require(tokenLeafIndex < (1 << (tokenProof.length / 32)), InvalidTokenLeafIndex());

        // Verify inclusion of token leaf
        bytes32 tokenLeafHash = calculateTokenLeafHash(tokenLeaf);
        require(
            Merkle.verifyInclusionKeccak({
                root: earnerTokenRoot,
                index: tokenLeafIndex,
                proof: tokenProof,
                leaf: tokenLeafHash
            }),
            InvalidClaimProof()
        );
    }

    /// @notice verify inclusion of earner claim proof in the distribution root. This verifies
    /// the inclusion of the earner and earnerTokenRoot hash in the tree. The token claims are proven separately
    /// against the earnerTokenRoot hash (see _verifyTokenClaimProof). The earner leaf comprises of (earner, earnerTokenRoot)
    /// @param root distribution root that should be read from storage
    /// @param earnerLeafIndex index of the earner leaf
    /// @param earnerProof proof of the earners account root in the merkle tree
    /// @param earnerLeaf leaf of earner merkle tree containing the earner address and earner's token root hash
    function _verifyEarnerClaimProof(
        bytes32 root,
        uint32 earnerLeafIndex,
        bytes calldata earnerProof,
        EarnerTreeMerkleLeaf calldata earnerLeaf
    ) internal pure {
        // Validate index size so that there aren't multiple valid indices for the given proof
        // index can't be greater than 2**(earnerProof/32)
        require(earnerLeafIndex < (1 << (earnerProof.length / 32)), InvalidEarnerLeafIndex());
        // Verify inclusion of earner leaf
        bytes32 earnerLeafHash = calculateEarnerLeafHash(earnerLeaf);
        // forgefmt: disable-next-item
        require(
            Merkle.verifyInclusionKeccak({
                root: root,
                index: earnerLeafIndex,
                proof: earnerProof,
                leaf: earnerLeafHash
            }),
            InvalidClaimProof()
        );
    }

    /// @notice Internal helper to get the operator split in basis points.
    /// @dev It takes default split and activation delay into account while calculating the split.
    /// @param operatorSplit The split struct for an Operator
    /// @return The split in basis points.
    function _getOperatorSplit(
        OperatorSplit memory operatorSplit
    ) internal view returns (uint16) {
        if (
            (operatorSplit.activatedAt == 0)
                || (operatorSplit.oldSplitBips == type(uint16).max && block.timestamp < operatorSplit.activatedAt)
        ) {
            // Return the Default Operator Split if the operator split has not been initialized.
            // Also return the Default Operator Split if the operator split has been initialized but not activated yet. (i.e the first initialization)
            return defaultOperatorSplitBips;
        } else {
            // Return the new split if the new split has been activated, else return the old split.
            return
                (block.timestamp >= operatorSplit.activatedAt) ? operatorSplit.newSplitBips : operatorSplit.oldSplitBips;
        }
    }

    ///
    ///                         VIEW FUNCTIONS
    ///

    /// @inheritdoc IRewardsCoordinator
    function calculateEarnerLeafHash(
        EarnerTreeMerkleLeaf calldata leaf
    ) public pure returns (bytes32) {
        return keccak256(abi.encodePacked(EARNER_LEAF_SALT, leaf.earner, leaf.earnerTokenRoot));
    }

    /// @inheritdoc IRewardsCoordinator
    function calculateTokenLeafHash(
        TokenTreeMerkleLeaf calldata leaf
    ) public pure returns (bytes32) {
        return keccak256(abi.encodePacked(TOKEN_LEAF_SALT, leaf.token, leaf.cumulativeEarnings));
    }

    /// @inheritdoc IRewardsCoordinator
    function checkClaim(
        RewardsMerkleClaim calldata claim
    ) public view returns (bool) {
        _checkClaim(claim, _distributionRoots[claim.rootIndex]);
        return true;
    }

    /// @inheritdoc IRewardsCoordinator
    function getOperatorAVSSplit(
        address operator,
        address avs
    ) external view returns (uint16) {
        return _getOperatorSplit(_operatorAVSSplitBips[operator][avs]);
    }

    /// @inheritdoc IRewardsCoordinator
    function getOperatorPISplit(
        address operator
    ) external view returns (uint16) {
        return _getOperatorSplit(_operatorPISplitBips[operator]);
    }

    /// @inheritdoc IRewardsCoordinator
    function getOperatorSetSplit(
        address operator,
        OperatorSet calldata operatorSet
    ) external view returns (uint16) {
        return _getOperatorSplit(_operatorSetSplitBips[operator][operatorSet.key()]);
    }

    /// @inheritdoc IRewardsCoordinator
    function getDistributionRootsLength() public view returns (uint256) {
        return _distributionRoots.length;
    }

    /// @inheritdoc IRewardsCoordinator
    function getDistributionRootAtIndex(
        uint256 index
    ) external view returns (DistributionRoot memory) {
        return _distributionRoots[index];
    }

    /// @inheritdoc IRewardsCoordinator
    function getCurrentDistributionRoot() external view returns (DistributionRoot memory) {
        return _distributionRoots[_distributionRoots.length - 1];
    }

    /// @inheritdoc IRewardsCoordinator
    function getCurrentClaimableDistributionRoot() external view returns (DistributionRoot memory) {
        for (uint256 i = _distributionRoots.length; i > 0; i--) {
            DistributionRoot memory root = _distributionRoots[i - 1];
            if (!root.disabled && block.timestamp >= root.activatedAt) {
                return root;
            }
        }
        // Silence compiler warning.
        return DistributionRoot(bytes32(0), 0, 0, false);
    }

    /// @inheritdoc IRewardsCoordinator
    function getRootIndexFromHash(
        bytes32 rootHash
    ) public view returns (uint32) {
        for (uint32 i = uint32(_distributionRoots.length); i > 0; i--) {
            if (_distributionRoots[i - 1].root == rootHash) {
                return i - 1;
            }
        }
        revert InvalidRoot();
    }
}

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

pragma solidity ^0.8.2;

import "../../utils/AddressUpgradeable.sol";

/**
 * @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 Indicates that the contract has been initialized.
     * @custom:oz-retyped-from bool
     */
    uint8 private _initialized;

    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private _initializing;

    /**
     * @dev Triggered when the contract has been initialized or reinitialized.
     */
    event Initialized(uint8 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 functions marked with `initializer` can be nested in the context of a
     * constructor.
     *
     * Emits an {Initialized} event.
     */
    modifier initializer() {
        bool isTopLevelCall = !_initializing;
        require(
            (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
            "Initializable: contract is already initialized"
        );
        _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 255 will prevent any future reinitialization.
     *
     * Emits an {Initialized} event.
     */
    modifier reinitializer(uint8 version) {
        require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
        _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() {
        require(_initializing, "Initializable: contract is not initializing");
        _;
    }

    /**
     * @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 {
        require(!_initializing, "Initializable: contract is initializing");
        if (_initialized != type(uint8).max) {
            _initialized = type(uint8).max;
            emit Initialized(type(uint8).max);
        }
    }

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/ContextUpgradeable.sol";
import "../proxy/utils/Initializable.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    function __Ownable_init() internal onlyInitializing {
        __Ownable_init_unchained();
    }

    function __Ownable_init_unchained() internal onlyInitializing {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[49] private __gap;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;
import "../proxy/utils/Initializable.sol";

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuardUpgradeable is Initializable {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    function __ReentrancyGuard_init() internal onlyInitializing {
        __ReentrancyGuard_init_unchained();
    }

    function __ReentrancyGuard_init_unchained() internal onlyInitializing {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == _ENTERED;
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[49] private __gap;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";
import "../extensions/IERC20Permit.sol";
import "../../../utils/Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Compatible with tokens that require the approval to be set to
     * 0 before setting it to a non-zero value.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.
     * Revert on invalid signature.
     */
    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return
            success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
    }
}

// SPDX-License-Identifier: MIT
// Adapted from OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/MerkleProof.sol)

pragma solidity ^0.8.0;

/// @dev These functions deal with verification of Merkle Tree proofs.
///
/// WARNING: You should avoid using leaf values that are 64 bytes long prior to
/// hashing, salt the leaves, or hash the leaves with a hash function other than
/// what is used for the Merkle tree's internal nodes. This is because the
/// concatenation of a sorted pair of internal nodes in the Merkle tree could
/// be reinterpreted as a leaf value.
library Merkle {
    /// @notice Thrown when the provided proof was not a multiple of 32, or was empty for SHA256.
    /// @dev Error code: 0x4dc5f6a4
    error InvalidProofLength();

    /// @notice Thrown when the provided index was outside the max index for the tree.
    /// @dev Error code: 0x63df8171
    error InvalidIndex();

    /// @notice Thrown when the provided leaves' length was not a power of two.
    /// @dev Error code: 0xf6558f51
    error LeavesNotPowerOfTwo();

    /// @notice Thrown when the provided leaves' length was 0.
    /// @dev Error code: 0xbaec3d9a
    error NoLeaves();

    /// @notice Thrown when the provided leaves' length was insufficient.
    /// @dev Error code: 0xf8ef0367
    /// @dev This is used for the SHA256 Merkle tree, where the tree must have more than 1 leaf.
    error NotEnoughLeaves();

    /// @notice Thrown when the root is empty.
    /// @dev Error code: 0x53ce4ece
    /// @dev Empty roots should never be valid. We prevent them to avoid issues like the Nomad bridge attack: <https://medium.com/nomad-xyz-blog/nomad-bridge-hack-root-cause-analysis-875ad2e5aacd>
    error EmptyRoot();

    /// @notice Verifies that a given leaf is included in a Merkle tree
    /// @param proof The proof of inclusion for the leaf
    /// @param root The root of the Merkle tree
    /// @param leaf The leaf to verify
    /// @param index The index of the leaf in the Merkle tree
    /// @return True if the leaf is included in the Merkle tree, false otherwise
    /// @dev A `proof` is valid if and only if the rebuilt hash matches the root of the tree.
    /// @dev Reverts for:
    ///      - InvalidProofLength: proof.length is not a multiple of 32.
    ///      - InvalidIndex: index is not 0 at conclusion of computation (implying outside the max index for the tree).
    function verifyInclusionKeccak(
        bytes memory proof,
        bytes32 root,
        bytes32 leaf,
        uint256 index
    ) internal pure returns (bool) {
        require(root != bytes32(0), EmptyRoot());
        return processInclusionProofKeccak(proof, leaf, index) == root;
    }

    /// @notice Returns the rebuilt hash obtained by traversing a Merkle tree up
    /// from `leaf` using `proof`.
    /// @param proof The proof of inclusion for the leaf
    /// @param leaf The leaf to verify
    /// @param index The index of the leaf in the Merkle tree
    /// @return The rebuilt hash
    /// @dev Reverts for:
    ///      - InvalidProofLength: proof.length is not a multiple of 32.
    ///      - InvalidIndex: index is not 0 at conclusion of computation (implying outside the max index for the tree).
    /// @dev The tree is built assuming `leaf` is the 0 indexed `index`'th leaf from the bottom left of the tree.
    function processInclusionProofKeccak(
        bytes memory proof,
        bytes32 leaf,
        uint256 index
    ) internal pure returns (bytes32) {
        if (proof.length == 0) {
            return leaf;
        }

        require(proof.length % 32 == 0, InvalidProofLength());

        bytes32 computedHash = leaf;
        for (uint256 i = 32; i <= proof.length; i += 32) {
            if (index % 2 == 0) {
                // if index is even, then computedHash is a left sibling
                assembly {
                    mstore(0x00, computedHash)
                    mstore(0x20, mload(add(proof, i)))
                    computedHash := keccak256(0x00, 0x40)
                    index := div(index, 2)
                }
            } else {
                // if index is odd, then computedHash is a right sibling
                assembly {
                    mstore(0x00, mload(add(proof, i)))
                    mstore(0x20, computedHash)
                    computedHash := keccak256(0x00, 0x40)
                    index := div(index, 2)
                }
            }
        }

        // Confirm proof was fully consumed by end of computation
        require(index == 0, InvalidIndex());

        return computedHash;
    }

    /// @notice Verifies that a given leaf is included in a Merkle tree
    /// @param proof The proof of inclusion for the leaf
    /// @param root The root of the Merkle tree
    /// @param leaf The leaf to verify
    /// @param index The index of the leaf in the Merkle tree
    /// @return True if the leaf is included in the Merkle tree, false otherwise
    /// @dev A `proof` is valid if and only if the rebuilt hash matches the root of the tree.
    /// @dev Reverts for:
    ///      - InvalidProofLength: proof.length is 0 or not a multiple of 32.
    ///      - InvalidIndex: index is not 0 at conclusion of computation (implying outside the max index for the tree).
    function verifyInclusionSha256(
        bytes memory proof,
        bytes32 root,
        bytes32 leaf,
        uint256 index
    ) internal view returns (bool) {
        require(root != bytes32(0), EmptyRoot());
        return processInclusionProofSha256(proof, leaf, index) == root;
    }

    /// @notice Returns the rebuilt hash obtained by traversing a Merkle tree up
    /// from `leaf` using `proof`.
    /// @param proof The proof of inclusion for the leaf
    /// @param leaf The leaf to verify
    /// @param index The index of the leaf in the Merkle tree
    /// @return The rebuilt hash
    /// @dev Reverts for:
    ///      - InvalidProofLength: proof.length is 0 or not a multiple of 32.
    ///      - InvalidIndex: index is not 0 at conclusion of computation (implying outside the max index for the tree).
    /// @dev The tree is built assuming `leaf` is the 0 indexed `index`'th leaf from the bottom left of the tree.
    function processInclusionProofSha256(
        bytes memory proof,
        bytes32 leaf,
        uint256 index
    ) internal view returns (bytes32) {
        require(proof.length != 0 && proof.length % 32 == 0, InvalidProofLength());
        bytes32[1] memory computedHash = [leaf];
        for (uint256 i = 32; i <= proof.length; i += 32) {
            if (index % 2 == 0) {
                // if index is even, then computedHash is a left sibling
                assembly {
                    mstore(0x00, mload(computedHash))
                    mstore(0x20, mload(add(proof, i)))
                    if iszero(staticcall(sub(gas(), 2000), 2, 0x00, 0x40, computedHash, 0x20)) {
                        revert(0, 0)
                    }
                    index := div(index, 2)
                }
            } else {
                // if index is odd, then computedHash is a right sibling
                assembly {
                    mstore(0x00, mload(add(proof, i)))
                    mstore(0x20, mload(computedHash))
                    if iszero(staticcall(sub(gas(), 2000), 2, 0x00, 0x40, computedHash, 0x20)) {
                        revert(0, 0)
                    }
                    index := div(index, 2)
                }
            }
        }

        // Confirm proof was fully consumed by end of computation
        require(index == 0, InvalidIndex());

        return computedHash[0];
    }

    /// @notice Returns the Merkle root of a tree created from a set of leaves using SHA-256 as its hash function
    /// @param leaves the leaves of the Merkle tree
    /// @return The computed Merkle root of the tree.
    /// @dev Reverts for:
    ///      - NotEnoughLeaves: leaves.length is less than 2.
    ///      - LeavesNotPowerOfTwo: leaves.length is not a power of two.
    /// @dev Unlike the Keccak version, this function does not allow a single-leaf tree.
    function merkleizeSha256(
        bytes32[] memory leaves
    ) internal pure returns (bytes32) {
        require(leaves.length > 1, NotEnoughLeaves());
        require(isPowerOfTwo(leaves.length), LeavesNotPowerOfTwo());

        // There are half as many nodes in the layer above the leaves
        uint256 numNodesInLayer = leaves.length / 2;
        // Create a layer to store the internal nodes
        bytes32[] memory layer = new bytes32[](numNodesInLayer);
        // Fill the layer with the pairwise hashes of the leaves
        for (uint256 i = 0; i < numNodesInLayer; i++) {
            layer[i] = sha256(abi.encodePacked(leaves[2 * i], leaves[2 * i + 1]));
        }

        // While we haven't computed the root
        while (numNodesInLayer != 1) {
            // The next layer above has half as many nodes
            numNodesInLayer /= 2;
            // Overwrite the first numNodesInLayer nodes in layer with the pairwise hashes of their children
            for (uint256 i = 0; i < numNodesInLayer; i++) {
                layer[i] = sha256(abi.encodePacked(layer[2 * i], layer[2 * i + 1]));
            }
        }
        // The first node in the layer is the root
        return layer[0];
    }

    /// @notice Returns the Merkle root of a tree created from a set of leaves using Keccak as its hash function
    /// @param leaves the leaves of the Merkle tree
    /// @return The computed Merkle root of the tree.
    /// @dev Reverts for:
    ///      - NoLeaves: leaves.length is 0.
    function merkleizeKeccak(
        bytes32[] memory leaves
    ) internal pure returns (bytes32) {
        require(leaves.length > 0, NoLeaves());

        uint256 numNodesInLayer;
        if (!isPowerOfTwo(leaves.length)) {
            // Pad to the next power of 2
            numNodesInLayer = 1;
            while (numNodesInLayer < leaves.length) {
                numNodesInLayer *= 2;
            }
        } else {
            numNodesInLayer = leaves.length;
        }

        // Create a layer to store the internal nodes
        bytes32[] memory layer = new bytes32[](numNodesInLayer);
        for (uint256 i = 0; i < leaves.length; i++) {
            layer[i] = leaves[i];
        }

        // While we haven't computed the root
        while (numNodesInLayer != 1) {
            // The next layer above has half as many nodes
            numNodesInLayer /= 2;
            // Overwrite the first numNodesInLayer nodes in layer with the pairwise hashes of their children
            for (uint256 i = 0; i < numNodesInLayer; i++) {
                layer[i] = keccak256(abi.encodePacked(layer[2 * i], layer[2 * i + 1]));
            }
        }
        // The first node in the layer is the root
        return layer[0];
    }

    /// @notice Returns the Merkle proof for a given index in a tree created from a set of leaves using Keccak as its hash function
    /// @param leaves the leaves of the Merkle tree
    /// @param index the index of the leaf to get the proof for
    /// @return proof The computed Merkle proof for the leaf at index.
    /// @dev Reverts for:
    ///      - InvalidIndex: index is outside the max index for the tree.
    function getProofKeccak(
        bytes32[] memory leaves,
        uint256 index
    ) internal pure returns (bytes memory proof) {
        require(leaves.length > 0, NoLeaves());
        // TODO: very inefficient, use ZERO_HASHES
        // pad to the next power of 2
        uint256 numNodesInLayer = 1;
        while (numNodesInLayer < leaves.length) {
            numNodesInLayer *= 2;
        }
        bytes32[] memory layer = new bytes32[](numNodesInLayer);
        for (uint256 i = 0; i < leaves.length; i++) {
            layer[i] = leaves[i];
        }

        if (index >= layer.length) revert InvalidIndex();

        // While we haven't computed the root
        while (numNodesInLayer != 1) {
            // Flip the least significant bit of index to get the sibling index
            uint256 siblingIndex = index ^ 1;
            // Add the sibling to the proof
            proof = abi.encodePacked(proof, layer[siblingIndex]);
            index /= 2;

            // The next layer above has half as many nodes
            numNodesInLayer /= 2;
            // Overwrite the first numNodesInLayer nodes in layer with the pairwise hashes of their children
            for (uint256 i = 0; i < numNodesInLayer; i++) {
                layer[i] = keccak256(abi.encodePacked(layer[2 * i], layer[2 * i + 1]));
            }
        }
    }

    /// @notice Returns the Merkle proof for a given index in a tree created from a set of leaves using SHA-256 as its hash function
    /// @param leaves the leaves of the Merkle tree
    /// @param index the index of the leaf to get the proof for
    /// @return proof The computed Merkle proof for the leaf at index.
    /// @dev Reverts for:
    ///      - NotEnoughLeaves: leaves.length is less than 2.
    /// @dev Unlike the Keccak version, this function does not allow a single-leaf proof.
    function getProofSha256(
        bytes32[] memory leaves,
        uint256 index
    ) internal pure returns (bytes memory proof) {
        require(leaves.length > 1, NotEnoughLeaves());
        // TODO: very inefficient, use ZERO_HASHES
        // pad to the next power of 2
        uint256 numNodesInLayer = 1;
        while (numNodesInLayer < leaves.length) {
            numNodesInLayer *= 2;
        }
        bytes32[] memory layer = new bytes32[](numNodesInLayer);
        for (uint256 i = 0; i < leaves.length; i++) {
            layer[i] = leaves[i];
        }

        if (index >= layer.length) revert InvalidIndex();

        // While we haven't computed the root
        while (numNodesInLayer != 1) {
            // Flip the least significant bit of index to get the sibling index
            uint256 siblingIndex = index ^ 1;
            // Add the sibling to the proof
            proof = abi.encodePacked(proof, layer[siblingIndex]);
            index /= 2;

            // The next layer above has half as many nodes
            numNodesInLayer /= 2;
            // Overwrite the first numNodesInLayer nodes in layer with the pairwise hashes of their children
            for (uint256 i = 0; i < numNodesInLayer; i++) {
                layer[i] = sha256(abi.encodePacked(layer[2 * i], layer[2 * i + 1]));
            }
        }
    }

    /// @notice Returns whether the input is a power of two
    /// @param value the value to check
    /// @return True if the input is a power of two, false otherwise
    function isPowerOfTwo(
        uint256 value
    ) internal pure returns (bool) {
        return value != 0 && (value & (value - 1)) == 0;
    }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.27;

import "../interfaces/IPausable.sol";

/// @title Adds pausability to a contract, with pausing & unpausing controlled by the `pauser` and `unpauser` of a PauserRegistry contract.
/// @author Layr Labs, Inc.
/// @notice Terms of Service: https://docs.eigenlayer.xyz/overview/terms-of-service
/// @notice Contracts that inherit from this contract may define their own `pause` and `unpause` (and/or related) functions.
/// These functions should be permissioned as "onlyPauser" which defers to a `PauserRegistry` for determining access control.
/// @dev Pausability is implemented using a uint256, which allows up to 256 different single bit-flags; each bit can potentially pause different functionality.
/// Inspiration for this was taken from the NearBridge design here https://etherscan.io/address/0x3FEFc5A4B1c02f21cBc8D3613643ba0635b9a873#code.
/// For the `pause` and `unpause` functions we've implemented, if you pause, you can only flip (any number of) switches to on/1 (aka "paused"), and if you unpause,
/// you can only flip (any number of) switches to off/0 (aka "paused").
/// If you want a pauseXYZ function that just flips a single bit / "pausing flag", it will:
/// 1) 'bit-wise and' (aka `&`) a flag with the current paused state (as a uint256)
/// 2) update the paused state to this new value
/// @dev We note as well that we have chosen to identify flags by their *bit index* as opposed to their numerical value, so, e.g. defining `DEPOSITS_PAUSED = 3`
/// indicates specifically that if the *third bit* of `_paused` is flipped -- i.e. it is a '1' -- then deposits should be paused
abstract contract Pausable is IPausable {
    /// Constants
    uint256 internal constant _UNPAUSE_ALL = 0;

    uint256 internal constant _PAUSE_ALL = type(uint256).max;

    /// @notice Address of the `PauserRegistry` contract that this contract defers to for determining access control (for pausing).
    IPauserRegistry public immutable pauserRegistry;

    /// Storage

    /// @dev Do not remove, deprecated storage.
    IPauserRegistry private __deprecated_pauserRegistry;

    /// @dev Returns a bitmap representing the paused status of the contract.
    uint256 private _paused;

    /// Modifiers

    /// @dev Thrown if the caller is not a valid pauser according to the pauser registry.
    modifier onlyPauser() {
        _checkOnlyPauser();
        _;
    }

    /// @dev Thrown if the caller is not a valid unpauser according to the pauser registry.
    modifier onlyUnpauser() {
        _checkOnlyUnpauser();
        _;
    }

    /// @dev Thrown if the contract is paused, i.e. if any of the bits in `_paused` is flipped to 1.
    modifier whenNotPaused() {
        _checkOnlyWhenNotPaused();
        _;
    }

    /// @dev Thrown if the `indexed`th bit of `_paused` is 1, i.e. if the `index`th pause switch is flipped.
    modifier onlyWhenNotPaused(
        uint8 index
    ) {
        _checkOnlyWhenNotPaused(index);
        _;
    }

    function _checkOnlyPauser() internal view {
        require(pauserRegistry.isPauser(msg.sender), OnlyPauser());
    }

    function _checkOnlyUnpauser() internal view {
        require(msg.sender == pauserRegistry.unpauser(), OnlyUnpauser());
    }

    function _checkOnlyWhenNotPaused() internal view {
        require(_paused == 0, CurrentlyPaused());
    }

    function _checkOnlyWhenNotPaused(
        uint8 index
    ) internal view {
        require(!paused(index), CurrentlyPaused());
    }

    /// Construction

    constructor(
        IPauserRegistry _pauserRegistry
    ) {
        require(address(_pauserRegistry) != address(0), InputAddressZero());
        pauserRegistry = _pauserRegistry;
    }

    /// @inheritdoc IPausable
    function pause(
        uint256 newPausedStatus
    ) external onlyPauser {
        uint256 currentPausedStatus = _paused;
        // verify that the `newPausedStatus` does not *unflip* any bits (i.e. doesn't unpause anything, all 1 bits remain)
        require((currentPausedStatus & newPausedStatus) == currentPausedStatus, InvalidNewPausedStatus());
        _setPausedStatus(newPausedStatus);
    }

    /// @inheritdoc IPausable
    function pauseAll() external onlyPauser {
        _setPausedStatus(_PAUSE_ALL);
    }

    /// @inheritdoc IPausable
    function unpause(
        uint256 newPausedStatus
    ) external onlyUnpauser {
        uint256 currentPausedStatus = _paused;
        // verify that the `newPausedStatus` does not *flip* any bits (i.e. doesn't pause anything, all 0 bits remain)
        require(((~currentPausedStatus) & (~newPausedStatus)) == (~currentPausedStatus), InvalidNewPausedStatus());
        _paused = newPausedStatus;
        emit Unpaused(msg.sender, newPausedStatus);
    }

    /// @inheritdoc IPausable
    function paused() public view virtual returns (uint256) {
        return _paused;
    }

    /// @inheritdoc IPausable
    function paused(
        uint8 index
    ) public view virtual returns (bool) {
        uint256 mask = 1 << index;
        return ((_paused & mask) == mask);
    }

    /// @dev Internal helper for setting the paused status, and emitting the corresponding event.
    function _setPausedStatus(
        uint256 pausedStatus
    ) internal {
        _paused = pausedStatus;
        emit Paused(msg.sender, pausedStatus);
    }

    /// @dev This empty reserved space is put in place to allow future versions to add new
    /// variables without shifting down storage in the inheritance chain.
    /// See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
    uint256[48] private __gap;
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.27;

import "../../interfaces/IRewardsCoordinator.sol";

/// @title Storage variables for the `RewardsCoordinator` contract.
/// @author Layr Labs, Inc.
/// @notice Terms of Service: https://docs.eigenlayer.xyz/overview/terms-of-service
/// @notice This storage contract is separate from the logic to simplify the upgrade process.
abstract contract RewardsCoordinatorStorage is IRewardsCoordinator {
    // Constants

    /// @dev Index for flag that pauses calling createAVSRewardsSubmission
    uint8 internal constant PAUSED_AVS_REWARDS_SUBMISSION = 0;
    /// @dev Index for flag that pauses calling createRewardsForAllSubmission
    uint8 internal constant PAUSED_REWARDS_FOR_ALL_SUBMISSION = 1;
    /// @dev Index for flag that pauses calling processClaim
    uint8 internal constant PAUSED_PROCESS_CLAIM = 2;
    /// @dev Index for flag that pauses submitRoots and disableRoot
    uint8 internal constant PAUSED_SUBMIT_DISABLE_ROOTS = 3;
    /// @dev Index for flag that pauses calling rewardAllStakersAndOperators
    uint8 internal constant PAUSED_REWARD_ALL_STAKERS_AND_OPERATORS = 4;
    /// @dev Index for flag that pauses calling createOperatorDirectedAVSRewardsSubmission
    uint8 internal constant PAUSED_OPERATOR_DIRECTED_AVS_REWARDS_SUBMISSION = 5;
    /// @dev Index for flag that pauses calling setOperatorAVSSplit
    uint8 internal constant PAUSED_OPERATOR_AVS_SPLIT = 6;
    /// @dev Index for flag that pauses calling setOperatorPISplit
    uint8 internal constant PAUSED_OPERATOR_PI_SPLIT = 7;
    /// @dev Index for flag that pauses calling setOperatorSetSplit
    uint8 internal constant PAUSED_OPERATOR_SET_SPLIT = 8;
    /// @dev Index for flag that pauses calling setOperatorSetPerformanceRewardsSubmission
    uint8 internal constant PAUSED_OPERATOR_DIRECTED_OPERATOR_SET_REWARDS_SUBMISSION = 9;

    /// @dev Salt for the earner leaf, meant to distinguish from tokenLeaf since they have the same sized data
    uint8 internal constant EARNER_LEAF_SALT = 0;
    /// @dev Salt for the token leaf, meant to distinguish from earnerLeaf since they have the same sized data
    uint8 internal constant TOKEN_LEAF_SALT = 1;

    /// @notice The maximum rewards token amount for a single rewards submission, constrained by off-chain calculation
    uint256 internal constant MAX_REWARDS_AMOUNT = 1e38 - 1;
    /// @notice Equivalent to 100%, but in basis points.
    uint16 internal constant ONE_HUNDRED_IN_BIPS = 10_000;

    /// @notice Canonical, virtual beacon chain ETH strategy
    IStrategy public constant beaconChainETHStrategy = IStrategy(0xbeaC0eeEeeeeEEeEeEEEEeeEEeEeeeEeeEEBEaC0);

    // Immutables

    /// @notice The DelegationManager contract for EigenLayer
    IDelegationManager public immutable delegationManager;

    /// @notice The StrategyManager contract for EigenLayer
    IStrategyManager public immutable strategyManager;

    /// @notice The AllocationManager contract for EigenLayer
    IAllocationManager public immutable allocationManager;

    /// @notice The interval in seconds at which the calculation for rewards distribution is done.
    /// @dev RewardsSubmission durations must be multiples of this interval. This is going to be configured to 1 day
    uint32 public immutable CALCULATION_INTERVAL_SECONDS;
    /// @notice The maximum amount of time (seconds) that a rewards submission can span over
    uint32 public immutable MAX_REWARDS_DURATION;
    /// @notice max amount of time (seconds) that a rewards submission can start in the past
    uint32 public immutable MAX_RETROACTIVE_LENGTH;
    /// @notice max amount of time (seconds) that a rewards submission can start in the future
    uint32 public immutable MAX_FUTURE_LENGTH;
    /// @notice absolute min timestamp (seconds) that a rewards submission can start at
    uint32 public immutable GENESIS_REWARDS_TIMESTAMP;
    /// @notice The cadence at which a snapshot is taken offchain for calculating rewards distributions
    uint32 internal constant SNAPSHOT_CADENCE = 1 days;

    // Mutatables

    /// @dev Do not remove, deprecated storage.
    bytes32 internal __deprecated_DOMAIN_SEPARATOR;

    /// @notice List of roots submitted by the rewardsUpdater
    /// @dev Array is internal with an external getter so we can return a `DistributionRoot[] memory` object
    DistributionRoot[] internal _distributionRoots;

    /// Slot 2
    /// @notice The address of the entity that can update the contract with new merkle roots
    address public rewardsUpdater;
    /// @notice Delay in timestamp (seconds) before a posted root can be claimed against
    uint32 public activationDelay;
    /// @notice Timestamp for last submitted DistributionRoot
    uint32 public currRewardsCalculationEndTimestamp;
    /// @notice the default split for all operators across all avss in bips.
    uint16 public defaultOperatorSplitBips;

    /// @notice Returns the `claimer` for a given `earner`.
    /// @dev The claimer is able to call `processClaim` on behalf of the `earner`.
    mapping(address earner => address claimer) public claimerFor;

    /// @notice Returns the total claimed amount for an `earner` for a given `token`.
    mapping(address earner => mapping(IERC20 token => uint256 totalClaimed)) public cumulativeClaimed;

    /// @notice Returns the submission `nonce` for an `avs`.
    mapping(address avs => uint256 nonce) public submissionNonce;

    /// @notice Returns whether a `hash` is a `valid` rewards submission hash for a given `avs`.
    mapping(address avs => mapping(bytes32 hash => bool valid)) public isAVSRewardsSubmissionHash;

    /// @notice Returns whether a `hash` is a `valid` rewards submission for all hash for a given `avs`.
    mapping(address avs => mapping(bytes32 hash => bool valid)) public isRewardsSubmissionForAllHash;

    /// @notice Returns whether a `submitter` is a `valid` rewards for all submitter.
    mapping(address submitter => bool valid) public isRewardsForAllSubmitter;

    /// @notice Returns whether a `hash` is a `valid` rewards submission for all earners hash for a given `avs`.
    mapping(address avs => mapping(bytes32 hash => bool valid)) public isRewardsSubmissionForAllEarnersHash;

    /// @notice Returns whether a `hash` is a `valid` operator set performance rewards submission hash for a given `avs`.
    mapping(address avs => mapping(bytes32 hash => bool valid)) public isOperatorDirectedAVSRewardsSubmissionHash;

    /// @notice Returns the `split` an `operator` takes for an `avs`.
    mapping(address operator => mapping(address avs => OperatorSplit split)) internal _operatorAVSSplitBips;

    /// @notice Returns the `split` an `operator` takes for Programmatic Incentives.
    mapping(address operator => OperatorSplit split) internal _operatorPISplitBips;

    /// @notice Returns the `split` an `operator` takes for a given operator set.
    mapping(address operator => mapping(bytes32 operatorSetKey => OperatorSplit split)) internal _operatorSetSplitBips;

    /// @notice Returns whether a `hash` is a `valid` operator set performance rewards submission hash for a given `avs`.
    mapping(address avs => mapping(bytes32 hash => bool valid)) public
        isOperatorDirectedOperatorSetRewardsSubmissionHash;

    // Construction

    constructor(
        IDelegationManager _delegationManager,
        IStrategyManager _strategyManager,
        IAllocationManager _allocationManager,
        uint32 _CALCULATION_INTERVAL_SECONDS,
        uint32 _MAX_REWARDS_DURATION,
        uint32 _MAX_RETROACTIVE_LENGTH,
        uint32 _MAX_FUTURE_LENGTH,
        uint32 _GENESIS_REWARDS_TIMESTAMP
    ) {
        require(
            _GENESIS_REWARDS_TIMESTAMP % _CALCULATION_INTERVAL_SECONDS == 0, InvalidGenesisRewardsTimestampRemainder()
        );
        require(_CALCULATION_INTERVAL_SECONDS % SNAPSHOT_CADENCE == 0, InvalidCalculationIntervalSecondsRemainder());
        delegationManager = _delegationManager;
        strategyManager = _strategyManager;
        allocationManager = _allocationManager;
        CALCULATION_INTERVAL_SECONDS = _CALCULATION_INTERVAL_SECONDS;
        MAX_REWARDS_DURATION = _MAX_REWARDS_DURATION;
        MAX_RETROACTIVE_LENGTH = _MAX_RETROACTIVE_LENGTH;
        MAX_FUTURE_LENGTH = _MAX_FUTURE_LENGTH;
        GENESIS_REWARDS_TIMESTAMP = _GENESIS_REWARDS_TIMESTAMP;
    }

    /// @dev This empty reserved space is put in place to allow future versions to add new
    /// variables without shifting down storage in the inheritance chain.
    /// See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
    uint256[35] private __gap;
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.0;

import "../interfaces/IPermissionController.sol";

abstract contract PermissionControllerMixin {
    /// @dev Thrown when the caller is not allowed to call a function on behalf of an account.
    error InvalidPermissions();

    /// @notice Pointer to the permission controller contract.
    IPermissionController public immutable permissionController;

    constructor(
        IPermissionController _permissionController
    ) {
        permissionController = _permissionController;
    }

    /// @notice Modifier that checks if the caller can call on behalf of an account, reverts if not permitted.
    /// @param account The account on whose behalf the function is being called.
    /// @dev Use this modifier when the entire function requires authorization.
    /// @dev This is the most common pattern - prefer this over `_checkCanCall` when possible.
    modifier checkCanCall(
        address account
    ) {
        _checkCanCall(account);
        _;
    }

    /// @notice Checks if the caller is permitted to call the current function on behalf of the given account.
    /// @param account The account on whose behalf the function is being called.
    /// @dev Reverts with `InvalidPermissions()` if the caller is not permitted.
    /// @dev Use this function instead of the modifier when:
    ///      - You need to avoid "stack too deep" errors (e.g., when combining multiple modifiers)
    ///      - You need more control over when the check occurs in your function logic
    function _checkCanCall(
        address account
    ) internal view {
        require(_canCall(account), InvalidPermissions());
    }

    /// @notice Checks if the caller is permitted to call the current function on behalf of the given account.
    /// @param account The account on whose behalf the function is being called.
    /// @return allowed True if the caller is permitted, false otherwise.
    /// @dev Unlike `_checkCanCall`, this function returns a boolean instead of reverting.
    /// @dev Use this function when you need conditional logic based on permissions, such as:
    ///      - OR conditions: `require(_canCall(operator) || _canCall(avs), InvalidCaller());`
    ///      - If-else branches: `if (_canCall(account)) { ... } else { ... }`
    ///      - Multiple authorization paths in the same function
    /// @dev This function queries the permissionController to determine if msg.sender is authorized
    ///      to call the current function (identified by msg.sig) on behalf of `account`.
    function _canCall(
        address account
    ) internal view returns (bool allowed) {
        return permissionController.canCall(account, msg.sender, address(this), msg.sig);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library AddressUpgradeable {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;
import "../proxy/utils/Initializable.sol";

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract ContextUpgradeable is Initializable {
    function __Context_init() internal onlyInitializing {
    }

    function __Context_init_unchained() internal onlyInitializing {
    }
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[50] private __gap;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity >=0.5.0;

import "../interfaces/IPauserRegistry.sol";

/// @title Adds pausability to a contract, with pausing & unpausing controlled by the `pauser` and `unpauser` of a PauserRegistry contract.
/// @author Layr Labs, Inc.
/// @notice Terms of Service: https://docs.eigenlayer.xyz/overview/terms-of-service
/// @notice Contracts that inherit from this contract may define their own `pause` and `unpause` (and/or related) functions.
/// These functions should be permissioned as "onlyPauser" which defers to a `PauserRegistry` for determining access control.
/// @dev Pausability is implemented using a uint256, which allows up to 256 different single bit-flags; each bit can potentially pause different functionality.
/// Inspiration for this was taken from the NearBridge design here https://etherscan.io/address/0x3FEFc5A4B1c02f21cBc8D3613643ba0635b9a873#code.
/// For the `pause` and `unpause` functions we've implemented, if you pause, you can only flip (any number of) switches to on/1 (aka "paused"), and if you unpause,
/// you can only flip (any number of) switches to off/0 (aka "paused").
/// If you want a pauseXYZ function that just flips a single bit / "pausing flag", it will:
/// 1) 'bit-wise and' (aka `&`) a flag with the current paused state (as a uint256)
/// 2) update the paused state to this new value
/// @dev We note as well that we have chosen to identify flags by their *bit index* as opposed to their numerical value, so, e.g. defining `DEPOSITS_PAUSED = 3`
/// indicates specifically that if the *third bit* of `_paused` is flipped -- i.e. it is a '1' -- then deposits should be paused
interface IPausable {
    /// @dev Thrown when caller is not pauser.
    error OnlyPauser();
    /// @dev Thrown when caller is not unpauser.
    error OnlyUnpauser();
    /// @dev Thrown when currently paused.
    error CurrentlyPaused();
    /// @dev Thrown when invalid `newPausedStatus` is provided.
    error InvalidNewPausedStatus();
    /// @dev Thrown when a null address input is provided.
    error InputAddressZero();

    /// @notice Emitted when the pause is triggered by `account`, and changed to `newPausedStatus`.
    event Paused(address indexed account, uint256 newPausedStatus);

    /// @notice Emitted when the pause is lifted by `account`, and changed to `newPausedStatus`.
    event Unpaused(address indexed account, uint256 newPausedStatus);

    /// @notice Address of the `PauserRegistry` contract that this contract defers to for determining access control (for pausing).
    function pauserRegistry() external view returns (IPauserRegistry);

    /// @notice This function is used to pause an EigenLayer contract's functionality.
    /// It is permissioned to the `pauser` address, which is expected to be a low threshold multisig.
    /// @param newPausedStatus represents the new value for `_paused` to take, which means it may flip several bits at once.
    /// @dev This function can only pause functionality, and thus cannot 'unflip' any bit in `_paused` from 1 to 0.
    function pause(
        uint256 newPausedStatus
    ) external;

    /// @notice Alias for `pause(type(uint256).max)`.
    function pauseAll() external;

    /// @notice This function is used to unpause an EigenLayer contract's functionality.
    /// It is permissioned to the `unpauser` address, which is expected to be a high threshold multisig or governance contract.
    /// @param newPausedStatus represents the new value for `_paused` to take, which means it may flip several bits at once.
    /// @dev This function can only unpause functionality, and thus cannot 'flip' any bit in `_paused` from 0 to 1.
    function unpause(
        uint256 newPausedStatus
    ) external;

    /// @notice Returns the current paused status as a uint256.
    function paused() external view returns (uint256);

    /// @notice Returns 'true' if the `indexed`th bit of `_paused` is 1, and 'false' otherwise
    function paused(
        uint8 index
    ) external view returns (bool);
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.27;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "../libraries/OperatorSetLib.sol";

import "./IAllocationManager.sol";
import "./IDelegationManager.sol";
import "./IStrategyManager.sol";
import "./IPauserRegistry.sol";
import "./IPermissionController.sol";
import "./IStrategy.sol";

interface IRewardsCoordinatorErrors {
    /// @dev Thrown when msg.sender is not allowed to call a function
    error UnauthorizedCaller();
    /// @dev Thrown when a earner not an AVS or Operator
    error InvalidEarner();

    /// Invalid Inputs

    /// @dev Thrown when an input address is zero
    error InvalidAddressZero();
    /// @dev Thrown when an invalid root is provided.
    error InvalidRoot();
    /// @dev Thrown when an invalid root index is provided.
    error InvalidRootIndex();
    /// @dev Thrown when input arrays length is zero.
    error InputArrayLengthZero();
    /// @dev Thrown when two array parameters have mismatching lengths.
    error InputArrayLengthMismatch();
    /// @dev Thrown when provided root is not for new calculated period.
    error NewRootMustBeForNewCalculatedPeriod();
    /// @dev Thrown when rewards end timestamp has not elapsed.
    error RewardsEndTimestampNotElapsed();
    /// @dev Thrown when an invalid operator set is provided.
    error InvalidOperatorSet();

    /// Rewards Submissions

    /// @dev Thrown when input `amount` is zero.
    error AmountIsZero();
    /// @dev Thrown when input `amount` exceeds maximum.
    error AmountExceedsMax();
    /// @dev Thrown when input `split` exceeds `ONE_HUNDRED_IN_BIPS`
    error SplitExceedsMax();
    /// @dev Thrown when an operator attempts to set a split before the previous one becomes active
    error PreviousSplitPending();
    /// @dev Thrown when input `duration` exceeds maximum.
    error DurationExceedsMax();
    /// @dev Thrown when input `duration` is zero.
    error DurationIsZero();
    /// @dev Thrown when input `duration` is not evenly divisble by CALCULATION_INTERVAL_SECONDS.
    error InvalidDurationRemainder();
    /// @dev Thrown when GENESIS_REWARDS_TIMESTAMP is not evenly divisble by CALCULATION_INTERVAL_SECONDS.
    error InvalidGenesisRewardsTimestampRemainder();
    /// @dev Thrown when CALCULATION_INTERVAL_SECONDS is not evenly divisble by SNAPSHOT_CADENCE.
    error InvalidCalculationIntervalSecondsRemainder();
    /// @dev Thrown when `startTimestamp` is not evenly divisble by CALCULATION_INTERVAL_SECONDS.
    error InvalidStartTimestampRemainder();
    /// @dev Thrown when `startTimestamp` is too far in the future.
    error StartTimestampTooFarInFuture();
    /// @dev Thrown when `startTimestamp` is too far in the past.
    error StartTimestampTooFarInPast();
    /// @dev Thrown when an attempt to use a non-whitelisted strategy is made.
    error StrategyNotWhitelisted();
    /// @dev Thrown when `strategies` is not sorted in ascending order.
    error StrategiesNotInAscendingOrder();
    /// @dev Thrown when `operators` are not sorted in ascending order
    error OperatorsNotInAscendingOrder();
    /// @dev Thrown when an operator-directed rewards submission is not retroactive
    error SubmissionNotRetroactive();

    /// Claims

    /// @dev Thrown when an invalid earner claim proof is provided.
    error InvalidClaimProof();
    /// @dev Thrown when an invalid token leaf index is provided.
    error InvalidTokenLeafIndex();
    /// @dev Thrown when an invalid earner leaf index is provided.
    error InvalidEarnerLeafIndex();
    /// @dev Thrown when cumulative earnings are not greater than cumulative claimed.
    error EarningsNotGreaterThanClaimed();

    /// Reward Root Checks

    /// @dev Thrown if a root has already been disabled.
    error RootDisabled();
    /// @dev Thrown if a root has not been activated yet.
    error RootNotActivated();
    /// @dev Thrown if a root has already been activated.
    error RootAlreadyActivated();
}

interface IRewardsCoordinatorTypes {
    /// @notice A linear combination of strategies and multipliers for AVSs to weigh
    /// EigenLayer strategies.
    /// @param strategy The EigenLayer strategy to be used for the rewards submission
    /// @param multiplier The weight of the strategy in the rewards submission
    struct StrategyAndMultiplier {
        IStrategy strategy;
        uint96 multiplier;
    }

    /// @notice A reward struct for an operator
    /// @param operator The operator to be rewarded
    /// @param amount The reward amount for the operator
    struct OperatorReward {
        address operator;
        uint256 amount;
    }

    /// @notice A split struct for an Operator
    /// @param oldSplitBips The old split in basis points. This is the split that is active if `block.timestamp < activatedAt`
    /// @param newSplitBips The new split in basis points. This is the split that is active if `block.timestamp >= activatedAt`
    /// @param activatedAt The timestamp at which the split will be activated
    struct OperatorSplit {
        uint16 oldSplitBips;
        uint16 newSplitBips;
        uint32 activatedAt;
    }

    /// Sliding Window for valid RewardsSubmission startTimestamp
    ///
    /// Scenario A: GENESIS_REWARDS_TIMESTAMP IS WITHIN RANGE
    ///         <-----MAX_RETROACTIVE_LENGTH-----> t (block.timestamp) <---MAX_FUTURE_LENGTH--->
    ///             <--------------------valid range for startTimestamp------------------------>
    ///             ^
    ///         GENESIS_REWARDS_TIMESTAMP
    ///
    ///
    /// Scenario B: GENESIS_REWARDS_TIMESTAMP IS OUT OF RANGE
    ///         <-----MAX_RETROACTIVE_LENGTH-----> t (block.timestamp) <---MAX_FUTURE_LENGTH--->
    ///         <------------------------valid range for startTimestamp------------------------>
    ///     ^
    /// GENESIS_REWARDS_TIMESTAMP
    /// @notice RewardsSubmission struct submitted by AVSs when making rewards for their operators and stakers
    /// RewardsSubmission can be for a time range within the valid window for startTimestamp and must be within max duration.
    /// See `createAVSRewardsSubmission()` for more details.
    /// @param strategiesAndMultipliers The strategies and their relative weights
    /// cannot have duplicate strategies and need to be sorted in ascending address order
    /// @param token The rewards token to be distributed
    /// @param amount The total amount of tokens to be distributed
    /// @param startTimestamp The timestamp (seconds) at which the submission range is considered for distribution
    /// could start in the past or in the future but within a valid range. See the diagram above.
    /// @param duration The duration of the submission range in seconds. Must be <= MAX_REWARDS_DURATION
    struct RewardsSubmission {
        StrategyAndMultiplier[] strategiesAndMultipliers;
        IERC20 token;
        uint256 amount;
        uint32 startTimestamp;
        uint32 duration;
    }

    /// @notice OperatorDirectedRewardsSubmission struct submitted by AVSs when making operator-directed rewards for their operators and stakers.
    /// @param strategiesAndMultipliers The strategies and their relative weights.
    /// @param token The rewards token to be distributed.
    /// @param operatorRewards The rewards for the operators.
    /// @param startTimestamp The timestamp (seconds) at which the submission range is considered for distribution.
    /// @param duration The duration of the submission range in seconds.
    /// @param description Describes what the rewards submission is for.
    struct OperatorDirectedRewardsSubmission {
        StrategyAndMultiplier[] strategiesAndMultipliers;
        IERC20 token;
        OperatorReward[] operatorRewards;
        uint32 startTimestamp;
        uint32 duration;
        string description;
    }

    /// @notice A distribution root is a merkle root of the distribution of earnings for a given period.
    /// The RewardsCoordinator stores all historical distribution roots so that earners can claim their earnings against older roots
    /// if they wish but the merkle tree contains the cumulative earnings of all earners and tokens for a given period so earners (or their claimers if set)
    /// only need to claim against the latest root to claim all available earnings.
    /// @param root The merkle root of the distribution
    /// @param rewardsCalculationEndTimestamp The timestamp (seconds) until which rewards have been calculated
    /// @param activatedAt The timestamp (seconds) at which the root can be claimed against
    struct DistributionRoot {
        bytes32 root;
        uint32 rewardsCalculationEndTimestamp;
        uint32 activatedAt;
        bool disabled;
    }

    /// @notice Internal leaf in the merkle tree for the earner's account leaf
    /// @param earner The address of the earner
    /// @param earnerTokenRoot The merkle root of the earner's token subtree
    /// Each leaf in the earner's token subtree is a TokenTreeMerkleLeaf
    struct EarnerTreeMerkleLeaf {
        address earner;
        bytes32 earnerTokenRoot;
    }

    /// @notice The actual leaves in the distribution merkle tree specifying the token earnings
    /// for the respective earner's subtree. Each leaf is a claimable amount of a token for an earner.
    /// @param token The token for which the earnings are being claimed
    /// @param cumulativeEarnings The cumulative earnings of the earner for the token
    struct TokenTreeMerkleLeaf {
        IERC20 token;
        uint256 cumulativeEarnings;
    }

    /// @notice A claim against a distribution root called by an
    /// earners claimer (could be the earner themselves). Each token claim will claim the difference
    /// between the cumulativeEarnings of the earner and the cumulativeClaimed of the claimer.
    /// Each claim can specify which of the earner's earned tokens they want to claim.
    /// See `processClaim()` for more details.
    /// @param rootIndex The index of the root in the list of DistributionRoots
    /// @param earnerIndex The index of the earner's account root in the merkle tree
    /// @param earnerTreeProof The proof of the earner's EarnerTreeMerkleLeaf against the merkle root
    /// @param earnerLeaf The earner's EarnerTreeMerkleLeaf struct, providing the earner address and earnerTokenRoot
    /// @param tokenIndices The indices of the token leaves in the earner's subtree
    /// @param tokenTreeProofs The proofs of the token leaves against the earner's earnerTokenRoot
    /// @param tokenLeaves The token leaves to be claimed
    /// @dev The merkle tree is structured with the merkle root at the top and EarnerTreeMerkleLeaf as internal leaves
    /// in the tree. Each earner leaf has its own subtree with TokenTreeMerkleLeaf as leaves in the subtree.
    /// To prove a claim against a specified rootIndex(which specifies the distributionRoot being used),
    /// the claim will first verify inclusion of the earner leaf in the tree against _distributionRoots[rootIndex].root.
    /// Then for each token, it will verify inclusion of the token leaf in the earner's subtree against the earner's earnerTokenRoot.
    struct RewardsMerkleClaim {
        uint32 rootIndex;
        uint32 earnerIndex;
        bytes earnerTreeProof;
        EarnerTreeMerkleLeaf earnerLeaf;
        uint32[] tokenIndices;
        bytes[] tokenTreeProofs;
        TokenTreeMerkleLeaf[] tokenLeaves;
    }

    /// @notice Parameters for the RewardsCoordinator constructor
    /// @param delegationManager The address of the DelegationManager contract
    /// @param strategyManager The address of the StrategyManager contract
    /// @param allocationManager The address of the AllocationManager contract
    /// @param pauserRegistry The address of the PauserRegistry contract
    /// @param permissionController The address of the PermissionController contract
    /// @param CALCULATION_INTERVAL_SECONDS The interval at which rewards are calculated
    /// @param MAX_REWARDS_DURATION The maximum duration of a rewards submission
    /// @param MAX_RETROACTIVE_LENGTH The maximum retroactive length of a rewards submission
    /// @param MAX_FUTURE_LENGTH The maximum future length of a rewards submission
    /// @param GENESIS_REWARDS_TIMESTAMP The timestamp at which rewards are first calculated
    /// @param version The semantic version of the contract (e.g. "1.2.3")
    /// @dev Needed to avoid stack-too-deep errors
    struct RewardsCoordinatorConstructorParams {
        IDelegationManager delegationManager;
        IStrategyManager strategyManager;
        IAllocationManager allocationManager;
        IPauserRegistry pauserRegistry;
        IPermissionController permissionController;
        uint32 CALCULATION_INTERVAL_SECONDS;
        uint32 MAX_REWARDS_DURATION;
        uint32 MAX_RETROACTIVE_LENGTH;
        uint32 MAX_FUTURE_LENGTH;
        uint32 GENESIS_REWARDS_TIMESTAMP;
    }
}

interface IRewardsCoordinatorEvents is IRewardsCoordinatorTypes {
    /// @notice emitted when an AVS creates a valid RewardsSubmission
    event AVSRewardsSubmissionCreated(
        address indexed avs,
        uint256 indexed submissionNonce,
        bytes32 indexed rewardsSubmissionHash,
        RewardsSubmission rewardsSubmission
    );

    /// @notice emitted when a valid RewardsSubmission is created for all stakers by a valid submitter
    event RewardsSubmissionForAllCreated(
        address indexed submitter,
        uint256 indexed submissionNonce,
        bytes32 indexed rewardsSubmissionHash,
        RewardsSubmission rewardsSubmission
    );

    /// @notice emitted when a valid RewardsSubmission is created when rewardAllStakersAndOperators is called
    event RewardsSubmissionForAllEarnersCreated(
        address indexed tokenHopper,
        uint256 indexed submissionNonce,
        bytes32 indexed rewardsSubmissionHash,
        RewardsSubmission rewardsSubmission
    );

    /// @notice Emitted when an AVS creates a valid `OperatorDirectedRewardsSubmission`
    /// @param caller The address calling `createOperatorDirectedAVSRewardsSubmission`.
    /// @param avs The avs on behalf of which the operator-directed rewards are being submitted.
    /// @param operatorDirectedRewardsSubmissionHash Keccak256 hash of (`avs`, `submissionNonce` and `operatorDirectedRewardsSubmission`).
    /// @param submissionNonce Current nonce of the avs. Used to generate a unique submission hash.
    /// @param operatorDirectedRewardsSubmission The Operator-Directed Rewards Submission. Contains the token, start timestamp, duration, operator rewards, description and, strategy and multipliers.
    event OperatorDirectedAVSRewardsSubmissionCreated(
        address indexed caller,
        address indexed avs,
        bytes32 indexed operatorDirectedRewardsSubmissionHash,
        uint256 submissionNonce,
        OperatorDirectedRewardsSubmission operatorDirectedRewardsSubmission
    );

    /// @notice Emitted when an AVS creates a valid `OperatorDirectedRewardsSubmission` for an operator set.
    /// @param caller The address calling `createOperatorDirectedOperatorSetRewardsSubmission`.
    /// @param operatorDirectedRewardsSubmissionHash Keccak256 hash of (`avs`, `submissionNonce` and `operatorDirectedRewardsSubmission`).
    /// @param operatorSet The operatorSet on behalf of which the operator-directed rewards are being submitted.
    /// @param submissionNonce Current nonce of the avs. Used to generate a unique submission hash.
    /// @param operatorDirectedRewardsSubmission The Operator-Directed Rewards Submission. Contains the token, start timestamp, duration, operator rewards, description and, strategy and multipliers.
    event OperatorDirectedOperatorSetRewardsSubmissionCreated(
        address indexed caller,
        bytes32 indexed operatorDirectedRewardsSubmissionHash,
        OperatorSet operatorSet,
        uint256 submissionNonce,
        OperatorDirectedRewardsSubmission operatorDirectedRewardsSubmission
    );

    /// @notice rewardsUpdater is responsible for submitting DistributionRoots, only owner can set rewardsUpdater
    event RewardsUpdaterSet(address indexed oldRewardsUpdater, address indexed newRewardsUpdater);

    event RewardsForAllSubmitterSet(
        address indexed rewardsForAllSubmitter,
        bool indexed oldValue,
        bool indexed newValue
    );

    event ActivationDelaySet(uint32 oldActivationDelay, uint32 newActivationDelay);
    event DefaultOperatorSplitBipsSet(uint16 oldDefaultOperatorSplitBips, uint16 newDefaultOperatorSplitBips);

    /// @notice Emitted when the operator split for an AVS is set.
    /// @param caller The address calling `setOperatorAVSSplit`.
    /// @param operator The operator on behalf of which the split is being set.
    /// @param avs The avs for which the split is being set by the operator.
    /// @param activatedAt The timestamp at which the split will be activated.
    /// @param oldOperatorAVSSplitBips The old split for the operator for the AVS.
    /// @param newOperatorAVSSplitBips The new split for the operator for the AVS.
    event OperatorAVSSplitBipsSet(
        address indexed caller,
        address indexed operator,
        address indexed avs,
        uint32 activatedAt,
        uint16 oldOperatorAVSSplitBips,
        uint16 newOperatorAVSSplitBips
    );

    /// @notice Emitted when the operator split for Programmatic Incentives is set.
    /// @param caller The address calling `setOperatorPISplit`.
    /// @param operator The operator on behalf of which the split is being set.
    /// @param activatedAt The timestamp at which the split will be activated.
    /// @param oldOperatorPISplitBips The old split for the operator for Programmatic Incentives.
    /// @param newOperatorPISplitBips The new split for the operator for Programmatic Incentives.
    event OperatorPISplitBipsSet(
        address indexed caller,
        address indexed operator,
        uint32 activatedAt,
        uint16 oldOperatorPISplitBips,
        uint16 newOperatorPISplitBips
    );

    /// @notice Emitted when the operator split for a given operatorSet is set.
    /// @param caller The address calling `setOperatorSetSplit`.
    /// @param operator The operator on behalf of which the split is being set.
    /// @param operatorSet The operatorSet for which the split is being set.
    /// @param activatedAt The timestamp at which the split will be activated.
    /// @param oldOperatorSetSplitBips The old split for the operator for the operatorSet.
    /// @param newOperatorSetSplitBips The new split for the operator for the operatorSet.
    event OperatorSetSplitBipsSet(
        address indexed caller,
        address indexed operator,
        OperatorSet operatorSet,
        uint32 activatedAt,
        uint16 oldOperatorSetSplitBips,
        uint16 newOperatorSetSplitBips
    );

    event ClaimerForSet(address indexed earner, address indexed oldClaimer, address indexed claimer);

    /// @notice rootIndex is the specific array index of the newly created root in the storage array
    event DistributionRootSubmitted(
        uint32 indexed rootIndex,
        bytes32 indexed root,
        uint32 indexed rewardsCalculationEndTimestamp,
        uint32 activatedAt
    );

    event DistributionRootDisabled(uint32 indexed rootIndex);

    /// @notice root is one of the submitted distribution roots that was claimed against
    event RewardsClaimed(
        bytes32 root,
        address indexed earner,
        address indexed claimer,
        address indexed recipient,
        IERC20 token,
        uint256 claimedAmount
    );
}

/// @title Interface for the `IRewardsCoordinator` contract.
/// @author Layr Labs, Inc.
/// @notice Terms of Service: https://docs.eigenlayer.xyz/overview/terms-of-service
/// @notice Allows AVSs to make "Rewards Submissions", which get distributed amongst the AVSs' confirmed
/// Operators and the Stakers delegated to those Operators.
/// Calculations are performed based on the completed RewardsSubmission, with the results posted in
/// a Merkle root against which Stakers & Operators can make claims.
interface IRewardsCoordinator is IRewardsCoordinatorErrors, IRewardsCoordinatorEvents {
    /// @dev Initializes the addresses of the initial owner, pauser registry, rewardsUpdater and
    /// configures the initial paused status, activationDelay, and defaultOperatorSplitBips.
    function initialize(
        address initialOwner,
        uint256 initialPausedStatus,
        address _rewardsUpdater,
        uint32 _activationDelay,
        uint16 _defaultSplitBips
    ) external;

    /// @notice Creates a new rewards submission on behalf of an AVS, to be split amongst the
    /// set of stakers delegated to operators who are registered to the `avs`
    /// @param rewardsSubmissions The rewards submissions being created
    /// @dev Expected to be called by the ServiceManager of the AVS on behalf of which the submission is being made
    /// @dev The duration of the `rewardsSubmission` cannot exceed `MAX_REWARDS_DURATION`
    /// @dev The duration of the `rewardsSubmission` cannot be 0 and must be a multiple of `CALCULATION_INTERVAL_SECONDS`
    /// @dev The tokens are sent to the `RewardsCoordinator` contract
    /// @dev Strategies must be in ascending order of addresses to check for duplicates
    /// @dev This function will revert if the `rewardsSubmission` is malformed,
    /// e.g. if the `strategies` and `weights` arrays are of non-equal lengths
    function createAVSRewardsSubmission(
        RewardsSubmission[] calldata rewardsSubmissions
    ) external;

    /// @notice similar to `createAVSRewardsSubmission` except the rewards are split amongst *all* stakers
    /// rather than just those delegated to operators who are registered to a single avs and is
    /// a permissioned call based on isRewardsForAllSubmitter mapping.
    /// @param rewardsSubmissions The rewards submissions being created
    function createRewardsForAllSubmission(
        RewardsSubmission[] calldata rewardsSubmissions
    ) external;

    /// @notice Creates a new rewards submission for all earners across all AVSs.
    /// Earners in this case indicating all operators and their delegated stakers. Undelegated stake
    /// is not rewarded from this RewardsSubmission. This interface is only callable
    /// by the token hopper contract from the Eigen Foundation
    /// @param rewardsSubmissions The rewards submissions being created
    function createRewardsForAllEarners(
        RewardsSubmission[] calldata rewardsSubmissions
    ) external;

    /// @notice Creates a new operator-directed rewards submission on behalf of an AVS, to be split amongst the operators and
    /// set of stakers delegated to operators who are registered to the `avs`.
    /// @param avs The AVS on behalf of which the reward is being submitted
    /// @param operatorDirectedRewardsSubmissions The operator-directed rewards submissions being created
    /// @dev Expected to be called by the ServiceManager of the AVS on behalf of which the submission is being made
    /// @dev The duration of the `rewardsSubmission` cannot exceed `MAX_REWARDS_DURATION`
    /// @dev The duration of the `rewardsSubmission` cannot be 0 and must be a multiple of `CALCULATION_INTERVAL_SECONDS`
    /// @dev The tokens are sent to the `RewardsCoordinator` contract
    /// @dev The `RewardsCoordinator` contract needs a token approval of sum of all `operatorRewards` in the `operatorDirectedRewardsSubmissions`, before calling this function.
    /// @dev Strategies must be in ascending order of addresses to check for duplicates
    /// @dev Operators must be in ascending order of addresses to check for duplicates.
    /// @dev This function will revert if the `operatorDirectedRewardsSubmissions` is malformed.
    function createOperatorDirectedAVSRewardsSubmission(
        address avs,
        OperatorDirectedRewardsSubmission[] calldata operatorDirectedRewardsSubmissions
    ) external;

    /// @notice Creates a new operator-directed rewards submission for an operator set, to be split amongst the operators and
    /// set of stakers delegated to operators who are part of the operator set.
    /// @param operatorSet The operator set for which the rewards are being submitted
    /// @param operatorDirectedRewardsSubmissions The operator-directed rewards submissions being created
    /// @dev Expected to be called by the AVS that created the operator set
    /// @dev The duration of the `rewardsSubmission` cannot exceed `MAX_REWARDS_DURATION`
    /// @dev The duration of the `rewardsSubmission` cannot be 0 and must be a multiple of `CALCULATION_INTERVAL_SECONDS`
    /// @dev The tokens are sent to the `RewardsCoordinator` contract
    /// @dev The `RewardsCoordinator` contract needs a token approval of sum of all `operatorRewards` in the `operatorDirectedRewardsSubmissions`, before calling this function
    /// @dev Strategies must be in ascending order of addresses to check for duplicates
    /// @dev Operators must be in ascending order of addresses to check for duplicates
    /// @dev This function will revert if the `operatorDirectedRewardsSubmissions` is malformed
    function createOperatorDirectedOperatorSetRewardsSubmission(
        OperatorSet calldata operatorSet,
        OperatorDirectedRewardsSubmission[] calldata operatorDirectedRewardsSubmissions
    ) external;

    /// @notice Claim rewards against a given root (read from _distributionRoots[claim.rootIndex]).
    /// Earnings are cumulative so earners don't have to claim against all distribution roots they have earnings for,
    /// they can simply claim against the latest root and the contract will calculate the difference between
    /// their cumulativeEarnings and cumulativeClaimed. This difference is then transferred to recipient address.
    /// @param claim The RewardsMerkleClaim to be processed.
    /// Contains the root index, earner, token leaves, and required proofs
    /// @param recipient The address recipient that receives the ERC20 rewards
    /// @dev only callable by the valid claimer, that is
    /// if claimerFor[claim.earner] is address(0) then only the earner can claim, otherwise only
    /// claimerFor[claim.earner] can claim the rewards.
    function processClaim(
        RewardsMerkleClaim calldata claim,
        address recipient
    ) external;

    /// @notice Batch claim rewards against a given root (read from _distributionRoots[claim.rootIndex]).
    /// Earnings are cumulative so earners don't have to claim against all distribution roots they have earnings for,
    /// they can simply claim against the latest root and the contract will calculate the difference between
    /// their cumulativeEarnings and cumulativeClaimed. This difference is then transferred to recipient address.
    /// @param claims The RewardsMerkleClaims to be processed.
    /// Contains the root index, earner, token leaves, and required proofs
    /// @param recipient The address recipient that receives the ERC20 rewards
    /// @dev only callable by the valid claimer, that is
    /// if claimerFor[claim.earner] is address(0) then only the earner can claim, otherwise only
    /// claimerFor[claim.earner] can claim the rewards.
    /// @dev This function may fail to execute with a large number of claims due to gas limits. Use a smaller array of claims if necessary.
    function processClaims(
        RewardsMerkleClaim[] calldata claims,
        address recipient
    ) external;

    /// @notice Creates a new distribution root. activatedAt is set to block.timestamp + activationDelay
    /// @param root The merkle root of the distribution
    /// @param rewardsCalculationEndTimestamp The timestamp until which rewards have been calculated
    /// @dev Only callable by the rewardsUpdater
    function submitRoot(
        bytes32 root,
        uint32 rewardsCalculationEndTimestamp
    ) external;

    /// @notice allow the rewardsUpdater to disable/cancel a pending root submission in case of an error
    /// @param rootIndex The index of the root to be disabled
    function disableRoot(
        uint32 rootIndex
    ) external;

    /// @notice Sets the address of the entity that can call `processClaim` on ehalf of an earner
    /// @param claimer The address of the entity that can call `processClaim` on behalf of the earner
    /// @dev Assumes msg.sender is the earner
    function setClaimerFor(
        address claimer
    ) external;

    /// @notice Sets the address of the entity that can call `processClaim` on behalf of an earner
    /// @param earner The address to set the claimer for
    /// @param claimer The address of the entity that can call `processClaim` on behalf of the earner
    /// @dev Only callable by operators or AVSs. We define an AVS that has created at least one
    ///      operatorSet in the `AllocationManager`
    function setClaimerFor(
        address earner,
        address claimer
    ) external;

    /// @notice Sets the delay in timestamp before a posted root can be claimed against
    /// @dev Only callable by the contract owner
    /// @param _activationDelay The new value for activationDelay
    function setActivationDelay(
        uint32 _activationDelay
    ) external;

    /// @notice Sets the default split for all operators across all avss.
    /// @param split The default split for all operators across all avss in bips.
    /// @dev Only callable by the contract owner.
    function setDefaultOperatorSplit(
        uint16 split
    ) external;

    /// @notice Sets the split for a specific operator for a specific avs
    /// @param operator The operator who is setting the split
    /// @param avs The avs for which the split is being set by the operator
    /// @param split The split for the operator for the specific avs in bips.
    /// @dev Only callable by the operator
    /// @dev Split has to be between 0 and 10000 bips (inclusive)
    /// @dev The split will be activated after the activation delay
    function setOperatorAVSSplit(
        address operator,
        address avs,
        uint16 split
    ) external;

    /// @notice Sets the split for a specific operator for Programmatic Incentives.
    /// @param operator The operator on behalf of which the split is being set.
    /// @param split The split for the operator for Programmatic Incentives in bips.
    /// @dev Only callable by the operator
    /// @dev Split has to be between 0 and 10000 bips (inclusive)
    /// @dev The split will be activated after the activation delay
    function setOperatorPISplit(
        address operator,
        uint16 split
    ) external;

    /// @notice Sets the split for a specific operator for a specific operatorSet.
    /// @param operator The operator who is setting the split.
    /// @param operatorSet The operatorSet for which the split is being set by the operator.
    /// @param split The split for the operator for the specific operatorSet in bips.
    /// @dev Only callable by the operator
    /// @dev Split has to be between 0 and 10000 bips (inclusive)
    /// @dev The split will be activated after the activation delay
    function setOperatorSetSplit(
        address operator,
        OperatorSet calldata operatorSet,
        uint16 split
    ) external;

    /// @notice Sets the permissioned `rewardsUpdater` address which can post new roots
    /// @dev Only callable by the contract owner
    /// @param _rewardsUpdater The address of the new rewardsUpdater
    function setRewardsUpdater(
        address _rewardsUpdater
    ) external;

    /// @notice Sets the permissioned `rewardsForAllSubmitter` address which can submit createRewardsForAllSubmission
    /// @dev Only callable by the contract owner
    /// @param _submitter The address of the rewardsForAllSubmitter
    /// @param _newValue The new value for isRewardsForAllSubmitter
    function setRewardsForAllSubmitter(
        address _submitter,
        bool _newValue
    ) external;

    ///
    ///                         VIEW FUNCTIONS
    ///

    /// @notice Delay in timestamp (seconds) before a posted root can be claimed against
    function activationDelay() external view returns (uint32);

    /// @notice The timestamp until which RewardsSubmissions have been calculated
    function currRewardsCalculationEndTimestamp() external view returns (uint32);

    /// @notice Mapping: earner => the address of the entity who can call `processClaim` on behalf of the earner
    function claimerFor(
        address earner
    ) external view returns (address);

    /// @notice Mapping: claimer => token => total amount claimed
    function cumulativeClaimed(
        address claimer,
        IERC20 token
    ) external view returns (uint256);

    /// @notice the default split for all operators across all avss
    function defaultOperatorSplitBips() external view returns (uint16);

    /// @notice the split for a specific `operator` for a specific `avs`
    function getOperatorAVSSplit(
        address operator,
        address avs
    ) external view returns (uint16);

    /// @notice the split for a specific `operator` for Programmatic Incentives
    function getOperatorPISplit(
        address operator
    ) external view returns (uint16);

    /// @notice Returns the split for a specific `operator` for a given `operatorSet`
    function getOperatorSetSplit(
        address operator,
        OperatorSet calldata operatorSet
    ) external view returns (uint16);

    /// @notice return the hash of the earner's leaf
    function calculateEarnerLeafHash(
        EarnerTreeMerkleLeaf calldata leaf
    ) external pure returns (bytes32);

    /// @notice returns the hash of the earner's token leaf
    function calculateTokenLeafHash(
        TokenTreeMerkleLeaf calldata leaf
    ) external pure returns (bytes32);

    /// @notice returns 'true' if the claim would currently pass the check in `processClaims`
    /// but will revert if not valid
    function checkClaim(
        RewardsMerkleClaim calldata claim
    ) external view returns (bool);

    /// @notice returns the number of distribution roots posted
    function getDistributionRootsLength() external view returns (uint256);

    /// @notice returns the distributionRoot at the specified index
    function getDistributionRootAtIndex(
        uint256 index
    ) external view returns (DistributionRoot memory);

    /// @notice returns the current distributionRoot
    function getCurrentDistributionRoot() external view returns (DistributionRoot memory);

    /// @notice loop through the distribution roots from reverse and get latest root that is not disabled and activated
    /// i.e. a root that can be claimed against
    function getCurrentClaimableDistributionRoot() external view returns (DistributionRoot memory);

    /// @notice loop through distribution roots from reverse and return index from hash
    function getRootIndexFromHash(
        bytes32 rootHash
    ) external view returns (uint32);

    /// @notice The address of the entity that can update the contract with new merkle roots
    function rewardsUpdater() external view returns (address);

    /// @notice The interval in seconds at which the calculation for a RewardsSubmission distribution is done.
    /// @dev Rewards Submission durations must be multiples of this interval.
    function CALCULATION_INTERVAL_SECONDS() external view returns (uint32);

    /// @notice The maximum amount of time (seconds) that a RewardsSubmission can span over
    function MAX_REWARDS_DURATION() external view returns (uint32);

    /// @notice max amount of time (seconds) that a submission can start in the past
    function MAX_RETROACTIVE_LENGTH() external view returns (uint32);

    /// @notice max amount of time (seconds) that a submission can start in the future
    function MAX_FUTURE_LENGTH() external view returns (uint32);

    /// @notice absolute min timestamp (seconds) that a submission can start at
    function GENESIS_REWARDS_TIMESTAMP() external view returns (uint32);
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.27;

interface IPermissionControllerErrors {
    /// @notice Thrown when a non-admin caller attempts to perform an admin-only action.
    error NotAdmin();
    /// @notice Thrown when attempting to remove an admin that does not exist.
    error AdminNotSet();
    /// @notice Thrown when attempting to set an appointee for a function that already has one.
    error AppointeeAlreadySet();
    /// @notice Thrown when attempting to interact with a non-existent appointee.
    error AppointeeNotSet();
    /// @notice Thrown when attempting to remove the last remaining admin.
    error CannotHaveZeroAdmins();
    /// @notice Thrown when attempting to set an admin that is already registered.
    error AdminAlreadySet();
    /// @notice Thrown when attempting to interact with an admin that is not in pending status.
    error AdminNotPending();
    /// @notice Thrown when attempting to add an admin that is already pending.
    error AdminAlreadyPending();
}

interface IPermissionControllerEvents {
    /// @notice Emitted when an appointee is set for an account to handle specific function calls.
    event AppointeeSet(address indexed account, address indexed appointee, address target, bytes4 selector);

    /// @notice Emitted when an appointee's permission to handle function calls for an account is revoked.
    event AppointeeRemoved(address indexed account, address indexed appointee, address target, bytes4 selector);

    /// @notice Emitted when an address is set as a pending admin for an account, requiring acceptance.
    event PendingAdminAdded(address indexed account, address admin);

    /// @notice Emitted when a pending admin status is removed for an account before acceptance.
    event PendingAdminRemoved(address indexed account, address admin);

    /// @notice Emitted when an address accepts and becomes an active admin for an account.
    event AdminSet(address indexed account, address admin);

    /// @notice Emitted when an admin's permissions are removed from an account.
    event AdminRemoved(address indexed account, address admin);
}

interface IPermissionController is IPermissionControllerErrors, IPermissionControllerEvents {
    /// @notice Sets a pending admin for an account.
    /// @param account The account to set the pending admin for.
    /// @param admin The address to set as pending admin.
    /// @dev The pending admin must accept the role before becoming an active admin.
    /// @dev Multiple admins can be set for a single account.
    function addPendingAdmin(
        address account,
        address admin
    ) external;

    /// @notice Removes a pending admin from an account before they have accepted the role.
    /// @param account The account to remove the pending admin from.
    /// @param admin The pending admin address to remove.
    /// @dev Only an existing admin of the account can remove a pending admin.
    function removePendingAdmin(
        address account,
        address admin
    ) external;

    /// @notice Allows a pending admin to accept their admin role for an account.
    /// @param account The account to accept the admin role for.
    /// @dev Only addresses that were previously set as pending admins can accept the role.
    function acceptAdmin(
        address account
    ) external;

    /// @notice Removes an active admin from an account.
    /// @param account The account to remove the admin from.
    /// @param admin The admin address to remove.
    /// @dev Only an existing admin of the account can remove another admin.
    /// @dev Will revert if removing this admin would leave the account with zero admins.
    function removeAdmin(
        address account,
        address admin
    ) external;

    /// @notice Sets an appointee who can call specific functions on behalf of an account.
    /// @param account The account to set the appointee for.
    /// @param appointee The address to be given permission.
    /// @param target The contract address the appointee can interact with.
    /// @param selector The function selector the appointee can call.
    /// @dev Only an admin of the account can set appointees.
    function setAppointee(
        address account,
        address appointee,
        address target,
        bytes4 selector
    ) external;

    /// @notice Removes an appointee's permission to call a specific function.
    /// @param account The account to remove the appointee from.
    /// @param appointee The appointee address to remove.
    /// @param target The contract address to remove permissions for.
    /// @param selector The function selector to remove permissions for.
    /// @dev Only an admin of the account can remove appointees.
    function removeAppointee(
        address account,
        address appointee,
        address target,
        bytes4 selector
    ) external;

    /// @notice Checks if a given address is an admin of an account.
    /// @param account The account to check admin status for.
    /// @param caller The address to check.
    /// @dev If the account has no admins, returns true only if the caller is the account itself.
    /// @return Returns true if the caller is an admin, false otherwise.
    function isAdmin(
        address account,
        address caller
    ) external view returns (bool);

    /// @notice Checks if an address is currently a pending admin for an account.
    /// @param account The account to check pending admin status for.
    /// @param pendingAdmin The address to check.
    /// @return Returns true if the address is a pending admin, false otherwise.
    function isPendingAdmin(
        address account,
        address pendingAdmin
    ) external view returns (bool);

    /// @notice Retrieves all active admins for an account.
    /// @param account The account to get the admins for.
    /// @dev If the account has no admins, returns an array containing only the account address.
    /// @return An array of admin addresses.
    function getAdmins(
        address account
    ) external view returns (address[] memory);

    /// @notice Retrieves all pending admins for an account.
    /// @param account The account to get the pending admins for.
    /// @return An array of pending admin addresses.
    function getPendingAdmins(
        address account
    ) external view returns (address[] memory);

    /// @notice Checks if a caller has permission to call a specific function.
    /// @param account The account to check permissions for.
    /// @param caller The address attempting to make the call.
    /// @param target The contract address being called.
    /// @param selector The function selector being called.
    /// @dev Returns true if the caller is either an admin or an appointed caller.
    /// @dev Be mindful that upgrades to the contract may invalidate the appointee's permissions.
    /// This is only possible if a function's selector changes (e.g. if a function's parameters are modified).
    /// @return Returns true if the caller has permission, false otherwise.
    function canCall(
        address account,
        address caller,
        address target,
        bytes4 selector
    ) external view returns (bool);

    /// @notice Retrieves all permissions granted to an appointee for a given account.
    /// @param account The account to check appointee permissions for.
    /// @param appointee The appointee address to check.
    /// @return Two arrays: target contract addresses and their corresponding function selectors.
    function getAppointeePermissions(
        address account,
        address appointee
    ) external view returns (address[] memory, bytes4[] memory);

    /// @notice Retrieves all appointees that can call a specific function for an account.
    /// @param account The account to get appointees for.
    /// @param target The contract address to check.
    /// @param selector The function selector to check.
    /// @dev Does not include admins in the returned list, even though they have calling permission.
    /// @return An array of appointee addresses.
    function getAppointees(
        address account,
        address target,
        bytes4 selector
    ) external view returns (address[] memory);
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity >=0.5.0;

/// @title Interface for the `PauserRegistry` contract.
/// @author Layr Labs, Inc.
/// @notice Terms of Service: https://docs.eigenlayer.xyz/overview/terms-of-service
interface IPauserRegistry {
    error OnlyUnpauser();
    error InputAddressZero();

    event PauserStatusChanged(address pauser, bool canPause);

    event UnpauserChanged(address previousUnpauser, address newUnpauser);

    /// @notice Mapping of addresses to whether they hold the pauser role.
    function isPauser(
        address pauser
    ) external view returns (bool);

    /// @notice Unique address that holds the unpauser role. Capable of changing *both* the pauser and unpauser addresses.
    function unpauser() external view returns (address);
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.27;

using OperatorSetLib for OperatorSet global;

/// @notice An operator set identified by the AVS address and an identifier
/// @param avs The address of the AVS this operator set belongs to
/// @param id The unique identifier for the operator set
struct OperatorSet {
    address avs;
    uint32 id;
}

library OperatorSetLib {
    function key(
        OperatorSet memory os
    ) internal pure returns (bytes32) {
        return bytes32(abi.encodePacked(os.avs, uint96(os.id)));
    }

    function decode(
        bytes32 _key
    ) internal pure returns (OperatorSet memory) {
        /// forgefmt: disable-next-item
        return OperatorSet({
            avs: address(uint160(uint256(_key) >> 96)),
            id: uint32(uint256(_key) & type(uint96).max)
        });
    }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity >=0.5.0;

import {OperatorSet} from "../libraries/OperatorSetLib.sol";
import "./IDelegationManager.sol";
import "./IPauserRegistry.sol";
import "./IPausable.sol";
import "./IStrategy.sol";
import "./IAVSRegistrar.sol";

interface IAllocationManagerErrors {
    /// Input Validation
    /// @dev Thrown when `wadToSlash` is zero or greater than 1e18
    error InvalidWadToSlash();
    /// @dev Thrown when two array parameters have mismatching lengths.
    error InputArrayLengthMismatch();
    /// @dev Thrown when the AVSRegistrar is not correctly configured to prevent an AVSRegistrar contract
    /// from being used with the wrong AVS
    error InvalidAVSRegistrar();
    /// @dev Thrown when an invalid strategy is provided.
    error InvalidStrategy();
    /// @dev Thrown when an invalid redistribution recipient is provided.
    error InvalidRedistributionRecipient();
    /// @dev Thrown when an operatorSet is already migrated
    error OperatorSetAlreadyMigrated();

    /// Caller

    /// @dev Thrown when caller is not authorized to call a function.
    error InvalidCaller();

    /// Operator Status

    /// @dev Thrown when an invalid operator is provided.
    error InvalidOperator();
    /// @dev Thrown when an invalid avs whose metadata is not registered is provided.
    error NonexistentAVSMetadata();
    /// @dev Thrown when an operator's allocation delay has yet to be set.
    error UninitializedAllocationDelay();
    /// @dev Thrown when attempting to slash an operator when they are not slashable.
    error OperatorNotSlashable();
    /// @dev Thrown when trying to add an operator to a set they are already a member of
    error AlreadyMemberOfSet();
    /// @dev Thrown when trying to slash/remove an operator from a set they are not a member of
    error NotMemberOfSet();

    /// Operator Set Status

    /// @dev Thrown when an invalid operator set is provided.
    error InvalidOperatorSet();
    /// @dev Thrown when provided `strategies` are not in ascending order.
    error StrategiesMustBeInAscendingOrder();
    /// @dev Thrown when trying to add a strategy to an operator set that already contains it.
    error StrategyAlreadyInOperatorSet();
    /// @dev Thrown when a strategy is referenced that does not belong to an operator set.
    error StrategyNotInOperatorSet();

    /// Modifying Allocations

    /// @dev Thrown when an operator attempts to set their allocation for an operatorSet to the same value
    error SameMagnitude();
    /// @dev Thrown when an allocation is attempted for a given operator when they have pending allocations or deallocations.
    error ModificationAlreadyPending();
    /// @dev Thrown when an allocation is attempted that exceeds a given operators total allocatable magnitude.
    error InsufficientMagnitude();

    /// SlasherStatus

    /// @dev Thrown when an operator set does not have a slasher set
    error SlasherNotSet();
}

interface IAllocationManagerTypes {
    /// @notice Defines allocation information from a strategy to an operator set, for an operator
    /// @param currentMagnitude the current magnitude allocated from the strategy to the operator set
    /// @param pendingDiff a pending change in magnitude, if it exists (0 otherwise)
    /// @param effectBlock the block at which the pending magnitude diff will take effect
    struct Allocation {
        uint64 currentMagnitude;
        int128 pendingDiff;
        uint32 effectBlock;
    }

    /// @notice Slasher configuration for an operator set.
    /// @param slasher The current effective slasher address. Updated immediately when instantEffectBlock=true
    ///        (e.g., during operator set creation or migration).
    /// @param pendingSlasher The slasher address that will become effective at effectBlock.
    /// @param effectBlock The block number at which pendingSlasher becomes the effective slasher.
    /// @dev It is not possible for the slasher to be the 0 address, which is used to denote if the slasher is not set
    struct SlasherParams {
        address slasher;
        address pendingSlasher;
        uint32 effectBlock;
    }

    /// @notice Allocation delay configuration for an operator.
    /// @param delay The current effective allocation delay. Updated immediately for newly registered operators.
    /// @param isSet Whether the allocation delay has been configured. True immediately for newly registered operators.
    /// @param pendingDelay The allocation delay that will become effective at effectBlock.
    /// @param effectBlock The block number at which pendingDelay becomes the effective delay.
    struct AllocationDelayInfo {
        uint32 delay;
        bool isSet;
        uint32 pendingDelay;
        uint32 effectBlock;
    }

    /// @notice Contains registration details for an operator pertaining to an operator set
    /// @param registered Whether the operator is currently registered for the operator set
    /// @param slashableUntil If the operator is not registered, they are still slashable until
    /// this block is reached.
    struct RegistrationStatus {
        bool registered;
        uint32 slashableUntil;
    }

    /// @notice Contains allocation info for a specific strategy
    /// @param maxMagnitude the maximum magnitude that can be allocated between all operator sets
    /// @param encumberedMagnitude the currently-allocated magnitude for the strategy
    struct StrategyInfo {
        uint64 maxMagnitude;
        uint64 encumberedMagnitude;
    }

    /// @notice Struct containing parameters to slashing
    /// @param operator the address to slash
    /// @param operatorSetId the ID of the operatorSet the operator is being slashed on behalf of
    /// @param strategies the set of strategies to slash
    /// @param wadsToSlash the parts in 1e18 to slash, this will be proportional to the operator's
    /// slashable stake allocation for the operatorSet
    /// @param description the description of the slashing provided by the AVS for legibility
    struct SlashingParams {
        address operator;
        uint32 operatorSetId;
        IStrategy[] strategies;
        uint256[] wadsToSlash;
        string description;
    }

    /// @notice struct used to modify the allocation of slashable magnitude to an operator set
    /// @param operatorSet the operator set to modify the allocation for
    /// @param strategies the strategies to modify allocations for
    /// @param newMagnitudes the new magnitude to allocate for each strategy to this operator set
    struct AllocateParams {
        OperatorSet operatorSet;
        IStrategy[] strategies;
        uint64[] newMagnitudes;
    }

    /// @notice Parameters used to register for an AVS's operator sets
    /// @param avs the AVS being registered for
    /// @param operatorSetIds the operator sets within the AVS to register for
    /// @param data extra data to be passed to the AVS to complete registration
    struct RegisterParams {
        address avs;
        uint32[] operatorSetIds;
        bytes data;
    }

    /// @notice Parameters used to deregister from an AVS's operator sets
    /// @param operator the operator being deregistered
    /// @param avs the avs being deregistered from
    /// @param operatorSetIds the operator sets within the AVS being deregistered from
    struct DeregisterParams {
        address operator;
        address avs;
        uint32[] operatorSetIds;
    }

    /// @notice Parameters used by an AVS to create new operator sets
    /// @param operatorSetId the id of the operator set to create
    /// @param strategies the strategies to add as slashable to the operator set
    /// @dev This struct and its associated method will be deprecated in Early Q2 2026
    struct CreateSetParams {
        uint32 operatorSetId;
        IStrategy[] strategies;
    }
    /// @notice Parameters used by an AVS to create new operator sets
    /// @param operatorSetId the id of the operator set to create
    /// @param strategies the strategies to add as slashable to the operator set
    /// @param slasher the address that will be the slasher for the operator set

    struct CreateSetParamsV2 {
        uint32 operatorSetId;
        IStrategy[] strategies;
        address slasher;
    }
}

interface IAllocationManagerEvents is IAllocationManagerTypes {
    /// @notice Emitted when operator updates their allocation delay.
    event AllocationDelaySet(address operator, uint32 delay, uint32 effectBlock);

    /// @notice Emitted when an operator set's slasher is updated.
    event SlasherUpdated(OperatorSet operatorSet, address slasher, uint32 effectBlock);

    /// @notice Emitted when an operator set's slasher is migrated.
    event SlasherMigrated(OperatorSet operatorSet, address slasher);

    /// @notice Emitted when an operator's magnitude is updated for a given operatorSet and strategy
    event AllocationUpdated(
        address operator,
        OperatorSet operatorSet,
        IStrategy strategy,
        uint64 magnitude,
        uint32 effectBlock
    );

    /// @notice Emitted when operator's encumbered magnitude is updated for a given strategy
    event EncumberedMagnitudeUpdated(address operator, IStrategy strategy, uint64 encumberedMagnitude);

    /// @notice Emitted when an operator's max magnitude is updated for a given strategy
    event MaxMagnitudeUpdated(address operator, IStrategy strategy, uint64 maxMagnitude);

    /// @notice Emitted when an operator is slashed by an operator set for a strategy
    /// `wadSlashed` is the proportion of the operator's total delegated stake that was slashed
    event OperatorSlashed(
        address operator,
        OperatorSet operatorSet,
        IStrategy[] strategies,
        uint256[] wadSlashed,
        string description
    );

    /// @notice Emitted when an AVS configures the address that will handle registration/deregistration
    event AVSRegistrarSet(address avs, IAVSRegistrar registrar);

    /// @notice Emitted when an AVS updates their metadata URI (Uniform Resource Identifier).
    /// @dev The URI is never stored; it is simply emitted through an event for off-chain indexing.
    event AVSMetadataURIUpdated(address indexed avs, string metadataURI);

    /// @notice Emitted when an operator set is created by an AVS.
    event OperatorSetCreated(OperatorSet operatorSet);

    /// @notice Emitted when an operator is added to an operator set.
    event OperatorAddedToOperatorSet(address indexed operator, OperatorSet operatorSet);

    /// @notice Emitted when an operator is removed from an operator set.
    event OperatorRemovedFromOperatorSet(address indexed operator, OperatorSet operatorSet);

    /// @notice Emitted when a redistributing operator set is created by an AVS.
    event RedistributionAddressSet(OperatorSet operatorSet, address redistributionRecipient);

    /// @notice Emitted when a strategy is added to an operator set.
    event StrategyAddedToOperatorSet(OperatorSet operatorSet, IStrategy strategy);

    /// @notice Emitted when a strategy is removed from an operator set.
    event StrategyRemovedFromOperatorSet(OperatorSet operatorSet, IStrategy strategy);
}

interface IAllocationManagerStorage is IAllocationManagerEvents {
    /// @notice The DelegationManager contract for EigenLayer
    function delegation() external view returns (IDelegationManager);

    /// @notice The Eigen strategy contract
    /// @dev Cannot be added to redistributing operator sets
    function eigenStrategy() external view returns (IStrategy);

    /// @notice Returns the number of blocks between an operator deallocating magnitude and the magnitude becoming
    /// unslashable and then being able to be reallocated to another operator set. Note that unlike the allocation delay
    /// which is configurable by the operator, the DEALLOCATION_DELAY is globally fixed and cannot be changed.
    function DEALLOCATION_DELAY() external view returns (uint32 delay);

    /// @notice Delay before alloaction delay modifications take effect.
    function ALLOCATION_CONFIGURATION_DELAY() external view returns (uint32);

    /// @notice Delay before slasher changes take effect.
    /// @dev Currently set to the same value as ALLOCATION_CONFIGURATION_DELAY.
    function SLASHER_CONFIGURATION_DELAY() external view returns (uint32);
}

interface IAllocationManagerActions is IAllocationManagerErrors, IAllocationManagerEvents, IAllocationManagerStorage {
    /// @dev Initializes the initial owner and paused status.
    function initialize(
        uint256 initialPausedStatus
    ) external;

    /// @notice Called by an AVS to slash an operator in a given operator set. The operator must be registered
    /// and have slashable stake allocated to the operator set.
    ///
    /// @param avs The AVS address initiating the slash.
    /// @param params The slashing parameters, containing:
    ///  - operator: The operator to slash.
    ///  - operatorSetId: The ID of the operator set the operator is being slashed from.
    ///  - strategies: Array of strategies to slash allocations from (must be in ascending order).
    ///  - wadsToSlash: Array of proportions to slash from each strategy (must be between 0 and 1e18).
    ///  - description: Description of why the operator was slashed.
    ///
    /// @return slashId The ID of the slash.
    /// @return shares The amount of shares that were slashed for each strategy.
    ///
    /// @dev For each strategy:
    ///      1. Reduces the operator's current allocation magnitude by wadToSlash proportion.
    ///      2. Reduces the strategy's max and encumbered magnitudes proportionally.
    ///      3. If there is a pending deallocation, reduces it proportionally.
    ///      4. Updates the operator's shares in the DelegationManager.
    ///
    /// @dev Small slashing amounts may not result in actual token burns due to
    ///      rounding, which will result in small amounts of tokens locked in the contract
    ///      rather than fully burning through the burn mechanism.
    function slashOperator(
        address avs,
        SlashingParams calldata params
    ) external returns (uint256 slashId, uint256[] memory shares);

    /// @notice Modifies the proportions of slashable stake allocated to an operator set from a list of strategies
    /// Note that deallocations remain slashable for DEALLOCATION_DELAY blocks therefore when they are cleared they may
    /// free up less allocatable magnitude than initially deallocated.
    /// @param operator the operator to modify allocations for
    /// @param params array of magnitude adjustments for one or more operator sets
    /// @dev Updates encumberedMagnitude for the updated strategies
    function modifyAllocations(
        address operator,
        AllocateParams[] calldata params
    ) external;

    /// @notice This function takes a list of strategies and for each strategy, removes from the deallocationQueue
    /// all clearable deallocations up to max `numToClear` number of deallocations, updating the encumberedMagnitude
    /// of the operator as needed.
    ///
    /// @param operator address to clear deallocations for
    /// @param strategies a list of strategies to clear deallocations for
    /// @param numToClear a list of number of pending deallocations to clear for each strategy
    ///
    /// @dev can be called permissionlessly by anyone
    function clearDeallocationQueue(
        address operator,
        IStrategy[] calldata strategies,
        uint16[] calldata numToClear
    ) external;

    /// @notice Allows an operator to register for one or more operator sets for an AVS. If the operator
    /// has any stake allocated to these operator sets, it immediately becomes slashable.
    /// @dev After registering within the ALM, this method calls the AVS Registrar's `IAVSRegistrar.
    /// registerOperator` method to complete registration. This call MUST succeed in order for
    /// registration to be successful.
    function registerForOperatorSets(
        address operator,
        RegisterParams calldata params
    ) external;

    /// @notice Allows an operator or AVS to deregister the operator from one or more of the AVS's operator sets.
    /// If the operator has any slashable stake allocated to the AVS, it remains slashable until the
    /// DEALLOCATION_DELAY has passed.
    /// @dev After deregistering within the ALM, this method calls the AVS Registrar's `IAVSRegistrar.
    /// deregisterOperator` method to complete deregistration. This call MUST succeed in order for
    /// deregistration to be successful.
    function deregisterFromOperatorSets(
        DeregisterParams calldata params
    ) external;

    /// @notice Called by the delegation manager OR an operator to set an operator's allocation delay.
    /// This is set when the operator first registers, and is the number of blocks between an operator
    /// allocating magnitude to an operator set, and the magnitude becoming slashable.
    /// @param operator The operator to set the delay on behalf of.
    /// @param delay the allocation delay in blocks
    /// @dev When the delay is set for a newly-registered operator (via the `DelegationManager.registerAsOperator` method),
    /// the delay will take effect immediately, allowing for operators to allocate slashable stake immediately.
    /// Else, the delay will take effect after `ALLOCATION_CONFIGURATION_DELAY` blocks.
    function setAllocationDelay(
        address operator,
        uint32 delay
    ) external;

    /// @notice Called by an AVS to configure the address that is called when an operator registers
    /// or is deregistered from the AVS's operator sets. If not set (or set to 0), defaults
    /// to the AVS's address.
    /// @param registrar the new registrar address
    function setAVSRegistrar(
        address avs,
        IAVSRegistrar registrar
    ) external;

    ///  @notice Called by an AVS to emit an `AVSMetadataURIUpdated` event indicating the information has updated.
    ///
    ///  @param metadataURI The URI for metadata associated with an AVS.
    ///
    ///  @dev Note that the `metadataURI` is *never stored* and is only emitted in the `AVSMetadataURIUpdated` event.
    function updateAVSMetadataURI(
        address avs,
        string calldata metadataURI
    ) external;

    /// @notice Allows an AVS to create new operator sets, defining strategies that the operator set uses
    /// @dev Upon creation, the address that can slash the operatorSet is the `avs` address. If you would like to use a different address,
    ///      use the `createOperatorSets` method which takes in `CreateSetParamsV2` instead.
    /// @dev THIS FUNCTION WILL BE DEPRECATED IN EARLY Q2 2026 IN FAVOR OF `createOperatorSets`, WHICH TAKES IN `CreateSetParamsV2`
    /// @dev Reverts for:
    ///      - NonexistentAVSMetadata: The AVS metadata is not registered
    ///      - InvalidOperatorSet: The operatorSet already exists
    ///      - InputAddressZero: The slasher is the zero address
    function createOperatorSets(
        address avs,
        CreateSetParams[] calldata params
    ) external;

    /// @notice Allows an AVS to create new operator sets, defining strategies that the operator set uses
    /// @dev Reverts for:
    ///      - NonexistentAVSMetadata: The AVS metadata is not registered
    ///      - InvalidOperatorSet: The operatorSet already exists
    ///      - InputAddressZero: The slasher is the zero address
    function createOperatorSets(
        address avs,
        CreateSetParamsV2[] calldata params
    ) external;

    /// @notice Allows an AVS to create new Redistribution operator sets.
    /// @param avs The AVS creating the new operator sets.
    /// @param params An array of operator set creation parameters.
    /// @param redistributionRecipients An array of addresses that will receive redistributed funds when operators are slashed.
    /// @dev Same logic as `createOperatorSets`, except `redistributionRecipients` corresponding to each operator set are stored.
    ///      Additionally, emits `RedistributionOperatorSetCreated` event instead of `OperatorSetCreated` for each created operator set.
    /// @dev The address that can slash the operatorSet is the `avs` address. If you would like to use a different address,
    ///      use the `createOperatorSets` method which takes in `CreateSetParamsV2` instead.
    /// @dev THIS FUNCTION WILL BE DEPRECATED IN EARLY Q2 2026 IN FAVOR OF `createRedistributingOperatorSets` WHICH TAKES IN `CreateSetParamsV2`
    /// @dev Reverts for:
    ///      - InputArrayLengthMismatch: The length of the params array does not match the length of the redistributionRecipients array
    ///      - NonexistentAVSMetadata: The AVS metadata is not registered
    ///      - InputAddressZero: The redistribution recipient is the zero address
    ///      - InvalidRedistributionRecipient: The redistribution recipient is the zero address or the default burn address
    ///      - InvalidOperatorSet: The operatorSet already exists
    ///      - InvalidStrategy: The strategy is the BEACONCHAIN_ETH_STRAT or the EIGEN strategy
    ///      - InputAddressZero: The slasher is the zero address
    function createRedistributingOperatorSets(
        address avs,
        CreateSetParams[] calldata params,
        address[] calldata redistributionRecipients
    ) external;

    /// @notice Allows an AVS to create new Redistribution operator sets.
    /// @param avs The AVS creating the new operator sets.
    /// @param params An array of operator set creation parameters.
    /// @param redistributionRecipients An array of addresses that will receive redistributed funds when operators are slashed.
    /// @dev Same logic as `createOperatorSets`, except `redistributionRecipients` corresponding to each operator set are stored.
    ///      Additionally, emits `RedistributionOperatorSetCreated` event instead of `OperatorSetCreated` for each created operator set.
    /// @dev Reverts for:
    ///      - InputArrayLengthMismatch: The length of the params array does not match the length of the redistributionRecipients array
    ///      - NonexistentAVSMetadata: The AVS metadata is not registered
    ///      - InputAddressZero: The redistribution recipient is the zero address
    ///      - InvalidRedistributionRecipient: The redistribution recipient is the zero address or the default burn address
    ///      - InvalidOperatorSet: The operatorSet already exists
    ///      - InvalidStrategy: The strategy is the BEACONCHAIN_ETH_STRAT or the EIGEN strategy
    ///      - InputAddressZero: The slasher is the zero address
    function createRedistributingOperatorSets(
        address avs,
        CreateSetParamsV2[] calldata params,
        address[] calldata redistributionRecipients
    ) external;

    /// @notice Allows an AVS to add strategies to an operator set
    /// @dev Strategies MUST NOT already exist in the operator set
    /// @dev If the operatorSet is redistributing, the `BEACONCHAIN_ETH_STRAT` may not be added, since redistribution is not supported for native eth
    /// @param avs the avs to set strategies for
    /// @param operatorSetId the operator set to add strategies to
    /// @param strategies the strategies to add
    function addStrategiesToOperatorSet(
        address avs,
        uint32 operatorSetId,
        IStrategy[] calldata strategies
    ) external;

    /// @notice Allows an AVS to remove strategies from an operator set
    /// @dev Strategies MUST already exist in the operator set
    /// @param avs the avs to remove strategies for
    /// @param operatorSetId the operator set to remove strategies from
    /// @param strategies the strategies to remove
    function removeStrategiesFromOperatorSet(
        address avs,
        uint32 operatorSetId,
        IStrategy[] calldata strategies
    ) external;

    /// @notice Allows an AVS to update the slasher for an operator set
    /// @param operatorSet the operator set to update the slasher for
    /// @param slasher the new slasher
    /// @dev The new slasher will take effect after `SLASHER_CONFIGURATION_DELAY` blocks.
    /// @dev No-op if the proposed slasher is already pending and hasn't taken effect yet (delay countdown is not restarted).
    /// @dev The slasher can only be updated if it has already been set. The slasher is set either on operatorSet creation or,
    ///      for operatorSets created prior to v1.9.0, via `migrateSlashers`
    /// @dev Reverts for:
    ///      - InvalidCaller: The caller cannot update the slasher for the operator set (set via the `PermissionController`)
    ///      - InvalidOperatorSet: The operator set does not exist
    ///      - SlasherNotSet: The slasher has not been set yet
    ///      - InputAddressZero: The slasher is the zero address
    function updateSlasher(
        OperatorSet memory operatorSet,
        address slasher
    ) external;

    /// @notice Allows any address to migrate the slasher from the permission controller to the ALM
    /// @param operatorSets the list of operator sets to migrate the slasher for
    /// @dev This function is used to migrate the slasher from the permission controller to the ALM for operatorSets created prior to `v1.9.0`
    /// @dev Migrates based on the following rules:
    ///      - If there is no slasher set or the slasher in the `PermissionController`is the 0 address, the AVS address will be set as the slasher
    ///      - If there are multiple slashers set in the `PermissionController`, the first address will be set as the slasher
    /// @dev A migration can only be completed once for a given operatorSet
    /// @dev This function will be deprecated in Early Q2 2026. EigenLabs will migrate the slasher for all operatorSets created prior to `v1.9.0`
    /// @dev This function does not revert to allow for simpler offchain calling. It will no-op if:
    ///      - The operator set does not exist
    ///      - The slasher has already been set, either via migration or creation of the operatorSet
    /// @dev WARNING: Gas cost is O(appointees) per operator set due to `PermissionController.getAppointees()` call.
    ///      May exceed block gas limit for AVSs with large appointee sets. Consider batching operator sets if needed.
    function migrateSlashers(
        OperatorSet[] memory operatorSets
    ) external;
}

interface IAllocationManagerView is IAllocationManagerErrors, IAllocationManagerEvents, IAllocationManagerStorage {
    ///
    ///                         VIEW FUNCTIONS
    ///
    /// @notice Returns the number of operator sets for the AVS
    /// @param avs the AVS to query
    function getOperatorSetCount(
        address avs
    ) external view returns (uint256);

    /// @notice Returns the list of operator sets the operator has current or pending allocations/deallocations in
    /// @param operator the operator to query
    /// @return the list of operator sets the operator has current or pending allocations/deallocations in
    function getAllocatedSets(
        address operator
    ) external view returns (OperatorSet[] memory);

    /// @notice Returns the list of strategies an operator has current or pending allocations/deallocations from
    /// given a specific operator set.
    /// @param operator the operator to query
    /// @param operatorSet the operator set to query
    /// @return the list of strategies
    function getAllocatedStrategies(
        address operator,
        OperatorSet memory operatorSet
    ) external view returns (IStrategy[] memory);

    /// @notice Returns the current/pending stake allocation an operator has from a strategy to an operator set
    /// @param operator the operator to query
    /// @param operatorSet the operator set to query
    /// @param strategy the strategy to query
    /// @return the current/pending stake allocation
    function getAllocation(
        address operator,
        OperatorSet memory operatorSet,
        IStrategy strategy
    ) external view returns (Allocation memory);

    /// @notice Returns the current/pending stake allocations for multiple operators from a strategy to an operator set
    /// @param operators the operators to query
    /// @param operatorSet the operator set to query
    /// @param strategy the strategy to query
    /// @return each operator's allocation
    function getAllocations(
        address[] memory operators,
        OperatorSet memory operatorSet,
        IStrategy strategy
    ) external view returns (Allocation[] memory);

    /// @notice Given a strategy, returns a list of operator sets and corresponding stake allocations.
    /// @dev Note that this returns a list of ALL operator sets the operator has allocations in. This means
    /// some of the returned allocations may be zero.
    /// @param operator the operator to query
    /// @param strategy the strategy to query
    /// @return the list of all operator sets the operator has allocations for
    /// @return the corresponding list of allocations from the specific `strategy`
    function getStrategyAllocations(
        address operator,
        IStrategy strategy
    ) external view returns (OperatorSet[] memory, Allocation[] memory);

    /// @notice For a strategy, get the amount of magnitude that is allocated across one or more operator sets
    /// @param operator the operator to query
    /// @param strategy the strategy to get allocatable magnitude for
    /// @return currently allocated magnitude
    function getEncumberedMagnitude(
        address operator,
        IStrategy strategy
    ) external view returns (uint64);

    /// @notice For a strategy, get the amount of magnitude not currently allocated to any operator set
    /// @param operator the operator to query
    /// @param strategy the strategy to get allocatable magnitude for
    /// @return magnitude available to be allocated to an operator set
    function getAllocatableMagnitude(
        address operator,
        IStrategy strategy
    ) external view returns (uint64);

    /// @notice Returns the maximum magnitude an operator can allocate for the given strategy
    /// @dev The max magnitude of an operator starts at WAD (1e18), and is decreased anytime
    /// the operator is slashed. This value acts as a cap on the max magnitude of the operator.
    /// @param operator the operator to query
    /// @param strategy the strategy to get the max magnitude for
    /// @return the max magnitude for the strategy
    function getMaxMagnitude(
        address operator,
        IStrategy strategy
    ) external view returns (uint64);

    /// @notice Returns the maximum magnitude an operator can allocate for the given strategies
    /// @dev The max magnitude of an operator starts at WAD (1e18), and is decreased anytime
    /// the operator is slashed. This value acts as a cap on the max magnitude of the operator.
    /// @param operator the operator to query
    /// @param strategies the strategies to get the max magnitudes for
    /// @return the max magnitudes for each strategy
    function getMaxMagnitudes(
        address operator,
        IStrategy[] calldata strategies
    ) external view returns (uint64[] memory);

    /// @notice Returns the maximum magnitudes each operator can allocate for the given strategy
    /// @dev The max magnitude of an operator starts at WAD (1e18), and is decreased anytime
    /// the operator is slashed. This value acts as a cap on the max magnitude of the operator.
    /// @param operators the operators to query
    /// @param strategy the strategy to get the max magnitudes for
    /// @return the max magnitudes for each operator
    function getMaxMagnitudes(
        address[] calldata operators,
        IStrategy strategy
    ) external view returns (uint64[] memory);

    /// @notice Returns the maximum magnitude an operator can allocate for the given strategies
    /// at a given block number
    /// @dev The max magnitude of an operator starts at WAD (1e18), and is decreased anytime
    /// the operator is slashed. This value acts as a cap on the max magnitude of the operator.
    /// @param operator the operator to query
    /// @param strategies the strategies to get the max magnitudes for
    /// @param blockNumber the blockNumber at which to check the max magnitudes
    /// @return the max magnitudes for each strategy
    function getMaxMagnitudesAtBlock(
        address operator,
        IStrategy[] calldata strategies,
        uint32 blockNumber
    ) external view returns (uint64[] memory);

    /// @notice Returns the time in blocks between an operator allocating slashable magnitude
    /// and the magnitude becoming slashable. If the delay has not been set, `isSet` will be false.
    /// @dev The operator must have a configured delay before allocating magnitude
    /// @param operator The operator to query
    /// @return isSet Whether the operator has configured a delay
    /// @return delay The time in blocks between allocating magnitude and magnitude becoming slashable
    function getAllocationDelay(
        address operator
    ) external view returns (bool isSet, uint32 delay);

    /// @notice Returns a list of all operator sets the operator is registered for
    /// @param operator The operator address to query.
    function getRegisteredSets(
        address operator
    ) external view returns (OperatorSet[] memory operatorSets);

    /// @notice Returns whether the operator is registered for the operator set
    /// @param operator The operator to query
    /// @param operatorSet The operator set to query
    function isMemberOfOperatorSet(
        address operator,
        OperatorSet memory operatorSet
    ) external view returns (bool);

    /// @notice Returns whether the operator set exists
    function isOperatorSet(
        OperatorSet memory operatorSet
    ) external view returns (bool);

    /// @notice Returns all the operators registered to an operator set
    /// @param operatorSet The operatorSet to query.
    function getMembers(
        OperatorSet memory operatorSet
    ) external view returns (address[] memory operators);

    /// @notice Returns the number of operators registered to an operatorSet.
    /// @param operatorSet The operatorSet to get the member count for
    function getMemberCount(
        OperatorSet memory operatorSet
    ) external view returns (uint256);

    /// @notice Returns the address that handles registration/deregistration for the AVS
    /// If not set, defaults to the input address (`avs`)
    function getAVSRegistrar(
        address avs
    ) external view returns (IAVSRegistrar);

    /// @notice Returns an array of strategies in the operatorSet.
    /// @param operatorSet The operatorSet to query.
    function getStrategiesInOperatorSet(
        OperatorSet memory operatorSet
    ) external view returns (IStrategy[] memory strategies);

    /// @notice Returns the minimum amount of stake that will be slashable as of some future block,
    /// according to each operator's allocation from each strategy to the operator set. Note that this function
    /// will return 0 for the slashable stake if the operator is not slashable at the time of the call.
    /// @dev This method queries actual delegated stakes in the DelegationManager and applies
    /// each operator's allocation to the stake to produce the slashable stake each allocation
    /// represents. This method does not consider slashable stake in the withdrawal queue even though there could be
    /// slashable stake in the queue.
    /// @dev This minimum takes into account `futureBlock`, and will omit any pending magnitude
    /// diffs that will not be in effect as of `futureBlock`. NOTE that in order to get the true
    /// minimum slashable stake as of some future block, `futureBlock` MUST be greater than block.number
    /// @dev NOTE that `futureBlock` should be fewer than `DEALLOCATION_DELAY` blocks in the future,
    /// or the values returned from this method may not be accurate due to deallocations.
    /// @param operatorSet the operator set to query
    /// @param operators the list of operators whose slashable stakes will be returned
    /// @param strategies the strategies that each slashable stake corresponds to
    /// @param futureBlock the block at which to get allocation information. Should be a future block.
    function getMinimumSlashableStake(
        OperatorSet memory operatorSet,
        address[] memory operators,
        IStrategy[] memory strategies,
        uint32 futureBlock
    ) external view returns (uint256[][] memory slashableStake);

    /// @notice Returns the current allocated stake, irrespective of the operator's slashable status for the operatorSet.
    /// @param operatorSet the operator set to query
    /// @param operators the operators to query
    /// @param strategies the strategies to query
    function getAllocatedStake(
        OperatorSet memory operatorSet,
        address[] memory operators,
        IStrategy[] memory strategies
    ) external view returns (uint256[][] memory slashableStake);

    /// @notice Returns whether an operator is slashable by an operator set.
    /// This returns true if the operator is registered or their slashableUntil block has not passed.
    /// This is because even when operators are deregistered, they still remain slashable for a period of time.
    /// @param operator the operator to check slashability for
    /// @param operatorSet the operator set to check slashability for
    function isOperatorSlashable(
        address operator,
        OperatorSet memory operatorSet
    ) external view returns (bool);

    /// @notice Returns the address that can slash a given operator set.
    /// @param operatorSet The operator set to query.
    /// @return The address that can slash the operator set. Returns `address(0)` if the operator set doesn't exist.
    /// @dev If there is a pending slasher that can be applied after the `effectBlock`, the pending slasher will be returned.
    function getSlasher(
        OperatorSet memory operatorSet
    ) external view returns (address);

    /// @notice Returns pending slasher for a given operator set.
    /// @param operatorSet The operator set to query.
    /// @return pendingSlasher The pending slasher for the operator set. Returns `address(0)` if there is no pending slasher or the operator set doesn't exist.
    /// @return effectBlock The block at which the pending slasher will take effect. Returns `0` if there is no pending slasher or the operator set doesn't exist.
    function getPendingSlasher(
        OperatorSet memory operatorSet
    ) external view returns (address pendingSlasher, uint32 effectBlock);

    /// @notice Returns the address where slashed funds will be sent for a given operator set.
    /// @param operatorSet The Operator Set to query.
    /// @return For redistributing Operator Sets, returns the configured redistribution address set during Operator Set creation.
    ///         For non-redistributing operator sets, returns the `DEFAULT_BURN_ADDRESS`.
    function getRedistributionRecipient(
        OperatorSet memory operatorSet
    ) external view returns (address);

    /// @notice Returns whether a given operator set supports redistribution
    /// or not when funds are slashed and burned from EigenLayer.
    /// @param operatorSet The Operator Set to query.
    /// @return For redistributing Operator Sets, returns true.
    ///         For non-redistributing Operator Sets, returns false.
    function isRedistributingOperatorSet(
        OperatorSet memory operatorSet
    ) external view returns (bool);

    /// @notice Returns the number of slashes for a given operator set.
    /// @param operatorSet The operator set to query.
    /// @return The number of slashes for the operator set.
    function getSlashCount(
        OperatorSet memory operatorSet
    ) external view returns (uint256);

    /// @notice Returns whether an operator is slashable by a redistributing operator set.
    /// @param operator The operator to query.
    function isOperatorRedistributable(
        address operator
    ) external view returns (bool);
}

interface IAllocationManager is IAllocationManagerActions, IAllocationManagerView, IPausable {}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity >=0.5.0;

import "./IStrategy.sol";
import "./IPauserRegistry.sol";
import "./ISignatureUtilsMixin.sol";
import "../libraries/SlashingLib.sol";
import "../libraries/OperatorSetLib.sol";

interface IDelegationManagerErrors {
    /// @dev Thrown when caller is neither the StrategyManager or EigenPodManager contract.
    error OnlyStrategyManagerOrEigenPodManager();
    /// @dev Thrown when msg.sender is not the EigenPodManager
    error OnlyEigenPodManager();
    /// @dev Throw when msg.sender is not the AllocationManager
    error OnlyAllocationManager();

    /// Delegation Status

    /// @dev Thrown when an operator attempts to undelegate.
    error OperatorsCannotUndelegate();
    /// @dev Thrown when an account is actively delegated.
    error ActivelyDelegated();
    /// @dev Thrown when an account is not actively delegated.
    error NotActivelyDelegated();
    /// @dev Thrown when `operator` is not a registered operator.
    error OperatorNotRegistered();

    /// Invalid Inputs

    /// @dev Thrown when attempting to execute an action that was not queued.
    error WithdrawalNotQueued();
    /// @dev Thrown when caller cannot undelegate on behalf of a staker.
    error CallerCannotUndelegate();
    /// @dev Thrown when two array parameters have mismatching lengths.
    error InputArrayLengthMismatch();
    /// @dev Thrown when input arrays length is zero.
    error InputArrayLengthZero();

    /// Slashing

    /// @dev Thrown when an operator has been fully slashed(maxMagnitude is 0) for a strategy.
    /// or if the staker has had been natively slashed to the point of their beaconChainScalingFactor equalling 0.
    error FullySlashed();

    /// Signatures

    /// @dev Thrown when attempting to spend a spent eip-712 salt.
    error SaltSpent();

    /// Withdrawal Processing

    /// @dev Thrown when attempting to withdraw before delay has elapsed.
    error WithdrawalDelayNotElapsed();
    /// @dev Thrown when withdrawer is not the current caller.
    error WithdrawerNotCaller();
}

interface IDelegationManagerTypes {
    // @notice Struct used for storing information about a single operator who has registered with EigenLayer
    struct OperatorDetails {
        /// @notice DEPRECATED -- this field is no longer used, payments are handled in RewardsCoordinator.sol
        address __deprecated_earningsReceiver;
        /// @notice Address to verify signatures when a staker wishes to delegate to the operator, as well as controlling "forced undelegations".
        /// @dev Signature verification follows these rules:
        /// 1) If this address is left as address(0), then any staker will be free to delegate to the operator, i.e. no signature verification will be performed.
        /// 2) If this address is an EOA (i.e. it has no code), then we follow standard ECDSA signature verification for delegations to the operator.
        /// 3) If this address is a contract (i.e. it has code) then we forward a call to the contract and verify that it returns the correct EIP-1271 "magic value".
        address delegationApprover;
        /// @notice DEPRECATED -- this field is no longer used. An analogous field is the `allocationDelay` stored in the AllocationManager
        uint32 __deprecated_stakerOptOutWindowBlocks;
    }

    /// @notice Abstract struct used in calculating an EIP712 signature for an operator's delegationApprover to approve that a specific staker delegate to the operator.
    /// @dev Used in computing the `DELEGATION_APPROVAL_TYPEHASH` and as a reference in the computation of the approverDigestHash in the `_delegate` function.
    struct DelegationApproval {
        // the staker who is delegating
        address staker;
        // the operator being delegated to
        address operator;
        // the operator's provided salt
        bytes32 salt;
        // the expiration timestamp (UTC) of the signature
        uint256 expiry;
    }

    /// @dev A struct representing an existing queued withdrawal. After the withdrawal delay has elapsed, this withdrawal can be completed via `completeQueuedWithdrawal`.
    /// A `Withdrawal` is created by the `DelegationManager` when `queueWithdrawals` is called. The `withdrawalRoots` hashes returned by `queueWithdrawals` can be used
    /// to fetch the corresponding `Withdrawal` from storage (via `getQueuedWithdrawal`).
    ///
    /// @param staker The address that queued the withdrawal
    /// @param delegatedTo The address that the staker was delegated to at the time the withdrawal was queued. Used to determine if additional slashing occurred before
    /// this withdrawal became completable.
    /// @param withdrawer The address that will call the contract to complete the withdrawal. Note that this will always equal `staker`; alternate withdrawers are not
    /// supported at this time.
    /// @param nonce The staker's `cumulativeWithdrawalsQueued` at time of queuing. Used to ensure withdrawals have unique hashes.
    /// @param startBlock The block number when the withdrawal was queued.
    /// @param strategies The strategies requested for withdrawal when the withdrawal was queued
    /// @param scaledShares The staker's deposit shares requested for withdrawal, scaled by the staker's `depositScalingFactor`. Upon completion, these will be
    /// scaled by the appropriate slashing factor as of the withdrawal's completable block. The result is what is actually withdrawable.
    struct Withdrawal {
        address staker;
        address delegatedTo;
        address withdrawer;
        uint256 nonce;
        uint32 startBlock;
        IStrategy[] strategies;
        uint256[] scaledShares;
    }

    /// @param strategies The strategies to withdraw from
    /// @param depositShares For each strategy, the number of deposit shares to withdraw. Deposit shares can
    /// be queried via `getDepositedShares`.
    /// NOTE: The number of shares ultimately received when a withdrawal is completed may be lower depositShares
    /// if the staker or their delegated operator has experienced slashing.
    /// @param __deprecated_withdrawer This field is ignored. The only party that may complete a withdrawal
    /// is the staker that originally queued it. Alternate withdrawers are not supported.
    struct QueuedWithdrawalParams {
        IStrategy[] strategies;
        uint256[] depositShares;
        address __deprecated_withdrawer;
    }
}

interface IDelegationManagerEvents is IDelegationManagerTypes {
    // @notice Emitted when a new operator registers in EigenLayer and provides their delegation approver.
    event OperatorRegistered(address indexed operator, address delegationApprover);

    /// @notice Emitted when an operator updates their delegation approver
    event DelegationApproverUpdated(address indexed operator, address newDelegationApprover);

    /// @notice Emitted when @param operator indicates that they are updating their MetadataURI string
    /// @dev Note that these strings are *never stored in storage* and are instead purely emitted in events for off-chain indexing
    event OperatorMetadataURIUpdated(address indexed operator, string metadataURI);

    /// @notice Emitted whenever an operator's shares are increased for a given strategy. Note that shares is the delta in the operator's shares.
    event OperatorSharesIncreased(address indexed operator, address staker, IStrategy strategy, uint256 shares);

    /// @notice Emitted whenever an operator's shares are decreased for a given strategy. Note that shares is the delta in the operator's shares.
    event OperatorSharesDecreased(address indexed operator, address staker, IStrategy strategy, uint256 shares);

    /// @notice Emitted when @param staker delegates to @param operator.
    event StakerDelegated(address indexed staker, address indexed operator);

    /// @notice Emitted when @param staker undelegates from @param operator.
    event StakerUndelegated(address indexed staker, address indexed operator);

    /// @notice Emitted when @param staker is undelegated via a call not originating from the staker themself
    event StakerForceUndelegated(address indexed staker, address indexed operator);

    /// @notice Emitted when a staker's depositScalingFactor is updated
    event DepositScalingFactorUpdated(address staker, IStrategy strategy, uint256 newDepositScalingFactor);

    /// @notice Emitted when a new withdrawal is queued.
    /// @param withdrawalRoot Is the hash of the `withdrawal`.
    /// @param withdrawal Is the withdrawal itself.
    /// @param sharesToWithdraw Is an array of the expected shares that were queued for withdrawal corresponding to the strategies in the `withdrawal`.
    event SlashingWithdrawalQueued(bytes32 withdrawalRoot, Withdrawal withdrawal, uint256[] sharesToWithdraw);

    /// @notice Emitted when a queued withdrawal is completed
    event SlashingWithdrawalCompleted(bytes32 withdrawalRoot);

    /// @notice Emitted whenever an operator's shares are slashed for a given strategy
    event OperatorSharesSlashed(address indexed operator, IStrategy strategy, uint256 totalSlashedShares);
}

/// @title DelegationManager
/// @author Layr Labs, Inc.
/// @notice Terms of Service: https://docs.eigenlayer.xyz/overview/terms-of-service
/// @notice  This is the contract for delegation in EigenLayer. The main functionalities of this contract are
/// - enabling anyone to register as an operator in EigenLayer
/// - allowing operators to specify parameters related to stakers who delegate to them
/// - enabling any staker to delegate its stake to the operator of its choice (a given staker can only delegate to a single operator at a time)
/// - enabling a staker to undelegate its assets from the operator it is delegated to (performed as part of the withdrawal process, initiated through the StrategyManager)
interface IDelegationManager is ISignatureUtilsMixin, IDelegationManagerErrors, IDelegationManagerEvents {
    /// @dev Initializes the initial owner and paused status.
    function initialize(
        uint256 initialPausedStatus
    ) external;

    /// @notice Registers the caller as an operator in EigenLayer.
    /// @param initDelegationApprover is an address that, if set, must provide a signature when stakers delegate
    /// to an operator.
    /// @param allocationDelay The delay before allocations take effect.
    /// @param metadataURI is a URI for the operator's metadata, i.e. a link providing more details on the operator.
    ///
    /// @dev Once an operator is registered, they cannot 'deregister' as an operator, and they will forever be considered "delegated to themself".
    /// @dev This function will revert if the caller is already delegated to an operator.
    /// @dev Note that the `metadataURI` is *never stored * and is only emitted in the `OperatorMetadataURIUpdated` event
    function registerAsOperator(
        address initDelegationApprover,
        uint32 allocationDelay,
        string calldata metadataURI
    ) external;

    /// @notice Updates an operator's stored `delegationApprover`.
    /// @param operator is the operator to update the delegationApprover for
    /// @param newDelegationApprover is the new delegationApprover for the operator
    ///
    /// @dev The caller must have previously registered as an operator in EigenLayer.
    function modifyOperatorDetails(
        address operator,
        address newDelegationApprover
    ) external;

    /// @notice Called by an operator to emit an `OperatorMetadataURIUpdated` event indicating the information has updated.
    /// @param operator The operator to update metadata for
    /// @param metadataURI The URI for metadata associated with an operator
    /// @dev Note that the `metadataURI` is *never stored * and is only emitted in the `OperatorMetadataURIUpdated` event
    function updateOperatorMetadataURI(
        address operator,
        string calldata metadataURI
    ) external;

    /// @notice Caller delegates their stake to an operator.
    /// @param operator The account (`msg.sender`) is delegating its assets to for use in serving applications built on EigenLayer.
    /// @param approverSignatureAndExpiry (optional) Verifies the operator approves of this delegation
    /// @param approverSalt (optional) A unique single use value tied to an individual signature.
    /// @dev The signature/salt are used ONLY if the operator has configured a delegationApprover.
    /// If they have not, these params can be left empty.
    function delegateTo(
        address operator,
        SignatureWithExpiry memory approverSignatureAndExpiry,
        bytes32 approverSalt
    ) external;

    /// @notice Undelegates the staker from their operator and queues a withdrawal for all of their shares
    /// @param staker The account to be undelegated
    /// @return withdrawalRoots The roots of the newly queued withdrawals, if a withdrawal was queued. Returns
    /// an empty array if none was queued.
    ///
    /// @dev Reverts if the `staker` is also an operator, since operators are not allowed to undelegate from themselves.
    /// @dev Reverts if the caller is not the staker, nor the operator who the staker is delegated to, nor the operator's specified "delegationApprover"
    /// @dev Reverts if the `staker` is not delegated to an operator
    function undelegate(
        address staker
    ) external returns (bytes32[] memory withdrawalRoots);

    /// @notice Undelegates the staker from their current operator, and redelegates to `newOperator`
    /// Queues a withdrawal for all of the staker's withdrawable shares. These shares will only be
    /// delegated to `newOperator` AFTER the withdrawal is completed.
    /// @dev This method acts like a call to `undelegate`, then `delegateTo`
    /// @param newOperator the new operator that will be delegated all assets
    /// @dev NOTE: the following 2 params are ONLY checked if `newOperator` has a `delegationApprover`.
    /// If not, they can be left empty.
    /// @param newOperatorApproverSig A signature from the operator's `delegationApprover`
    /// @param approverSalt A unique single use value tied to the approver's signature
    function redelegate(
        address newOperator,
        SignatureWithExpiry memory newOperatorApproverSig,
        bytes32 approverSalt
    ) external returns (bytes32[] memory withdrawalRoots);

    /// @notice Allows a staker to queue a withdrawal of their deposit shares. The withdrawal can be
    /// completed after the MIN_WITHDRAWAL_DELAY_BLOCKS via either of the completeQueuedWithdrawal methods.
    ///
    /// While in the queue, these shares are removed from the staker's balance, as well as from their operator's
    /// delegated share balance (if applicable). Note that while in the queue, deposit shares are still subject
    /// to slashing. If any slashing has occurred, the shares received may be less than the queued deposit shares.
    ///
    /// @dev To view all the staker's strategies/deposit shares that can be queued for withdrawal, see `getDepositedShares`
    /// @dev To view the current conversion between a staker's deposit shares and withdrawable shares, see `getWithdrawableShares`
    function queueWithdrawals(
        QueuedWithdrawalParams[] calldata params
    ) external returns (bytes32[] memory);

    /// @notice Used to complete a queued withdrawal
    /// @param withdrawal The withdrawal to complete
    /// @param tokens Array in which the i-th entry specifies the `token` input to the 'withdraw' function of the i-th Strategy in the `withdrawal.strategies` array.
    /// @param tokens For each `withdrawal.strategies`, the underlying token of the strategy
    /// NOTE: if `receiveAsTokens` is false, the `tokens` array is unused and can be filled with default values. However, `tokens.length` MUST still be equal to `withdrawal.strategies.length`.
    /// NOTE: For the `beaconChainETHStrategy`, the corresponding `tokens` value is ignored (can be 0).
    /// @param receiveAsTokens If true, withdrawn shares will be converted to tokens and sent to the caller. If false, the caller receives shares that can be delegated to an operator.
    /// NOTE: if the caller receives shares and is currently delegated to an operator, the received shares are
    /// automatically delegated to the caller's current operator.
    function completeQueuedWithdrawal(
        Withdrawal calldata withdrawal,
        IERC20[] calldata tokens,
        bool receiveAsTokens
    ) external;

    /// @notice Used to complete multiple queued withdrawals
    /// @param withdrawals Array of Withdrawals to complete. See `completeQueuedWithdrawal` for the usage of a single Withdrawal.
    /// @param tokens Array of tokens for each Withdrawal. See `completeQueuedWithdrawal` for the usage of a single array.
    /// @param receiveAsTokens Whether or not to complete each withdrawal as tokens. See `completeQueuedWithdrawal` for the usage of a single boolean.
    /// @dev See `completeQueuedWithdrawal` for relevant dev tags
    function completeQueuedWithdrawals(
        Withdrawal[] calldata withdrawals,
        IERC20[][] calldata tokens,
        bool[] calldata receiveAsTokens
    ) external;

    /// @notice Called by a share manager when a staker's deposit share balance in a strategy increases.
    /// This method delegates any new shares to an operator (if applicable), and updates the staker's
    /// deposit scaling factor regardless.
    /// @param staker The address whose deposit shares have increased
    /// @param strategy The strategy in which shares have been deposited
    /// @param prevDepositShares The number of deposit shares the staker had in the strategy prior to the increase
    /// @param addedShares The number of deposit shares added by the staker
    ///
    /// @dev Note that if the either the staker's current operator has been slashed 100% for `strategy`, OR the
    /// staker has been slashed 100% on the beacon chain such that the calculated slashing factor is 0, this
    /// method WILL REVERT.
    function increaseDelegatedShares(
        address staker,
        IStrategy strategy,
        uint256 prevDepositShares,
        uint256 addedShares
    ) external;

    /// @notice If the staker is delegated, decreases its operator's shares in response to
    /// a decrease in balance in the beaconChainETHStrategy
    /// @param staker the staker whose operator's balance will be decreased
    /// @param curDepositShares the current deposit shares held by the staker
    /// @param beaconChainSlashingFactorDecrease the amount that the staker's beaconChainSlashingFactor has decreased by
    /// @dev Note: `beaconChainSlashingFactorDecrease` are assumed to ALWAYS be < 1 WAD.
    /// These invariants are maintained in the EigenPodManager.
    function decreaseDelegatedShares(
        address staker,
        uint256 curDepositShares,
        uint64 beaconChainSlashingFactorDecrease
    ) external;

    /// @notice Decreases the operator's shares in storage after a slash and increases the burnable shares by calling
    /// into either the StrategyManager or EigenPodManager (if the strategy is beaconChainETH).
    /// @param operator The operator to decrease shares for.
    /// @param operatorSet The operator set to decrease shares for.
    /// @param slashId The slash id to decrease shares for.
    /// @param strategy The strategy to decrease shares for.
    /// @param prevMaxMagnitude The previous maxMagnitude of the operator.
    /// @param newMaxMagnitude The new maxMagnitude of the operator.
    /// @dev Callable only by the AllocationManager.
    /// @dev Note: Assumes `prevMaxMagnitude <= newMaxMagnitude`. This invariant is maintained in
    /// the AllocationManager.
    /// @return totalDepositSharesToSlash The total deposit shares to burn or redistribute.
    function slashOperatorShares(
        address operator,
        OperatorSet calldata operatorSet,
        uint256 slashId,
        IStrategy strategy,
        uint64 prevMaxMagnitude,
        uint64 newMaxMagnitude
    ) external returns (uint256 totalDepositSharesToSlash);

    ///
    ///                         VIEW FUNCTIONS
    ///

    /// @notice returns the address of the operator that `staker` is delegated to.
    /// @notice Mapping: staker => operator whom the staker is currently delegated to.
    /// @dev Note that returning address(0) indicates that the staker is not actively delegated to any operator.
    function delegatedTo(
        address staker
    ) external view returns (address);

    /// @notice Mapping: delegationApprover => 32-byte salt => whether or not the salt has already been used by the delegationApprover.
    /// @dev Salts are used in the `delegateTo` function. Note that this function only processes the delegationApprover's
    /// signature + the provided salt if the operator being delegated to has specified a nonzero address as their `delegationApprover`.
    function delegationApproverSaltIsSpent(
        address _delegationApprover,
        bytes32 salt
    ) external view returns (bool);

    /// @notice Mapping: staker => cumulative number of queued withdrawals they have ever initiated.
    /// @dev This only increments (doesn't decrement), and is used to help ensure that otherwise identical withdrawals have unique hashes.
    function cumulativeWithdrawalsQueued(
        address staker
    ) external view returns (uint256);

    /// @notice Returns 'true' if `staker` *is* actively delegated, and 'false' otherwise.
    function isDelegated(
        address staker
    ) external view returns (bool);

    /// @notice Returns true is an operator has previously registered for delegation.
    function isOperator(
        address operator
    ) external view returns (bool);

    /// @notice Returns the delegationApprover account for an operator
    function delegationApprover(
        address operator
    ) external view returns (address);

    /// @notice Returns the shares that an operator has delegated to them in a set of strategies
    /// @param operator the operator to get shares for
    /// @param strategies the strategies to get shares for
    function getOperatorShares(
        address operator,
        IStrategy[] memory strategies
    ) external view returns (uint256[] memory);

    /// @notice Returns the shares that a set of operators have delegated to them in a set of strategies
    /// @param operators the operators to get shares for
    /// @param strategies the strategies to get shares for
    function getOperatorsShares(
        address[] memory operators,
        IStrategy[] memory strategies
    ) external view returns (uint256[][] memory);

    /// @notice Returns amount of withdrawable shares from an operator for a strategy that is still in the queue
    /// and therefore slashable.
    /// @param operator the operator to get shares for
    /// @param strategy the strategy to get shares for
    /// @return the amount of shares that are slashable in the withdrawal queue for an operator and a strategy
    /// @dev If multiple slashes occur to shares in the queue, the function properly accounts for the fewer
    ///      number of shares that are available to be slashed.
    function getSlashableSharesInQueue(
        address operator,
        IStrategy strategy
    ) external view returns (uint256);

    /// @notice Given a staker and a set of strategies, return the shares they can queue for withdrawal and the
    /// corresponding depositShares.
    /// This value depends on which operator the staker is delegated to.
    /// The shares amount returned is the actual amount of Strategy shares the staker would receive (subject
    /// to each strategy's underlying shares to token ratio).
    function getWithdrawableShares(
        address staker,
        IStrategy[] memory strategies
    ) external view returns (uint256[] memory withdrawableShares, uint256[] memory depositShares);

    /// @notice Returns the number of shares in storage for a staker and all their strategies
    function getDepositedShares(
        address staker
    ) external view returns (IStrategy[] memory, uint256[] memory);

    /// @notice Returns the scaling factor applied to a staker's deposits for a given strategy
    function depositScalingFactor(
        address staker,
        IStrategy strategy
    ) external view returns (uint256);

    /// @notice Returns the Withdrawal associated with a `withdrawalRoot`.
    /// @param withdrawalRoot The hash identifying the queued withdrawal.
    /// @return withdrawal The withdrawal details.
    function queuedWithdrawals(
        bytes32 withdrawalRoot
    ) external view returns (Withdrawal memory withdrawal);

    /// @notice Returns the Withdrawal and corresponding shares associated with a `withdrawalRoot`
    /// @param withdrawalRoot The hash identifying the queued withdrawal
    /// @return withdrawal The withdrawal details
    /// @return shares Array of shares corresponding to each strategy in the withdrawal
    /// @dev The shares are what a user would receive from completing a queued withdrawal, assuming all slashings are applied
    /// @dev Withdrawals queued before the slashing release cannot be queried with this method
    function getQueuedWithdrawal(
        bytes32 withdrawalRoot
    ) external view returns (Withdrawal memory withdrawal, uint256[] memory shares);

    /// @notice Returns all queued withdrawals and their corresponding shares for a staker.
    /// @param staker The address of the staker to query withdrawals for.
    /// @return withdrawals Array of Withdrawal structs containing details about each queued withdrawal.
    /// @return shares 2D array of shares, where each inner array corresponds to the strategies in the withdrawal.
    /// @dev The shares are what a user would receive from completing a queued withdrawal, assuming all slashings are applied.
    function getQueuedWithdrawals(
        address staker
    ) external view returns (Withdrawal[] memory withdrawals, uint256[][] memory shares);

    /// @notice Returns a list of queued withdrawal roots for the `staker`.
    /// NOTE that this only returns withdrawals queued AFTER the slashing release.
    function getQueuedWithdrawalRoots(
        address staker
    ) external view returns (bytes32[] memory);

    /// @notice Converts shares for a set of strategies to deposit shares, likely in order to input into `queueWithdrawals`.
    /// This function will revert from a division by 0 error if any of the staker's strategies have a slashing factor of 0.
    /// @param staker the staker to convert shares for
    /// @param strategies the strategies to convert shares for
    /// @param withdrawableShares the shares to convert
    /// @return the deposit shares
    /// @dev will be a few wei off due to rounding errors
    function convertToDepositShares(
        address staker,
        IStrategy[] memory strategies,
        uint256[] memory withdrawableShares
    ) external view returns (uint256[] memory);

    /// @notice Returns the keccak256 hash of `withdrawal`.
    function calculateWithdrawalRoot(
        Withdrawal memory withdrawal
    ) external pure returns (bytes32);

    /// @notice Calculates the digest hash to be signed by the operator's delegationApprove and used in the `delegateTo` function.
    /// @param staker The account delegating their stake
    /// @param operator The account receiving delegated stake
    /// @param _delegationApprover the operator's `delegationApprover` who will be signing the delegationHash (in general)
    /// @param approverSalt A unique and single use value associated with the approver signature.
    /// @param expiry Time after which the approver's signature becomes invalid
    function calculateDelegationApprovalDigestHash(
        address staker,
        address operator,
        address _delegationApprover,
        bytes32 approverSalt,
        uint256 expiry
    ) external view returns (bytes32);

    /// @notice return address of the beaconChainETHStrategy
    function beaconChainETHStrategy() external view returns (IStrategy);

    /// @notice Returns the minimum withdrawal delay in blocks to pass for withdrawals queued to be completable.
    /// Also applies to legacy withdrawals so any withdrawals not completed prior to the slashing upgrade will be subject
    /// to this longer delay.
    /// @dev Backwards-compatible interface to return the internal `MIN_WITHDRAWAL_DELAY_BLOCKS` value
    /// @dev Previous value in storage was deprecated. See `__deprecated_minWithdrawalDelayBlocks`
    function minWithdrawalDelayBlocks() external view returns (uint32);

    /// @notice The EIP-712 typehash for the DelegationApproval struct used by the contract
    function DELEGATION_APPROVAL_TYPEHASH() external view returns (bytes32);
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity >=0.5.0;

import "./IStrategy.sol";
import "./IShareManager.sol";
import "./IDelegationManager.sol";
import "./IEigenPodManager.sol";

interface IStrategyManagerErrors {
    /// @dev Thrown when total strategies deployed exceeds max.
    error MaxStrategiesExceeded();
    /// @dev Thrown when call attempted from address that's not delegation manager.
    error OnlyDelegationManager();
    /// @dev Thrown when call attempted from address that's not strategy whitelister.
    error OnlyStrategyWhitelister();
    /// @dev Thrown when provided `shares` amount is too high.
    error SharesAmountTooHigh();
    /// @dev Thrown when provided `shares` amount is zero.
    error SharesAmountZero();
    /// @dev Thrown when provided `staker` address is null.
    error StakerAddressZero();
    /// @dev Thrown when provided `strategy` not found.
    error StrategyNotFound();
    /// @dev Thrown when attempting to deposit to a non-whitelisted strategy.
    error StrategyNotWhitelisted();
    /// @dev Thrown when attempting to add a strategy that is already in the operator set's burn or redistributable shares.
    error StrategyAlreadyInSlash();
}

interface IStrategyManagerEvents {
    /// @notice Emitted when a new deposit occurs on behalf of `staker`.
    /// @param staker Is the staker who is depositing funds into EigenLayer.
    /// @param strategy Is the strategy that `staker` has deposited into.
    /// @param shares Is the number of new shares `staker` has been granted in `strategy`.
    event Deposit(address staker, IStrategy strategy, uint256 shares);

    /// @notice Emitted when the `strategyWhitelister` is changed
    event StrategyWhitelisterChanged(address previousAddress, address newAddress);

    /// @notice Emitted when a strategy is added to the approved list of strategies for deposit
    event StrategyAddedToDepositWhitelist(IStrategy strategy);

    /// @notice Emitted when a strategy is removed from the approved list of strategies for deposit
    event StrategyRemovedFromDepositWhitelist(IStrategy strategy);

    /// @notice Emitted when an operator is slashed and shares to be burned or redistributed are increased
    event BurnOrRedistributableSharesIncreased(
        OperatorSet operatorSet,
        uint256 slashId,
        IStrategy strategy,
        uint256 shares
    );

    /// @notice Emitted when shares marked for burning or redistribution are decreased and transferred to the operator set's redistribution recipient
    event BurnOrRedistributableSharesDecreased(
        OperatorSet operatorSet,
        uint256 slashId,
        IStrategy strategy,
        uint256 shares
    );

    /// @notice Emitted when shares are burnt
    /// @dev This event is only emitted in the pre-redistribution slash path
    event BurnableSharesDecreased(IStrategy strategy, uint256 shares);
}

/// @title Interface for the primary entrypoint for funds into EigenLayer.
/// @author Layr Labs, Inc.
/// @notice Terms of Service: https://docs.eigenlayer.xyz/overview/terms-of-service
/// @notice See the `StrategyManager` contract itself for implementation details.
interface IStrategyManager is IStrategyManagerErrors, IStrategyManagerEvents, IShareManager {
    /// @notice Initializes the strategy manager contract. Sets the `pauserRegistry` (currently **not** modifiable after being set),
    /// and transfers contract ownership to the specified `initialOwner`.
    /// @param initialOwner Ownership of this contract is transferred to this address.
    /// @param initialStrategyWhitelister The initial value of `strategyWhitelister` to set.
    /// @param initialPausedStatus The initial value of `_paused` to set.
    function initialize(
        address initialOwner,
        address initialStrategyWhitelister,
        uint256 initialPausedStatus
    ) external;

    /// @notice Deposits `amount` of `token` into the specified `strategy` and credits shares to the caller
    /// @param strategy the strategy that handles `token`
    /// @param token the token from which the `amount` will be transferred
    /// @param amount the number of tokens to deposit
    /// @return depositShares the number of deposit shares credited to the caller
    /// @dev The caller must have previously approved this contract to transfer at least `amount` of `token` on their behalf.
    ///
    /// WARNING: Be extremely cautious when depositing tokens that do not strictly adhere to ERC20 standards.
    /// Tokens that diverge significantly from ERC20 norms can cause unexpected behavior in token balances for
    /// that strategy, e.g. ERC-777 tokens allowing cross-contract reentrancy.
    function depositIntoStrategy(
        IStrategy strategy,
        IERC20 token,
        uint256 amount
    ) external returns (uint256 depositShares);

    /// @notice Deposits `amount` of `token` into the specified `strategy` and credits shares to the `staker`
    /// Note tokens are transferred from `msg.sender`, NOT from `staker`. This method allows the caller, using a
    /// signature, to deposit their tokens to another staker's balance.
    /// @param strategy the strategy that handles `token`
    /// @param token the token from which the `amount` will be transferred
    /// @param amount the number of tokens to transfer from the caller to the strategy
    /// @param staker the staker that the deposited assets will be credited to
    /// @param expiry the timestamp at which the signature expires
    /// @param signature a valid ECDSA or EIP-1271 signature from `staker`
    /// @return depositShares the number of deposit shares credited to `staker`
    /// @dev The caller must have previously approved this contract to transfer at least `amount` of `token` on their behalf.
    ///
    /// WARNING: Be extremely cautious when depositing tokens that do not strictly adhere to ERC20 standards.
    /// Tokens that diverge significantly from ERC20 norms can cause unexpected behavior in token balances for
    /// that strategy, e.g. ERC-777 tokens allowing cross-contract reentrancy.
    function depositIntoStrategyWithSignature(
        IStrategy strategy,
        IERC20 token,
        uint256 amount,
        address staker,
        uint256 expiry,
        bytes memory signature
    ) external returns (uint256 depositShares);

    /// @notice Legacy burn strategy shares for the given strategy by calling into the strategy to transfer
    /// to the default burn address.
    /// @param strategy The strategy to burn shares in.
    /// @dev This function will be DEPRECATED in a release after redistribution
    function burnShares(
        IStrategy strategy
    ) external;

    /// @notice Removes burned shares from storage and transfers the underlying tokens for the slashId to the redistribution recipient.
    /// @dev Reentrancy is checked in the `clearBurnOrRedistributableSharesByStrategy` function.
    /// @param operatorSet The operator set to burn shares in.
    /// @param slashId The slash ID to burn shares in.
    /// @return The amounts of tokens transferred to the redistribution recipient for each strategy
    function clearBurnOrRedistributableShares(
        OperatorSet calldata operatorSet,
        uint256 slashId
    ) external returns (uint256[] memory);

    /// @notice Removes a single strategy's shares from storage and transfers the underlying tokens for the slashId to the redistribution recipient.
    /// @param operatorSet The operator set to burn shares in.
    /// @param slashId The slash ID to burn shares in.
    /// @param strategy The strategy to burn shares in.
    /// @return The amount of tokens transferred to the redistribution recipient for the strategy.
    function clearBurnOrRedistributableSharesByStrategy(
        OperatorSet calldata operatorSet,
        uint256 slashId,
        IStrategy strategy
    ) external returns (uint256);

    /// @notice Returns the strategies and shares that have NOT been sent to the redistribution recipient for a given slashId.
    /// @param operatorSet The operator set to burn or redistribute shares in.
    /// @param slashId The slash ID to burn or redistribute shares in.
    /// @return The strategies and shares for the given slashId.
    function getBurnOrRedistributableShares(
        OperatorSet calldata operatorSet,
        uint256 slashId
    ) external view returns (IStrategy[] memory, uint256[] memory);

    /// @notice Returns the shares for a given strategy for a given slashId.
    /// @param operatorSet The operator set to burn or redistribute shares in.
    /// @param slashId The slash ID to burn or redistribute shares in.
    /// @param strategy The strategy to get the shares for.
    /// @return The shares for the given strategy for the given slashId.
    /// @dev This function will return revert if the shares have already been sent to the redistribution recipient.
    function getBurnOrRedistributableShares(
        OperatorSet calldata operatorSet,
        uint256 slashId,
        IStrategy strategy
    ) external view returns (uint256);

    /// @notice Returns the number of strategies that have NOT been sent to the redistribution recipient for a given slashId.
    /// @param operatorSet The operator set to burn or redistribute shares in.
    /// @param slashId The slash ID to burn or redistribute shares in.
    /// @return The number of strategies for the given slashId.
    function getBurnOrRedistributableCount(
        OperatorSet calldata operatorSet,
        uint256 slashId
    ) external view returns (uint256);

    /// @notice Owner-only function to change the `strategyWhitelister` address.
    /// @param newStrategyWhitelister new address for the `strategyWhitelister`.
    function setStrategyWhitelister(
        address newStrategyWhitelister
    ) external;

    /// @notice Owner-only function that adds the provided Strategies to the 'whitelist' of strategies that stakers can deposit into
    /// @param strategiesToWhitelist Strategies that will be added to the `strategyIsWhitelistedForDeposit` mapping (if they aren't in it already)
    function addStrategiesToDepositWhitelist(
        IStrategy[] calldata strategiesToWhitelist
    ) external;

    /// @notice Owner-only function that removes the provided Strategies from the 'whitelist' of strategies that stakers can deposit into
    /// @param strategiesToRemoveFromWhitelist Strategies that will be removed to the `strategyIsWhitelistedForDeposit` mapping (if they are in it)
    function removeStrategiesFromDepositWhitelist(
        IStrategy[] calldata strategiesToRemoveFromWhitelist
    ) external;

    /// @notice Returns bool for whether or not `strategy` is whitelisted for deposit
    function strategyIsWhitelistedForDeposit(
        IStrategy strategy
    ) external view returns (bool);

    /// @notice Get all details on the staker's deposits and corresponding shares
    /// @return (staker's strategies, shares in these strategies)
    function getDeposits(
        address staker
    ) external view returns (IStrategy[] memory, uint256[] memory);

    function getStakerStrategyList(
        address staker
    ) external view returns (IStrategy[] memory);

    /// @notice Simple getter function that returns `stakerStrategyList[staker].length`.
    function stakerStrategyListLength(
        address staker
    ) external view returns (uint256);

    /// @notice Returns the current shares of `user` in `strategy`
    function stakerDepositShares(
        address user,
        IStrategy strategy
    ) external view returns (uint256 shares);

    /// @notice Returns the single, central Delegation contract of EigenLayer
    function delegation() external view returns (IDelegationManager);

    /// @notice Returns the address of the `strategyWhitelister`
    function strategyWhitelister() external view returns (address);

    /// @notice Returns the burnable shares of a strategy
    /// @dev This function will be deprecated in a release after redistribution
    function getBurnableShares(
        IStrategy strategy
    ) external view returns (uint256);

    /// @notice Gets every strategy with burnable shares and the amount of burnable shares in each said strategy
    ///
    /// @dev This function will be deprecated in a release after redistribution
    /// WARNING: This operation can copy the entire storage to memory, which can be quite expensive. This is designed
    /// to mostly be used by view accessors that are queried without any gas fees. Users should keep in mind that
    /// this function has an unbounded cost, and using it as part of a state-changing function may render the function
    /// uncallable if the map grows to a point where copying to memory consumes too much gas to fit in a block.
    function getStrategiesWithBurnableShares() external view returns (address[] memory, uint256[] memory);

    /// @param staker The address of the staker.
    /// @param strategy The strategy to deposit into.
    /// @param token The token to deposit.
    /// @param amount The amount of `token` to deposit.
    /// @param nonce The nonce of the staker.
    /// @param expiry The expiry of the signature.
    /// @return The EIP-712 signable digest hash.
    function calculateStrategyDepositDigestHash(
        address staker,
        IStrategy strategy,
        IERC20 token,
        uint256 amount,
        uint256 nonce,
        uint256 expiry
    ) external view returns (bytes32);

    /// @notice Returns the operator sets that have pending burn or redistributable shares.
    /// @return The operator sets that have pending burn or redistributable shares.
    function getPendingOperatorSets() external view returns (OperatorSet[] memory);

    /// @notice Returns the slash IDs that are pending to be burned or redistributed.
    /// @dev This function will return revert if the operator set has no pending burn or redistributable shares.
    /// @param operatorSet The operator set to get the pending slash IDs for.
    /// @return The slash IDs that are pending to be burned or redistributed.
    function getPendingSlashIds(
        OperatorSet calldata operatorSet
    ) external view returns (uint256[] memory);
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity >=0.5.0;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "../libraries/SlashingLib.sol";

interface IStrategyErrors {
    /// @dev Thrown when called by an account that is not strategy manager.
    error OnlyStrategyManager();
    /// @dev Thrown when new shares value is zero.
    error NewSharesZero();
    /// @dev Thrown when total shares exceeds max.
    error TotalSharesExceedsMax();
    /// @dev Thrown when amount shares is greater than total shares.
    error WithdrawalAmountExceedsTotalDeposits();
    /// @dev Thrown when attempting an action with a token that is not accepted.
    error OnlyUnderlyingToken();

    /// StrategyBaseWithTVLLimits

    /// @dev Thrown when `maxPerDeposit` exceeds max.
    error MaxPerDepositExceedsMax();
    /// @dev Thrown when balance exceeds max total deposits.
    error BalanceExceedsMaxTotalDeposits();
}

interface IStrategyEvents {
    /// @notice Used to emit an event for the exchange rate between 1 share and underlying token in a strategy contract
    /// @param rate is the exchange rate in wad 18 decimals
    /// @dev Tokens that do not have 18 decimals must have offchain services scale the exchange rate by the proper magnitude
    event ExchangeRateEmitted(uint256 rate);

    /// Used to emit the underlying token and its decimals on strategy creation
    /// @notice token
    /// @param token is the ERC20 token of the strategy
    /// @param decimals are the decimals of the ERC20 token in the strategy
    event StrategyTokenSet(IERC20 token, uint8 decimals);
}

/// @title Minimal interface for an `Strategy` contract.
/// @author Layr Labs, Inc.
/// @notice Terms of Service: https://docs.eigenlayer.xyz/overview/terms-of-service
/// @notice Custom `Strategy` implementations may expand extensively on this interface.
interface IStrategy is IStrategyErrors, IStrategyEvents {
    /// @notice Used to deposit tokens into this Strategy
    /// @param token is the ERC20 token being deposited
    /// @param amount is the amount of token being deposited
    /// @dev This function is only callable by the strategyManager contract. It is invoked inside of the strategyManager's
    /// `depositIntoStrategy` function, and individual share balances are recorded in the strategyManager as well.
    /// @return newShares is the number of new shares issued at the current exchange ratio.
    function deposit(
        IERC20 token,
        uint256 amount
    ) external returns (uint256);

    /// @notice Used to withdraw tokens from this Strategy, to the `recipient`'s address
    /// @param recipient is the address to receive the withdrawn funds
    /// @param token is the ERC20 token being transferred out
    /// @param amountShares is the amount of shares being withdrawn
    /// @dev This function is only callable by the strategyManager contract. It is invoked inside of the strategyManager's
    /// other functions, and individual share balances are recorded in the strategyManager as well.
    /// @return amountOut is the amount of tokens being transferred out.
    function withdraw(
        address recipient,
        IERC20 token,
        uint256 amountShares
    ) external returns (uint256);

    /// @notice Used to convert a number of shares to the equivalent amount of underlying tokens for this strategy.
    /// For a staker using this function and trying to calculate the amount of underlying tokens they have in total they
    /// should input into `amountShares` their withdrawable shares read from the `DelegationManager` contract.
    /// @notice In contrast to `sharesToUnderlyingView`, this function **may** make state modifications
    /// @param amountShares is the amount of shares to calculate its conversion into the underlying token
    /// @return The amount of underlying tokens corresponding to the input `amountShares`
    /// @dev Implementation for these functions in particular may vary significantly for different strategies
    function sharesToUnderlying(
        uint256 amountShares
    ) external returns (uint256);

    /// @notice Used to convert an amount of underlying tokens to the equivalent amount of shares in this strategy.
    /// @notice In contrast to `underlyingToSharesView`, this function **may** make state modifications
    /// @param amountUnderlying is the amount of `underlyingToken` to calculate its conversion into strategy shares
    /// @return The amount of shares corresponding to the input `amountUnderlying`.  This is used as deposit shares
    /// in the `StrategyManager` contract.
    /// @dev Implementation for these functions in particular may vary significantly for different strategies
    function underlyingToShares(
        uint256 amountUnderlying
    ) external returns (uint256);

    /// @notice convenience function for fetching the current underlying value of all of the `user`'s shares in
    /// this strategy. In contrast to `userUnderlyingView`, this function **may** make state modifications
    function userUnderlying(
        address user
    ) external returns (uint256);

    /// @notice convenience function for fetching the current total shares of `user` in this strategy, by
    /// querying the `strategyManager` contract
    function shares(
        address user
    ) external view returns (uint256);

    /// @notice Used to convert a number of shares to the equivalent amount of underlying tokens for this strategy.
    /// For a staker using this function and trying to calculate the amount of underlying tokens they have in total they
    /// should input into `amountShares` their withdrawable shares read from the `DelegationManager` contract.
    /// @notice In contrast to `sharesToUnderlying`, this function guarantees no state modifications
    /// @param amountShares is the amount of shares to calculate its conversion into the underlying token
    /// @return The amount of underlying tokens corresponding to the input `amountShares`
    /// @dev Implementation for these functions in particular may vary significantly for different strategies
    function sharesToUnderlyingView(
        uint256 amountShares
    ) external view returns (uint256);

    /// @notice Used to convert an amount of underlying tokens to the equivalent amount of shares in this strategy.
    /// @notice In contrast to `underlyingToShares`, this function guarantees no state modifications
    /// @param amountUnderlying is the amount of `underlyingToken` to calculate its conversion into strategy shares
    /// @return The amount of shares corresponding to the input `amountUnderlying`. This is used as deposit shares
    /// in the `StrategyManager` contract.
    /// @dev Implementation for these functions in particular may vary significantly for different strategies
    function underlyingToSharesView(
        uint256 amountUnderlying
    ) external view returns (uint256);

    /// @notice convenience function for fetching the current underlying value of all of the `user`'s shares in
    /// this strategy. In contrast to `userUnderlying`, this function guarantees no state modifications
    function userUnderlyingView(
        address user
    ) external view returns (uint256);

    /// @notice The underlying token for shares in this Strategy
    function underlyingToken() external view returns (IERC20);

    /// @notice The total number of extant shares in this Strategy
    function totalShares() external view returns (uint256);

    /// @notice Returns either a brief string explaining the strategy's goal & purpose, or a link to metadata that explains in more detail.
    function explanation() external view returns (string memory);
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity >=0.5.0;

interface IAVSRegistrar {
    /// @notice Called by the AllocationManager when an operator wants to register
    /// for one or more operator sets. This method should revert if registration
    /// is unsuccessful.
    /// @param operator the registering operator
    /// @param avs the AVS the operator is registering for. This should be the same as IAVSRegistrar.avs()
    /// @param operatorSetIds the list of operator set ids being registered for
    /// @param data arbitrary data the operator can provide as part of registration
    function registerOperator(
        address operator,
        address avs,
        uint32[] calldata operatorSetIds,
        bytes calldata data
    ) external;

    /// @notice Called by the AllocationManager when an operator is deregistered from one or more operator sets
    /// @param operator the deregistering operator
    /// @param avs the AVS the operator is deregistering from. This should be the same as IAVSRegistrar.avs()
    /// @param operatorSetIds the list of operator set ids being deregistered from
    function deregisterOperator(
        address operator,
        address avs,
        uint32[] calldata operatorSetIds
    ) external;

    /// @notice Returns true if the AVS is supported by the registrar
    /// @param avs the AVS to check
    /// @return true if the AVS is supported, false otherwise
    function supportsAVS(
        address avs
    ) external view returns (bool);
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity >=0.5.0;

interface ISignatureUtilsMixinErrors {
    /// @notice Thrown when a signature is invalid.
    error InvalidSignature();
    /// @notice Thrown when a signature has expired.
    error SignatureExpired();
}

interface ISignatureUtilsMixinTypes {
    /// @notice Struct that bundles together a signature and an expiration time for the signature.
    /// @dev Used primarily for stack management.
    struct SignatureWithExpiry {
        // the signature itself, formatted as a single bytes object
        bytes signature;
        // the expiration timestamp (UTC) of the signature
        uint256 expiry;
    }

    /// @notice Struct that bundles together a signature, a salt for uniqueness, and an expiration time for the signature.
    /// @dev Used primarily for stack management.
    struct SignatureWithSaltAndExpiry {
        // the signature itself, formatted as a single bytes object
        bytes signature;
        // the salt used to generate the signature
        bytes32 salt;
        // the expiration timestamp (UTC) of the signature
        uint256 expiry;
    }
}

/// @title The interface for common signature utilities.
/// @author Layr Labs, Inc.
/// @notice Terms of Service: https://docs.eigenlayer.xyz/overview/terms-of-service
interface ISignatureUtilsMixin is ISignatureUtilsMixinErrors, ISignatureUtilsMixinTypes {
    /// @notice Computes the EIP-712 domain separator used for signature validation.
    /// @dev The domain separator is computed according to EIP-712 specification, using:
    ///      - The hardcoded name "EigenLayer"
    ///      - The contract's version string
    ///      - The current chain ID
    ///      - This contract's address
    /// @return The 32-byte domain separator hash used in EIP-712 structured data signing.
    /// @dev See https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator.
    function domainSeparator() external view returns (bytes32);
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.27;

import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin-upgrades/contracts/utils/math/SafeCastUpgradeable.sol";

/// @dev All scaling factors have `1e18` as an initial/default value. This value is represented
/// by the constant `WAD`, which is used to preserve precision with uint256 math.
///
/// When applying scaling factors, they are typically multiplied/divided by `WAD`, allowing this
/// constant to act as a "1" in mathematical formulae.
uint64 constant WAD = 1e18;

/*
 * There are 2 types of shares:
 *      1. deposit shares
 *          - These can be converted to an amount of tokens given a strategy
 *              - by calling `sharesToUnderlying` on the strategy address (they're already tokens
 *              in the case of EigenPods)
 *          - These live in the storage of the EigenPodManager and individual StrategyManager strategies
 *      2. withdrawable shares
 *          - For a staker, this is the amount of shares that they can withdraw
 *          - For an operator, the shares delegated to them are equal to the sum of their stakers'
 *            withdrawable shares
 *
 * Along with a slashing factor, the DepositScalingFactor is used to convert between the two share types.
 */
struct DepositScalingFactor {
    uint256 _scalingFactor;
}

using SlashingLib for DepositScalingFactor global;

library SlashingLib {
    using Math for uint256;
    using SlashingLib for uint256;
    using SafeCastUpgradeable for uint256;

    /// @dev Thrown if an updated deposit scaling factor is 0 to avoid underflow.
    error InvalidDepositScalingFactor();

    // WAD MATH

    function mulWad(
        uint256 x,
        uint256 y
    ) internal pure returns (uint256) {
        return x.mulDiv(y, WAD);
    }

    function divWad(
        uint256 x,
        uint256 y
    ) internal pure returns (uint256) {
        return x.mulDiv(WAD, y);
    }

    /// @notice Used explicitly for calculating slashed magnitude, we want to ensure even in the
    /// situation where an operator is slashed several times and precision has been lost over time,
    /// an incoming slashing request isn't rounded down to 0 and an operator is able to avoid slashing penalties.
    function mulWadRoundUp(
        uint256 x,
        uint256 y
    ) internal pure returns (uint256) {
        return x.mulDiv(y, WAD, Math.Rounding.Up);
    }

    // GETTERS

    function scalingFactor(
        DepositScalingFactor memory dsf
    ) internal pure returns (uint256) {
        return dsf._scalingFactor == 0 ? WAD : dsf._scalingFactor;
    }

    function scaleForQueueWithdrawal(
        DepositScalingFactor memory dsf,
        uint256 depositSharesToWithdraw
    ) internal pure returns (uint256) {
        return depositSharesToWithdraw.mulWad(dsf.scalingFactor());
    }

    function scaleForCompleteWithdrawal(
        uint256 scaledShares,
        uint256 slashingFactor
    ) internal pure returns (uint256) {
        return scaledShares.mulWad(slashingFactor);
    }

    function update(
        DepositScalingFactor storage dsf,
        uint256 prevDepositShares,
        uint256 addedShares,
        uint256 slashingFactor
    ) internal {
        if (prevDepositShares == 0) {
            // If this is the staker's first deposit or they are delegating to an operator,
            // the slashing factor is inverted and applied to the existing DSF. This has the
            // effect of "forgiving" prior slashing for any subsequent deposits.
            dsf._scalingFactor = dsf.scalingFactor().divWad(slashingFactor);
            return;
        }

        /// Base Equations:
        /// (1) newShares = currentShares + addedShares
        /// (2) newDepositShares = prevDepositShares + addedShares
        /// (3) newShares = newDepositShares * newDepositScalingFactor * slashingFactor
        ///
        /// Plugging (1) into (3):
        /// (4) newDepositShares * newDepositScalingFactor * slashingFactor = currentShares + addedShares
        ///
        /// Solving for newDepositScalingFactor
        /// (5) newDepositScalingFactor = (currentShares + addedShares) / (newDepositShares * slashingFactor)
        ///
        /// Plugging in (2) into (5):
        /// (7) newDepositScalingFactor = (currentShares + addedShares) / ((prevDepositShares + addedShares) * slashingFactor)
        /// Note that magnitudes must be divided by WAD for precision. Thus,
        ///
        /// (8) newDepositScalingFactor = WAD * (currentShares + addedShares) / ((prevDepositShares + addedShares) * slashingFactor / WAD)
        /// (9) newDepositScalingFactor = (currentShares + addedShares) * WAD / (prevDepositShares + addedShares) * WAD / slashingFactor

        // Step 1: Calculate Numerator
        uint256 currentShares = dsf.calcWithdrawable(prevDepositShares, slashingFactor);

        // Step 2: Compute currentShares + addedShares
        uint256 newShares = currentShares + addedShares;

        // Step 3: Calculate newDepositScalingFactor
        /// forgefmt: disable-next-item
        uint256 newDepositScalingFactor = newShares
            .divWad(prevDepositShares + addedShares)
            .divWad(slashingFactor);

        dsf._scalingFactor = newDepositScalingFactor;

        // Avoid potential underflow.
        require(newDepositScalingFactor != 0, InvalidDepositScalingFactor());
    }

    /// @dev Reset the staker's DSF for a strategy by setting it to 0. This is the same
    /// as setting it to WAD (see the `scalingFactor` getter above).
    ///
    /// A DSF is reset when a staker reduces their deposit shares to 0, either by queueing
    /// a withdrawal, or undelegating from their operator. This ensures that subsequent
    /// delegations/deposits do not use a stale DSF (e.g. from a prior operator).
    function reset(
        DepositScalingFactor storage dsf
    ) internal {
        dsf._scalingFactor = 0;
    }

    // CONVERSION

    function calcWithdrawable(
        DepositScalingFactor memory dsf,
        uint256 depositShares,
        uint256 slashingFactor
    ) internal pure returns (uint256) {
        /// forgefmt: disable-next-item
        return depositShares
            .mulWad(dsf.scalingFactor())
            .mulWad(slashingFactor);
    }

    function calcDepositShares(
        DepositScalingFactor memory dsf,
        uint256 withdrawableShares,
        uint256 slashingFactor
    ) internal pure returns (uint256) {
        /// forgefmt: disable-next-item
        return withdrawableShares
            .divWad(dsf.scalingFactor())
            .divWad(slashingFactor);
    }

    /// @notice Calculates the amount of shares that should be slashed given the previous and new magnitudes.
    /// @param operatorShares The amount of shares to slash.
    /// @param prevMaxMagnitude The previous magnitude of the operator.
    /// @param newMaxMagnitude The new magnitude of the operator.
    /// @return The amount of shares that should be slashed.
    /// @dev This function will revert with a divide by zero error if the previous magnitude is 0.
    function calcSlashedAmount(
        uint256 operatorShares,
        uint256 prevMaxMagnitude,
        uint256 newMaxMagnitude
    ) internal pure returns (uint256) {
        // round up mulDiv so we don't overslash
        return operatorShares - operatorShares.mulDiv(newMaxMagnitude, prevMaxMagnitude, Math.Rounding.Up);
    }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.27;

import "../libraries/SlashingLib.sol";
import "./IStrategy.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "../libraries/OperatorSetLib.sol";
/// @title Interface for a `IShareManager` contract.
/// @author Layr Labs, Inc.
/// @notice Terms of Service: https://docs.eigenlayer.xyz/overview/terms-of-service
/// @notice This contract is used by the DelegationManager as a unified interface to interact with the EigenPodManager and StrategyManager

interface IShareManager {
    /// @notice Used by the DelegationManager to remove a Staker's shares from a particular strategy when entering the withdrawal queue
    /// @dev strategy must be beaconChainETH when talking to the EigenPodManager
    /// @return updatedShares the staker's deposit shares after decrement
    function removeDepositShares(
        address staker,
        IStrategy strategy,
        uint256 depositSharesToRemove
    ) external returns (uint256);

    /// @notice Used by the DelegationManager to award a Staker some shares that have passed through the withdrawal queue
    /// @dev strategy must be beaconChainETH when talking to the EigenPodManager
    /// @return existingDepositShares the shares the staker had before any were added
    /// @return addedShares the new shares added to the staker's balance
    function addShares(
        address staker,
        IStrategy strategy,
        uint256 shares
    ) external returns (uint256, uint256);

    /// @notice Used by the DelegationManager to convert deposit shares to tokens and send them to a staker
    /// @dev strategy must be beaconChainETH when talking to the EigenPodManager
    /// @dev token is not validated when talking to the EigenPodManager
    function withdrawSharesAsTokens(
        address staker,
        IStrategy strategy,
        IERC20 token,
        uint256 shares
    ) external;

    /// @notice Returns the current shares of `user` in `strategy`
    /// @dev strategy must be beaconChainETH when talking to the EigenPodManager
    /// @dev returns 0 if the user has negative shares
    function stakerDepositShares(
        address user,
        IStrategy strategy
    ) external view returns (uint256 depositShares);

    /// @notice Increase the amount of burnable/redistributable shares for a given Strategy. This is called by the DelegationManager
    /// when an operator is slashed in EigenLayer.
    /// @param operatorSet The operator set to burn shares in.
    /// @param slashId The slash id to burn shares in.
    /// @param strategy The strategy to burn shares in.
    /// @param addedSharesToBurn The amount of added shares to burn.
    /// @dev This function is only called by the DelegationManager when an operator is slashed.
    function increaseBurnOrRedistributableShares(
        OperatorSet calldata operatorSet,
        uint256 slashId,
        IStrategy strategy,
        uint256 addedSharesToBurn
    ) external;
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity >=0.5.0;

import "@openzeppelin/contracts/proxy/beacon/IBeacon.sol";
import "./IETHPOSDeposit.sol";
import "./IStrategyManager.sol";
import "./IEigenPod.sol";
import "./IShareManager.sol";
import "./IPausable.sol";
import "./IStrategy.sol";

interface IEigenPodManagerErrors {
    /// @dev Thrown when caller is not a EigenPod.
    error OnlyEigenPod();
    /// @dev Thrown when caller is not DelegationManager.
    error OnlyDelegationManager();
    /// @dev Thrown when caller already has an EigenPod.
    error EigenPodAlreadyExists();
    /// @dev Thrown when shares is not a multiple of gwei.
    error SharesNotMultipleOfGwei();
    /// @dev Thrown when shares would result in a negative integer.
    error SharesNegative();
    /// @dev Thrown when the strategy is not the beaconChainETH strategy.
    error InvalidStrategy();
    /// @dev Thrown when the pods shares are negative and a beacon chain balance update is attempted.
    /// The podOwner should complete legacy withdrawal first.
    error LegacyWithdrawalsNotCompleted();
    /// @dev Thrown when caller is not the proof timestamp setter
    error OnlyProofTimestampSetter();
}

interface IEigenPodManagerEvents {
    /// @notice Emitted to notify the deployment of an EigenPod
    event PodDeployed(address indexed eigenPod, address indexed podOwner);

    /// @notice Emitted to notify a deposit of beacon chain ETH recorded in the strategy manager
    event BeaconChainETHDeposited(address indexed podOwner, uint256 amount);

    /// @notice Emitted when the balance of an EigenPod is updated
    event PodSharesUpdated(address indexed podOwner, int256 sharesDelta);

    /// @notice Emitted every time the total shares of a pod are updated
    event NewTotalShares(address indexed podOwner, int256 newTotalShares);

    /// @notice Emitted when a withdrawal of beacon chain ETH is completed
    event BeaconChainETHWithdrawalCompleted(
        address indexed podOwner,
        uint256 shares,
        uint96 nonce,
        address delegatedAddress,
        address withdrawer,
        bytes32 withdrawalRoot
    );

    /// @notice Emitted when a staker's beaconChainSlashingFactor is updated
    event BeaconChainSlashingFactorDecreased(
        address staker,
        uint64 prevBeaconChainSlashingFactor,
        uint64 newBeaconChainSlashingFactor
    );

    /// @notice Emitted when an operator is slashed and shares to be burned are increased
    event BurnableETHSharesIncreased(uint256 shares);

    /// @notice Emitted when the Pectra fork timestamp is updated
    event PectraForkTimestampSet(uint64 newPectraForkTimestamp);

    /// @notice Emitted when the proof timestamp setter is updated
    event ProofTimestampSetterSet(address newProofTimestampSetter);
}

interface IEigenPodManagerTypes {
    /// @notice The amount of beacon chain slashing experienced by a pod owner as a proportion of WAD
    /// @param isSet whether the slashingFactor has ever been updated. Used to distinguish between
    /// a value of "0" and an uninitialized value.
    /// @param slashingFactor the proportion of the pod owner's balance that has been decreased due to
    /// slashing or other beacon chain balance decreases.
    /// @dev NOTE: if !isSet, `slashingFactor` should be treated as WAD. `slashingFactor` is monotonically
    /// decreasing and can hit 0 if fully slashed.
    struct BeaconChainSlashingFactor {
        bool isSet;
        uint64 slashingFactor;
    }
}

/// @title Interface for factory that creates and manages solo staking pods that have their withdrawal credentials pointed to EigenLayer.
/// @author Layr Labs, Inc.
/// @notice Terms of Service: https://docs.eigenlayer.xyz/overview/terms-of-service
interface IEigenPodManager is
    IEigenPodManagerErrors,
    IEigenPodManagerEvents,
    IEigenPodManagerTypes,
    IShareManager,
    IPausable
{
    /// @notice Creates an EigenPod for the sender.
    /// @dev Function will revert if the `msg.sender` already has an EigenPod.
    /// @dev Returns EigenPod address
    function createPod() external returns (address);

    /// @notice Stakes for a new beacon chain validator on the sender's EigenPod.
    /// Also creates an EigenPod for the sender if they don't have one already.
    /// @param pubkey The 48 bytes public key of the beacon chain validator.
    /// @param signature The validator's signature of the deposit data.
    /// @param depositDataRoot The root/hash of the deposit data for the validator's deposit.
    function stake(
        bytes calldata pubkey,
        bytes calldata signature,
        bytes32 depositDataRoot
    ) external payable;

    /// @notice Adds any positive share delta to the pod owner's deposit shares, and delegates them to the pod
    /// owner's operator (if applicable). A negative share delta does NOT impact the pod owner's deposit shares,
    /// but will reduce their beacon chain slashing factor and delegated shares accordingly.
    /// @param podOwner is the pod owner whose balance is being updated.
    /// @param prevRestakedBalanceWei is the total amount restaked through the pod before the balance update, including
    /// any amount currently in the withdrawal queue.
    /// @param balanceDeltaWei is the amount the balance changed
    /// @dev Callable only by the podOwner's EigenPod contract.
    /// @dev Reverts if `sharesDelta` is not a whole Gwei amount
    function recordBeaconChainETHBalanceUpdate(
        address podOwner,
        uint256 prevRestakedBalanceWei,
        int256 balanceDeltaWei
    ) external;

    /// @notice Sets the address that can set proof timestamps
    function setProofTimestampSetter(
        address newProofTimestampSetter
    ) external;

    /// @notice Sets the Pectra fork timestamp, only callable by `proofTimestampSetter`
    function setPectraForkTimestamp(
        uint64 timestamp
    ) external;

    /// @notice Returns the address of the `podOwner`'s EigenPod if it has been deployed.
    function ownerToPod(
        address podOwner
    ) external view returns (IEigenPod);

    /// @notice Returns the address of the `podOwner`'s EigenPod (whether it is deployed yet or not).
    function getPod(
        address podOwner
    ) external view returns (IEigenPod);

    /// @notice The ETH2 Deposit Contract
    function ethPOS() external view returns (IETHPOSDeposit);

    /// @notice Beacon proxy to which the EigenPods point
    function eigenPodBeacon() external view returns (IBeacon);

    /// @notice Returns 'true' if the `podOwner` has created an EigenPod, and 'false' otherwise.
    function hasPod(
        address podOwner
    ) external view returns (bool);

    /// @notice Returns the number of EigenPods that have been created
    function numPods() external view returns (uint256);

    /// @notice Mapping from Pod owner owner to the number of shares they have in the virtual beacon chain ETH strategy.
    /// @dev The share amount can become negative. This is necessary to accommodate the fact that a pod owner's virtual beacon chain ETH shares can
    /// decrease between the pod owner queuing and completing a withdrawal.
    /// When the pod owner's shares would otherwise increase, this "deficit" is decreased first _instead_.
    /// Likewise, when a withdrawal is completed, this "deficit" is decreased and the withdrawal amount is decreased; We can think of this
    /// as the withdrawal "paying off the deficit".
    function podOwnerDepositShares(
        address podOwner
    ) external view returns (int256);

    /// @notice returns canonical, virtual beaconChainETH strategy
    function beaconChainETHStrategy() external view returns (IStrategy);

    /// @notice Returns the historical sum of proportional balance decreases a pod owner has experienced when
    /// updating their pod's balance.
    function beaconChainSlashingFactor(
        address staker
    ) external view returns (uint64);

    /// @notice Returns the accumulated amount of beacon chain ETH Strategy shares
    function burnableETHShares() external view returns (uint256);

    /// @notice Returns the timestamp of the Pectra hard fork
    /// @dev Specifically, this returns the timestamp of the first non-missed slot at or after the Pectra hard fork
    function pectraForkTimestamp() external view returns (uint64);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1, "Math: mulDiv overflow");

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SafeCast.sol)
// This file was procedurally generated from scripts/generate/templates/SafeCast.js.

pragma solidity ^0.8.0;

/**
 * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow
 * checks.
 *
 * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
 * easily result in undesired exploitation or bugs, since developers usually
 * assume that overflows raise errors. `SafeCast` restores this intuition by
 * reverting the transaction when such an operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 *
 * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing
 * all math on `uint256` and `int256` and then downcasting.
 */
library SafeCastUpgradeable {
    /**
     * @dev Returns the downcasted uint248 from uint256, reverting on
     * overflow (when the input is greater than largest uint248).
     *
     * Counterpart to Solidity's `uint248` operator.
     *
     * Requirements:
     *
     * - input must fit into 248 bits
     *
     * _Available since v4.7._
     */
    function toUint248(uint256 value) internal pure returns (uint248) {
        require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits");
        return uint248(value);
    }

    /**
     * @dev Returns the downcasted uint240 from uint256, reverting on
     * overflow (when the input is greater than largest uint240).
     *
     * Counterpart to Solidity's `uint240` operator.
     *
     * Requirements:
     *
     * - input must fit into 240 bits
     *
     * _Available since v4.7._
     */
    function toUint240(uint256 value) internal pure returns (uint240) {
        require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits");
        return uint240(value);
    }

    /**
     * @dev Returns the downcasted uint232 from uint256, reverting on
     * overflow (when the input is greater than largest uint232).
     *
     * Counterpart to Solidity's `uint232` operator.
     *
     * Requirements:
     *
     * - input must fit into 232 bits
     *
     * _Available since v4.7._
     */
    function toUint232(uint256 value) internal pure returns (uint232) {
        require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits");
        return uint232(value);
    }

    /**
     * @dev Returns the downcasted uint224 from uint256, reverting on
     * overflow (when the input is greater than largest uint224).
     *
     * Counterpart to Solidity's `uint224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     *
     * _Available since v4.2._
     */
    function toUint224(uint256 value) internal pure returns (uint224) {
        require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
        return uint224(value);
    }

    /**
     * @dev Returns the downcasted uint216 from uint256, reverting on
     * overflow (when the input is greater than largest uint216).
     *
     * Counterpart to Solidity's `uint216` operator.
     *
     * Requirements:
     *
     * - input must fit into 216 bits
     *
     * _Available since v4.7._
     */
    function toUint216(uint256 value) internal pure returns (uint216) {
        require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits");
        return uint216(value);
    }

    /**
     * @dev Returns the downcasted uint208 from uint256, reverting on
     * overflow (when the input is greater than largest uint208).
     *
     * Counterpart to Solidity's `uint208` operator.
     *
     * Requirements:
     *
     * - input must fit into 208 bits
     *
     * _Available since v4.7._
     */
    function toUint208(uint256 value) internal pure returns (uint208) {
        require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits");
        return uint208(value);
    }

    /**
     * @dev Returns the downcasted uint200 from uint256, reverting on
     * overflow (when the input is greater than largest uint200).
     *
     * Counterpart to Solidity's `uint200` operator.
     *
     * Requirements:
     *
     * - input must fit into 200 bits
     *
     * _Available since v4.7._
     */
    function toUint200(uint256 value) internal pure returns (uint200) {
        require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits");
        return uint200(value);
    }

    /**
     * @dev Returns the downcasted uint192 from uint256, reverting on
     * overflow (when the input is greater than largest uint192).
     *
     * Counterpart to Solidity's `uint192` operator.
     *
     * Requirements:
     *
     * - input must fit into 192 bits
     *
     * _Available since v4.7._
     */
    function toUint192(uint256 value) internal pure returns (uint192) {
        require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits");
        return uint192(value);
    }

    /**
     * @dev Returns the downcasted uint184 from uint256, reverting on
     * overflow (when the input is greater than largest uint184).
     *
     * Counterpart to Solidity's `uint184` operator.
     *
     * Requirements:
     *
     * - input must fit into 184 bits
     *
     * _Available since v4.7._
     */
    function toUint184(uint256 value) internal pure returns (uint184) {
        require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits");
        return uint184(value);
    }

    /**
     * @dev Returns the downcasted uint176 from uint256, reverting on
     * overflow (when the input is greater than largest uint176).
     *
     * Counterpart to Solidity's `uint176` operator.
     *
     * Requirements:
     *
     * - input must fit into 176 bits
     *
     * _Available since v4.7._
     */
    function toUint176(uint256 value) internal pure returns (uint176) {
        require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits");
        return uint176(value);
    }

    /**
     * @dev Returns the downcasted uint168 from uint256, reverting on
     * overflow (when the input is greater than largest uint168).
     *
     * Counterpart to Solidity's `uint168` operator.
     *
     * Requirements:
     *
     * - input must fit into 168 bits
     *
     * _Available since v4.7._
     */
    function toUint168(uint256 value) internal pure returns (uint168) {
        require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits");
        return uint168(value);
    }

    /**
     * @dev Returns the downcasted uint160 from uint256, reverting on
     * overflow (when the input is greater than largest uint160).
     *
     * Counterpart to Solidity's `uint160` operator.
     *
     * Requirements:
     *
     * - input must fit into 160 bits
     *
     * _Available since v4.7._
     */
    function toUint160(uint256 value) internal pure returns (uint160) {
        require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits");
        return uint160(value);
    }

    /**
     * @dev Returns the downcasted uint152 from uint256, reverting on
     * overflow (when the input is greater than largest uint152).
     *
     * Counterpart to Solidity's `uint152` operator.
     *
     * Requirements:
     *
     * - input must fit into 152 bits
     *
     * _Available since v4.7._
     */
    function toUint152(uint256 value) internal pure returns (uint152) {
        require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits");
        return uint152(value);
    }

    /**
     * @dev Returns the downcasted uint144 from uint256, reverting on
     * overflow (when the input is greater than largest uint144).
     *
     * Counterpart to Solidity's `uint144` operator.
     *
     * Requirements:
     *
     * - input must fit into 144 bits
     *
     * _Available since v4.7._
     */
    function toUint144(uint256 value) internal pure returns (uint144) {
        require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits");
        return uint144(value);
    }

    /**
     * @dev Returns the downcasted uint136 from uint256, reverting on
     * overflow (when the input is greater than largest uint136).
     *
     * Counterpart to Solidity's `uint136` operator.
     *
     * Requirements:
     *
     * - input must fit into 136 bits
     *
     * _Available since v4.7._
     */
    function toUint136(uint256 value) internal pure returns (uint136) {
        require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits");
        return uint136(value);
    }

    /**
     * @dev Returns the downcasted uint128 from uint256, reverting on
     * overflow (when the input is greater than largest uint128).
     *
     * Counterpart to Solidity's `uint128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     *
     * _Available since v2.5._
     */
    function toUint128(uint256 value) internal pure returns (uint128) {
        require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
        return uint128(value);
    }

    /**
     * @dev Returns the downcasted uint120 from uint256, reverting on
     * overflow (when the input is greater than largest uint120).
     *
     * Counterpart to Solidity's `uint120` operator.
     *
     * Requirements:
     *
     * - input must fit into 120 bits
     *
     * _Available since v4.7._
     */
    function toUint120(uint256 value) internal pure returns (uint120) {
        require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits");
        return uint120(value);
    }

    /**
     * @dev Returns the downcasted uint112 from uint256, reverting on
     * overflow (when the input is greater than largest uint112).
     *
     * Counterpart to Solidity's `uint112` operator.
     *
     * Requirements:
     *
     * - input must fit into 112 bits
     *
     * _Available since v4.7._
     */
    function toUint112(uint256 value) internal pure returns (uint112) {
        require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits");
        return uint112(value);
    }

    /**
     * @dev Returns the downcasted uint104 from uint256, reverting on
     * overflow (when the input is greater than largest uint104).
     *
     * Counterpart to Solidity's `uint104` operator.
     *
     * Requirements:
     *
     * - input must fit into 104 bits
     *
     * _Available since v4.7._
     */
    function toUint104(uint256 value) internal pure returns (uint104) {
        require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits");
        return uint104(value);
    }

    /**
     * @dev Returns the downcasted uint96 from uint256, reverting on
     * overflow (when the input is greater than largest uint96).
     *
     * Counterpart to Solidity's `uint96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     *
     * _Available since v4.2._
     */
    function toUint96(uint256 value) internal pure returns (uint96) {
        require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
        return uint96(value);
    }

    /**
     * @dev Returns the downcasted uint88 from uint256, reverting on
     * overflow (when the input is greater than largest uint88).
     *
     * Counterpart to Solidity's `uint88` operator.
     *
     * Requirements:
     *
     * - input must fit into 88 bits
     *
     * _Available since v4.7._
     */
    function toUint88(uint256 value) internal pure returns (uint88) {
        require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits");
        return uint88(value);
    }

    /**
     * @dev Returns the downcasted uint80 from uint256, reverting on
     * overflow (when the input is greater than largest uint80).
     *
     * Counterpart to Solidity's `uint80` operator.
     *
     * Requirements:
     *
     * - input must fit into 80 bits
     *
     * _Available since v4.7._
     */
    function toUint80(uint256 value) internal pure returns (uint80) {
        require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits");
        return uint80(value);
    }

    /**
     * @dev Returns the downcasted uint72 from uint256, reverting on
     * overflow (when the input is greater than largest uint72).
     *
     * Counterpart to Solidity's `uint72` operator.
     *
     * Requirements:
     *
     * - input must fit into 72 bits
     *
     * _Available since v4.7._
     */
    function toUint72(uint256 value) internal pure returns (uint72) {
        require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits");
        return uint72(value);
    }

    /**
     * @dev Returns the downcasted uint64 from uint256, reverting on
     * overflow (when the input is greater than largest uint64).
     *
     * Counterpart to Solidity's `uint64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     *
     * _Available since v2.5._
     */
    function toUint64(uint256 value) internal pure returns (uint64) {
        require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
        return uint64(value);
    }

    /**
     * @dev Returns the downcasted uint56 from uint256, reverting on
     * overflow (when the input is greater than largest uint56).
     *
     * Counterpart to Solidity's `uint56` operator.
     *
     * Requirements:
     *
     * - input must fit into 56 bits
     *
     * _Available since v4.7._
     */
    function toUint56(uint256 value) internal pure returns (uint56) {
        require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits");
        return uint56(value);
    }

    /**
     * @dev Returns the downcasted uint48 from uint256, reverting on
     * overflow (when the input is greater than largest uint48).
     *
     * Counterpart to Solidity's `uint48` operator.
     *
     * Requirements:
     *
     * - input must fit into 48 bits
     *
     * _Available since v4.7._
     */
    function toUint48(uint256 value) internal pure returns (uint48) {
        require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits");
        return uint48(value);
    }

    /**
     * @dev Returns the downcasted uint40 from uint256, reverting on
     * overflow (when the input is greater than largest uint40).
     *
     * Counterpart to Solidity's `uint40` operator.
     *
     * Requirements:
     *
     * - input must fit into 40 bits
     *
     * _Available since v4.7._
     */
    function toUint40(uint256 value) internal pure returns (uint40) {
        require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits");
        return uint40(value);
    }

    /**
     * @dev Returns the downcasted uint32 from uint256, reverting on
     * overflow (when the input is greater than largest uint32).
     *
     * Counterpart to Solidity's `uint32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     *
     * _Available since v2.5._
     */
    function toUint32(uint256 value) internal pure returns (uint32) {
        require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
        return uint32(value);
    }

    /**
     * @dev Returns the downcasted uint24 from uint256, reverting on
     * overflow (when the input is greater than largest uint24).
     *
     * Counterpart to Solidity's `uint24` operator.
     *
     * Requirements:
     *
     * - input must fit into 24 bits
     *
     * _Available since v4.7._
     */
    function toUint24(uint256 value) internal pure returns (uint24) {
        require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits");
        return uint24(value);
    }

    /**
     * @dev Returns the downcasted uint16 from uint256, reverting on
     * overflow (when the input is greater than largest uint16).
     *
     * Counterpart to Solidity's `uint16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     *
     * _Available since v2.5._
     */
    function toUint16(uint256 value) internal pure returns (uint16) {
        require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
        return uint16(value);
    }

    /**
     * @dev Returns the downcasted uint8 from uint256, reverting on
     * overflow (when the input is greater than largest uint8).
     *
     * Counterpart to Solidity's `uint8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits
     *
     * _Available since v2.5._
     */
    function toUint8(uint256 value) internal pure returns (uint8) {
        require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
        return uint8(value);
    }

    /**
     * @dev Converts a signed int256 into an unsigned uint256.
     *
     * Requirements:
     *
     * - input must be greater than or equal to 0.
     *
     * _Available since v3.0._
     */
    function toUint256(int256 value) internal pure returns (uint256) {
        require(value >= 0, "SafeCast: value must be positive");
        return uint256(value);
    }

    /**
     * @dev Returns the downcasted int248 from int256, reverting on
     * overflow (when the input is less than smallest int248 or
     * greater than largest int248).
     *
     * Counterpart to Solidity's `int248` operator.
     *
     * Requirements:
     *
     * - input must fit into 248 bits
     *
     * _Available since v4.7._
     */
    function toInt248(int256 value) internal pure returns (int248 downcasted) {
        downcasted = int248(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 248 bits");
    }

    /**
     * @dev Returns the downcasted int240 from int256, reverting on
     * overflow (when the input is less than smallest int240 or
     * greater than largest int240).
     *
     * Counterpart to Solidity's `int240` operator.
     *
     * Requirements:
     *
     * - input must fit into 240 bits
     *
     * _Available since v4.7._
     */
    function toInt240(int256 value) internal pure returns (int240 downcasted) {
        downcasted = int240(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 240 bits");
    }

    /**
     * @dev Returns the downcasted int232 from int256, reverting on
     * overflow (when the input is less than smallest int232 or
     * greater than largest int232).
     *
     * Counterpart to Solidity's `int232` operator.
     *
     * Requirements:
     *
     * - input must fit into 232 bits
     *
     * _Available since v4.7._
     */
    function toInt232(int256 value) internal pure returns (int232 downcasted) {
        downcasted = int232(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 232 bits");
    }

    /**
     * @dev Returns the downcasted int224 from int256, reverting on
     * overflow (when the input is less than smallest int224 or
     * greater than largest int224).
     *
     * Counterpart to Solidity's `int224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     *
     * _Available since v4.7._
     */
    function toInt224(int256 value) internal pure returns (int224 downcasted) {
        downcasted = int224(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 224 bits");
    }

    /**
     * @dev Returns the downcasted int216 from int256, reverting on
     * overflow (when the input is less than smallest int216 or
     * greater than largest int216).
     *
     * Counterpart to Solidity's `int216` operator.
     *
     * Requirements:
     *
     * - input must fit into 216 bits
     *
     * _Available since v4.7._
     */
    function toInt216(int256 value) internal pure returns (int216 downcasted) {
        downcasted = int216(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 216 bits");
    }

    /**
     * @dev Returns the downcasted int208 from int256, reverting on
     * overflow (when the input is less than smallest int208 or
     * greater than largest int208).
     *
     * Counterpart to Solidity's `int208` operator.
     *
     * Requirements:
     *
     * - input must fit into 208 bits
     *
     * _Available since v4.7._
     */
    function toInt208(int256 value) internal pure returns (int208 downcasted) {
        downcasted = int208(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 208 bits");
    }

    /**
     * @dev Returns the downcasted int200 from int256, reverting on
     * overflow (when the input is less than smallest int200 or
     * greater than largest int200).
     *
     * Counterpart to Solidity's `int200` operator.
     *
     * Requirements:
     *
     * - input must fit into 200 bits
     *
     * _Available since v4.7._
     */
    function toInt200(int256 value) internal pure returns (int200 downcasted) {
        downcasted = int200(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 200 bits");
    }

    /**
     * @dev Returns the downcasted int192 from int256, reverting on
     * overflow (when the input is less than smallest int192 or
     * greater than largest int192).
     *
     * Counterpart to Solidity's `int192` operator.
     *
     * Requirements:
     *
     * - input must fit into 192 bits
     *
     * _Available since v4.7._
     */
    function toInt192(int256 value) internal pure returns (int192 downcasted) {
        downcasted = int192(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 192 bits");
    }

    /**
     * @dev Returns the downcasted int184 from int256, reverting on
     * overflow (when the input is less than smallest int184 or
     * greater than largest int184).
     *
     * Counterpart to Solidity's `int184` operator.
     *
     * Requirements:
     *
     * - input must fit into 184 bits
     *
     * _Available since v4.7._
     */
    function toInt184(int256 value) internal pure returns (int184 downcasted) {
        downcasted = int184(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 184 bits");
    }

    /**
     * @dev Returns the downcasted int176 from int256, reverting on
     * overflow (when the input is less than smallest int176 or
     * greater than largest int176).
     *
     * Counterpart to Solidity's `int176` operator.
     *
     * Requirements:
     *
     * - input must fit into 176 bits
     *
     * _Available since v4.7._
     */
    function toInt176(int256 value) internal pure returns (int176 downcasted) {
        downcasted = int176(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 176 bits");
    }

    /**
     * @dev Returns the downcasted int168 from int256, reverting on
     * overflow (when the input is less than smallest int168 or
     * greater than largest int168).
     *
     * Counterpart to Solidity's `int168` operator.
     *
     * Requirements:
     *
     * - input must fit into 168 bits
     *
     * _Available since v4.7._
     */
    function toInt168(int256 value) internal pure returns (int168 downcasted) {
        downcasted = int168(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 168 bits");
    }

    /**
     * @dev Returns the downcasted int160 from int256, reverting on
     * overflow (when the input is less than smallest int160 or
     * greater than largest int160).
     *
     * Counterpart to Solidity's `int160` operator.
     *
     * Requirements:
     *
     * - input must fit into 160 bits
     *
     * _Available since v4.7._
     */
    function toInt160(int256 value) internal pure returns (int160 downcasted) {
        downcasted = int160(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 160 bits");
    }

    /**
     * @dev Returns the downcasted int152 from int256, reverting on
     * overflow (when the input is less than smallest int152 or
     * greater than largest int152).
     *
     * Counterpart to Solidity's `int152` operator.
     *
     * Requirements:
     *
     * - input must fit into 152 bits
     *
     * _Available since v4.7._
     */
    function toInt152(int256 value) internal pure returns (int152 downcasted) {
        downcasted = int152(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 152 bits");
    }

    /**
     * @dev Returns the downcasted int144 from int256, reverting on
     * overflow (when the input is less than smallest int144 or
     * greater than largest int144).
     *
     * Counterpart to Solidity's `int144` operator.
     *
     * Requirements:
     *
     * - input must fit into 144 bits
     *
     * _Available since v4.7._
     */
    function toInt144(int256 value) internal pure returns (int144 downcasted) {
        downcasted = int144(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 144 bits");
    }

    /**
     * @dev Returns the downcasted int136 from int256, reverting on
     * overflow (when the input is less than smallest int136 or
     * greater than largest int136).
     *
     * Counterpart to Solidity's `int136` operator.
     *
     * Requirements:
     *
     * - input must fit into 136 bits
     *
     * _Available since v4.7._
     */
    function toInt136(int256 value) internal pure returns (int136 downcasted) {
        downcasted = int136(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 136 bits");
    }

    /**
     * @dev Returns the downcasted int128 from int256, reverting on
     * overflow (when the input is less than smallest int128 or
     * greater than largest int128).
     *
     * Counterpart to Solidity's `int128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     *
     * _Available since v3.1._
     */
    function toInt128(int256 value) internal pure returns (int128 downcasted) {
        downcasted = int128(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 128 bits");
    }

    /**
     * @dev Returns the downcasted int120 from int256, reverting on
     * overflow (when the input is less than smallest int120 or
     * greater than largest int120).
     *
     * Counterpart to Solidity's `int120` operator.
     *
     * Requirements:
     *
     * - input must fit into 120 bits
     *
     * _Available since v4.7._
     */
    function toInt120(int256 value) internal pure returns (int120 downcasted) {
        downcasted = int120(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 120 bits");
    }

    /**
     * @dev Returns the downcasted int112 from int256, reverting on
     * overflow (when the input is less than smallest int112 or
     * greater than largest int112).
     *
     * Counterpart to Solidity's `int112` operator.
     *
     * Requirements:
     *
     * - input must fit into 112 bits
     *
     * _Available since v4.7._
     */
    function toInt112(int256 value) internal pure returns (int112 downcasted) {
        downcasted = int112(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 112 bits");
    }

    /**
     * @dev Returns the downcasted int104 from int256, reverting on
     * overflow (when the input is less than smallest int104 or
     * greater than largest int104).
     *
     * Counterpart to Solidity's `int104` operator.
     *
     * Requirements:
     *
     * - input must fit into 104 bits
     *
     * _Available since v4.7._
     */
    function toInt104(int256 value) internal pure returns (int104 downcasted) {
        downcasted = int104(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 104 bits");
    }

    /**
     * @dev Returns the downcasted int96 from int256, reverting on
     * overflow (when the input is less than smallest int96 or
     * greater than largest int96).
     *
     * Counterpart to Solidity's `int96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     *
     * _Available since v4.7._
     */
    function toInt96(int256 value) internal pure returns (int96 downcasted) {
        downcasted = int96(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 96 bits");
    }

    /**
     * @dev Returns the downcasted int88 from int256, reverting on
     * overflow (when the input is less than smallest int88 or
     * greater than largest int88).
     *
     * Counterpart to Solidity's `int88` operator.
     *
     * Requirements:
     *
     * - input must fit into 88 bits
     *
     * _Available since v4.7._
     */
    function toInt88(int256 value) internal pure returns (int88 downcasted) {
        downcasted = int88(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 88 bits");
    }

    /**
     * @dev Returns the downcasted int80 from int256, reverting on
     * overflow (when the input is less than smallest int80 or
     * greater than largest int80).
     *
     * Counterpart to Solidity's `int80` operator.
     *
     * Requirements:
     *
     * - input must fit into 80 bits
     *
     * _Available since v4.7._
     */
    function toInt80(int256 value) internal pure returns (int80 downcasted) {
        downcasted = int80(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 80 bits");
    }

    /**
     * @dev Returns the downcasted int72 from int256, reverting on
     * overflow (when the input is less than smallest int72 or
     * greater than largest int72).
     *
     * Counterpart to Solidity's `int72` operator.
     *
     * Requirements:
     *
     * - input must fit into 72 bits
     *
     * _Available since v4.7._
     */
    function toInt72(int256 value) internal pure returns (int72 downcasted) {
        downcasted = int72(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 72 bits");
    }

    /**
     * @dev Returns the downcasted int64 from int256, reverting on
     * overflow (when the input is less than smallest int64 or
     * greater than largest int64).
     *
     * Counterpart to Solidity's `int64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     *
     * _Available since v3.1._
     */
    function toInt64(int256 value) internal pure returns (int64 downcasted) {
        downcasted = int64(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 64 bits");
    }

    /**
     * @dev Returns the downcasted int56 from int256, reverting on
     * overflow (when the input is less than smallest int56 or
     * greater than largest int56).
     *
     * Counterpart to Solidity's `int56` operator.
     *
     * Requirements:
     *
     * - input must fit into 56 bits
     *
     * _Available since v4.7._
     */
    function toInt56(int256 value) internal pure returns (int56 downcasted) {
        downcasted = int56(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 56 bits");
    }

    /**
     * @dev Returns the downcasted int48 from int256, reverting on
     * overflow (when the input is less than smallest int48 or
     * greater than largest int48).
     *
     * Counterpart to Solidity's `int48` operator.
     *
     * Requirements:
     *
     * - input must fit into 48 bits
     *
     * _Available since v4.7._
     */
    function toInt48(int256 value) internal pure returns (int48 downcasted) {
        downcasted = int48(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 48 bits");
    }

    /**
     * @dev Returns the downcasted int40 from int256, reverting on
     * overflow (when the input is less than smallest int40 or
     * greater than largest int40).
     *
     * Counterpart to Solidity's `int40` operator.
     *
     * Requirements:
     *
     * - input must fit into 40 bits
     *
     * _Available since v4.7._
     */
    function toInt40(int256 value) internal pure returns (int40 downcasted) {
        downcasted = int40(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 40 bits");
    }

    /**
     * @dev Returns the downcasted int32 from int256, reverting on
     * overflow (when the input is less than smallest int32 or
     * greater than largest int32).
     *
     * Counterpart to Solidity's `int32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     *
     * _Available since v3.1._
     */
    function toInt32(int256 value) internal pure returns (int32 downcasted) {
        downcasted = int32(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 32 bits");
    }

    /**
     * @dev Returns the downcasted int24 from int256, reverting on
     * overflow (when the input is less than smallest int24 or
     * greater than largest int24).
     *
     * Counterpart to Solidity's `int24` operator.
     *
     * Requirements:
     *
     * - input must fit into 24 bits
     *
     * _Available since v4.7._
     */
    function toInt24(int256 value) internal pure returns (int24 downcasted) {
        downcasted = int24(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 24 bits");
    }

    /**
     * @dev Returns the downcasted int16 from int256, reverting on
     * overflow (when the input is less than smallest int16 or
     * greater than largest int16).
     *
     * Counterpart to Solidity's `int16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     *
     * _Available since v3.1._
     */
    function toInt16(int256 value) internal pure returns (int16 downcasted) {
        downcasted = int16(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 16 bits");
    }

    /**
     * @dev Returns the downcasted int8 from int256, reverting on
     * overflow (when the input is less than smallest int8 or
     * greater than largest int8).
     *
     * Counterpart to Solidity's `int8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits
     *
     * _Available since v3.1._
     */
    function toInt8(int256 value) internal pure returns (int8 downcasted) {
        downcasted = int8(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 8 bits");
    }

    /**
     * @dev Converts an unsigned uint256 into a signed int256.
     *
     * Requirements:
     *
     * - input must be less than or equal to maxInt256.
     *
     * _Available since v3.0._
     */
    function toInt256(uint256 value) internal pure returns (int256) {
        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
        require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
        return int256(value);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)

pragma solidity ^0.8.0;

/**
 * @dev This is the interface that {BeaconProxy} expects of its beacon.
 */
interface IBeacon {
    /**
     * @dev Must return an address that can be used as a delegate call target.
     *
     * {BeaconProxy} will check that this address is a contract.
     */
    function implementation() external view returns (address);
}

// ┏━━━┓━┏┓━┏┓━━┏━━━┓━━┏━━━┓━━━━┏━━━┓━━━━━━━━━━━━━━━━━━━┏┓━━━━━┏━━━┓━━━━━━━━━┏┓━━━━━━━━━━━━━━┏┓━
// ┃┏━━┛┏┛┗┓┃┃━━┃┏━┓┃━━┃┏━┓┃━━━━┗┓┏┓┃━━━━━━━━━━━━━━━━━━┏┛┗┓━━━━┃┏━┓┃━━━━━━━━┏┛┗┓━━━━━━━━━━━━┏┛┗┓
// ┃┗━━┓┗┓┏┛┃┗━┓┗┛┏┛┃━━┃┃━┃┃━━━━━┃┃┃┃┏━━┓┏━━┓┏━━┓┏━━┓┏┓┗┓┏┛━━━━┃┃━┗┛┏━━┓┏━┓━┗┓┏┛┏━┓┏━━┓━┏━━┓┗┓┏┛
// ┃┏━━┛━┃┃━┃┏┓┃┏━┛┏┛━━┃┃━┃┃━━━━━┃┃┃┃┃┏┓┃┃┏┓┃┃┏┓┃┃━━┫┣┫━┃┃━━━━━┃┃━┏┓┃┏┓┃┃┏┓┓━┃┃━┃┏┛┗━┓┃━┃┏━┛━┃┃━
// ┃┗━━┓━┃┗┓┃┃┃┃┃┃┗━┓┏┓┃┗━┛┃━━━━┏┛┗┛┃┃┃━┫┃┗┛┃┃┗┛┃┣━━┃┃┃━┃┗┓━━━━┃┗━┛┃┃┗┛┃┃┃┃┃━┃┗┓┃┃━┃┗┛┗┓┃┗━┓━┃┗┓
// ┗━━━┛━┗━┛┗┛┗┛┗━━━┛┗┛┗━━━┛━━━━┗━━━┛┗━━┛┃┏━┛┗━━┛┗━━┛┗┛━┗━┛━━━━┗━━━┛┗━━┛┗┛┗┛━┗━┛┗┛━┗━━━┛┗━━┛━┗━┛
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┃┃━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┗┛━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

// SPDX-License-Identifier: CC0-1.0

pragma solidity >=0.5.0;

// This interface is designed to be compatible with the Vyper version.
/// @notice This is the Ethereum 2.0 deposit contract interface.
/// For more information see the Phase 0 specification under https://github.com/ethereum/eth2.0-specs
interface IETHPOSDeposit {
    /// @notice A processed deposit event.
    event DepositEvent(bytes pubkey, bytes withdrawal_credentials, bytes amount, bytes signature, bytes index);

    /// @notice Submit a Phase 0 DepositData object.
    /// @param pubkey A BLS12-381 public key.
    /// @param withdrawal_credentials Commitment to a public key for withdrawals.
    /// @param signature A BLS12-381 signature.
    /// @param deposit_data_root The SHA-256 hash of the SSZ-encoded DepositData object.
    /// Used as a protection against malformed input.
    function deposit(
        bytes calldata pubkey,
        bytes calldata withdrawal_credentials,
        bytes calldata signature,
        bytes32 deposit_data_root
    ) external payable;

    /// @notice Query the current deposit root hash.
    /// @return The deposit root hash.
    function get_deposit_root() external view returns (bytes32);

    /// @notice Query the current deposit count.
    /// @return The deposit count encoded as a little endian 64-bit number.
    function get_deposit_count() external view returns (bytes memory);
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity >=0.5.0;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

import "../libraries/BeaconChainProofs.sol";
import "./IEigenPodManager.sol";

interface IEigenPodErrors {
    /// @dev Thrown when msg.sender is not the EPM.
    error OnlyEigenPodManager();
    /// @dev Thrown when msg.sender is not the pod owner.
    error OnlyEigenPodOwner();
    /// @dev Thrown when msg.sender is not owner or the proof submitter.
    error OnlyEigenPodOwnerOrProofSubmitter();
    /// @dev Thrown when attempting an action that is currently paused.
    error CurrentlyPaused();

    /// Invalid Inputs

    /// @dev Thrown when an address of zero is provided.
    error InputAddressZero();
    /// @dev Thrown when two array parameters have mismatching lengths.
    error InputArrayLengthMismatch();
    /// @dev Thrown when `validatorPubKey` length is not equal to 48-bytes.
    error InvalidPubKeyLength();
    /// @dev Thrown when provided timestamp is out of range.
    error TimestampOutOfRange();

    /// Checkpoints

    /// @dev Thrown when no active checkpoints are found.
    error NoActiveCheckpoint();
    /// @dev Thrown if an uncompleted checkpoint exists.
    error CheckpointAlreadyActive();
    /// @dev Thrown if there's not a balance available to checkpoint.
    error NoBalanceToCheckpoint();
    /// @dev Thrown when attempting to create a checkpoint twice within a given block.
    error CannotCheckpointTwiceInSingleBlock();

    /// Withdrawing

    /// @dev Thrown when amount exceeds `restakedExecutionLayerGwei`.
    error InsufficientWithdrawableBalance();

    /// Validator Status

    /// @dev Thrown when a validator's withdrawal credentials have already been verified.
    error CredentialsAlreadyVerified();
    /// @dev Thrown if the provided proof is not valid for this EigenPod.
    error WithdrawalCredentialsNotForEigenPod();
    /// @dev Thrown when a validator is not in the ACTIVE status in the pod.
    error ValidatorNotActiveInPod();
    /// @dev Thrown when validator is not active yet on the beacon chain.
    error ValidatorInactiveOnBeaconChain();
    /// @dev Thrown if a validator is exiting the beacon chain.
    error ValidatorIsExitingBeaconChain();
    /// @dev Thrown when a validator has not been slashed on the beacon chain.
    error ValidatorNotSlashedOnBeaconChain();

    /// Consolidation and Withdrawal Requests

    /// @dev Thrown when a predeploy request is initiated with insufficient msg.value
    error InsufficientFunds();
    /// @dev Thrown when calling the predeploy fails
    error PredeployFailed();
    /// @dev Thrown when querying a predeploy for its current fee fails
    error FeeQueryFailed();

    /// Misc

    /// @dev Thrown when an invalid block root is returned by the EIP-4788 oracle.
    error InvalidEIP4788Response();
    /// @dev Thrown when attempting to send an invalid amount to the beacon deposit contract.
    error MsgValueNot32ETH();
    /// @dev Thrown when provided `beaconTimestamp` is too far in the past.
    error BeaconTimestampTooFarInPast();
    /// @dev Thrown when provided `beaconTimestamp` is before the last checkpoint
    error BeaconTimestampBeforeLatestCheckpoint();
    /// @dev Thrown when the pectraForkTimestamp returned from the EigenPodManager is zero
    error ForkTimestampZero();
}

interface IEigenPodTypes {
    enum VALIDATOR_STATUS {
        INACTIVE, // doesnt exist
        ACTIVE, // staked on ethpos and withdrawal credentials are pointed to the EigenPod
        WITHDRAWN // withdrawn from the Beacon Chain
    }

    /// @param validatorIndex index of the validator on the beacon chain
    /// @param restakedBalanceGwei amount of beacon chain ETH restaked on EigenLayer in gwei
    /// @param lastCheckpointedAt timestamp of the validator's most recent balance update
    /// @param status last recorded status of the validator
    struct ValidatorInfo {
        uint64 validatorIndex;
        uint64 restakedBalanceGwei;
        uint64 lastCheckpointedAt;
        VALIDATOR_STATUS status;
    }

    struct Checkpoint {
        bytes32 beaconBlockRoot;
        uint24 proofsRemaining;
        uint64 podBalanceGwei;
        int64 balanceDeltasGwei;
        uint64 prevBeaconBalanceGwei;
    }

    /// @param srcPubkey the pubkey of the source validator for the consolidation
    /// @param targetPubkey the pubkey of the target validator for the consolidation
    /// @dev Note that if srcPubkey == targetPubkey, this is a "switch request," and will
    /// change the validator's withdrawal credential type from 0x01 to 0x02.
    /// For more notes on usage, see `requestConsolidation`
    struct ConsolidationRequest {
        bytes srcPubkey;
        bytes targetPubkey;
    }

    /// @param pubkey the pubkey of the validator to withdraw from
    /// @param amountGwei the amount (in gwei) to withdraw from the beacon chain to the pod
    /// @dev Note that if amountGwei == 0, this is a "full exit request," and will fully exit
    /// the validator to the pod.
    /// For more notes on usage, see `requestWithdrawal`
    struct WithdrawalRequest {
        bytes pubkey;
        uint64 amountGwei;
    }
}

interface IEigenPodEvents is IEigenPodTypes {
    /// @notice Emitted when an ETH validator stakes via this eigenPod
    event EigenPodStaked(bytes32 pubkeyHash);

    /// @notice Emitted when a pod owner updates the proof submitter address
    event ProofSubmitterUpdated(address prevProofSubmitter, address newProofSubmitter);

    /// @notice Emitted when an ETH validator's withdrawal credentials are successfully verified to be pointed to this eigenPod
    event ValidatorRestaked(bytes32 pubkeyHash);

    /// @notice Emitted when an ETH validator's  balance is proven to be updated.  Here newValidatorBalanceGwei
    //  is the validator's balance that is credited on EigenLayer.
    event ValidatorBalanceUpdated(bytes32 pubkeyHash, uint64 balanceTimestamp, uint64 newValidatorBalanceGwei);

    /// @notice Emitted when restaked beacon chain ETH is withdrawn from the eigenPod.
    event RestakedBeaconChainETHWithdrawn(address indexed recipient, uint256 amount);

    /// @notice Emitted when ETH is received via the `receive` fallback
    event NonBeaconChainETHReceived(uint256 amountReceived);

    /// @notice Emitted when a checkpoint is created
    event CheckpointCreated(
        uint64 indexed checkpointTimestamp,
        bytes32 indexed beaconBlockRoot,
        uint256 validatorCount
    );

    /// @notice Emitted when a checkpoint is finalized
    event CheckpointFinalized(uint64 indexed checkpointTimestamp, int256 totalShareDeltaWei);

    /// @notice Emitted when a validator is proven for a given checkpoint
    event ValidatorCheckpointed(uint64 indexed checkpointTimestamp, bytes32 indexed pubkeyHash);

    /// @notice Emitted when a validator is proven to have 0 balance at a given checkpoint
    event ValidatorWithdrawn(uint64 indexed checkpointTimestamp, bytes32 indexed pubkeyHash);

    /// @notice Emitted when a consolidation request is initiated where source == target
    event SwitchToCompoundingRequested(bytes32 indexed validatorPubkeyHash);

    /// @notice Emitted when a standard consolidation request is initiated
    event ConsolidationRequested(bytes32 indexed sourcePubkeyHash, bytes32 indexed targetPubkeyHash);

    /// @notice Emitted when a withdrawal request is initiated where request.amountGwei == 0
    event ExitRequested(bytes32 indexed validatorPubkeyHash);

    /// @notice Emitted when a partial withdrawal request is initiated
    event WithdrawalRequested(bytes32 indexed validatorPubkeyHash, uint64 withdrawalAmountGwei);
}

/// @title The implementation contract used for restaking beacon chain ETH on EigenLayer
/// @author Layr Labs, Inc.
/// @notice Terms of Service: https://docs.eigenlayer.xyz/overview/terms-of-service
/// @dev Note that all beacon chain balances are stored as gwei within the beacon chain datastructures. We choose
///   to account balances in terms of gwei in the EigenPod contract and convert to wei when making calls to other contracts
interface IEigenPod is IEigenPodErrors, IEigenPodEvents {
    /// @notice Used to initialize the pointers to contracts crucial to the pod's functionality, in beacon proxy construction from EigenPodManager
    function initialize(
        address owner
    ) external;

    /// @notice Called by EigenPodManager when the owner wants to create another ETH validator.
    /// @dev This function only supports staking to a 0x01 validator. For compounding validators, please interact directly with the deposit contract.
    function stake(
        bytes calldata pubkey,
        bytes calldata signature,
        bytes32 depositDataRoot
    ) external payable;

    /// @notice Transfers `amountWei` from this contract to the `recipient`. Only callable by the EigenPodManager as part
    /// of the DelegationManager's withdrawal flow.
    /// @dev `amountWei` is not required to be a whole Gwei amount. Amounts less than a Gwei multiple may be unrecoverable due to Gwei conversion.
    function withdrawRestakedBeaconChainETH(
        address recipient,
        uint256 amount
    ) external;

    /// @dev Create a checkpoint used to prove this pod's active validator set. Checkpoints are completed
    /// by submitting one checkpoint proof per ACTIVE validator. During the checkpoint process, the total
    /// change in ACTIVE validator balance is tracked, and any validators with 0 balance are marked `WITHDRAWN`.
    /// @dev Once finalized, the pod owner is awarded shares corresponding to:
    /// - the total change in their ACTIVE validator balances
    /// - any ETH in the pod not already awarded shares
    /// @dev A checkpoint cannot be created if the pod already has an outstanding checkpoint. If
    /// this is the case, the pod owner MUST complete the existing checkpoint before starting a new one.
    /// @param revertIfNoBalance Forces a revert if the pod ETH balance is 0. This allows the pod owner
    /// to prevent accidentally starting a checkpoint that will not increase their shares
    function startCheckpoint(
        bool revertIfNoBalance
    ) external;

    /// @dev Progress the current checkpoint towards completion by submitting one or more validator
    /// checkpoint proofs. Anyone can call this method to submit proofs towards the current checkpoint.
    /// For each validator proven, the current checkpoint's `proofsRemaining` decreases.
    /// @dev If the checkpoint's `proofsRemaining` reaches 0, the checkpoint is finalized.
    /// (see `_updateCheckpoint` for more details)
    /// @dev This method can only be called when there is a currently-active checkpoint.
    /// @param balanceContainerProof proves the beacon's current balance container root against a checkpoint's `beaconBlockRoot`
    /// @param proofs Proofs for one or more validator current balances against the `balanceContainerRoot`
    function verifyCheckpointProofs(
        BeaconChainProofs.BalanceContainerProof calldata balanceContainerProof,
        BeaconChainProofs.BalanceProof[] calldata proofs
    ) external;

    /// @dev Verify one or more validators have their withdrawal credentials pointed at this EigenPod, and award
    /// shares based on their effective balance. Proven validators are marked `ACTIVE` within the EigenPod, and
    /// future checkpoint proofs will need to include them.
    /// @dev Withdrawal credential proofs MUST NOT be older than `currentCheckpointTimestamp`.
    /// @dev Validators proven via this method MUST NOT have an exit epoch set already.
    /// @param beaconTimestamp the beacon chain timestamp sent to the 4788 oracle contract. Corresponds
    /// to the parent beacon block root against which the proof is verified.
    /// @param stateRootProof proves a beacon state root against a beacon block root
    /// @param validatorIndices a list of validator indices being proven
    /// @param validatorFieldsProofs proofs of each validator's `validatorFields` against the beacon state root
    /// @param validatorFields the fields of the beacon chain "Validator" container. See consensus specs for
    /// details: https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/beacon-chain.md#validator
    function verifyWithdrawalCredentials(
        uint64 beaconTimestamp,
        BeaconChainProofs.StateRootProof calldata stateRootProof,
        uint40[] calldata validatorIndices,
        bytes[] calldata validatorFieldsProofs,
        bytes32[][] calldata validatorFields
    ) external;

    /// @dev Prove that one of this pod's active validators was slashed on the beacon chain. A successful
    /// staleness proof allows the caller to start a checkpoint.
    ///
    /// @dev Note that in order to start a checkpoint, any existing checkpoint must already be completed!
    /// (See `_startCheckpoint` for details)
    ///
    /// @dev Note that this method allows anyone to start a checkpoint as soon as a slashing occurs on the beacon
    /// chain. This is intended to make it easier to external watchers to keep a pod's balance up to date.
    ///
    /// @dev Note too that beacon chain slashings are not instant. There is a delay between the initial slashing event
    /// and the validator's final exit back to the execution layer. During this time, the validator's balance may or
    /// may not drop further due to a correlation penalty. This method allows proof of a slashed validator
    /// to initiate a checkpoint for as long as the validator remains on the beacon chain. Once the validator
    /// has exited and been checkpointed at 0 balance, they are no longer "checkpoint-able" and cannot be proven
    /// "stale" via this method.
    /// See https://eth2book.info/capella/part3/transition/epoch/#slashings for more info.
    ///
    /// @param beaconTimestamp the beacon chain timestamp sent to the 4788 oracle contract. Corresponds
    /// to the parent beacon block root against which the proof is verified.
    /// @param stateRootProof proves a beacon state root against a beacon block root
    /// @param proof the fields of the beacon chain "Validator" container, along with a merkle proof against
    /// the beacon state root. See the consensus specs for more details:
    /// https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/beacon-chain.md#validator
    ///
    /// @dev Staleness conditions:
    /// - Validator's last checkpoint is older than `beaconTimestamp`
    /// - Validator MUST be in `ACTIVE` status in the pod
    /// - Validator MUST be slashed on the beacon chain
    function verifyStaleBalance(
        uint64 beaconTimestamp,
        BeaconChainProofs.StateRootProof calldata stateRootProof,
        BeaconChainProofs.ValidatorProof calldata proof
    ) external;

    /// @notice Allows the owner or proof submitter to initiate one or more requests to
    /// consolidate their validators on the beacon chain.
    /// @param requests An array of requests consisting of the source and target pubkeys
    /// of the validators to be consolidated
    /// @dev The target validator MUST have ACTIVE (proven) withdrawal credentials pointed at
    /// the pod. This prevents cross-pod consolidations.
    /// @dev The consolidation request predeploy requires a fee is sent with each request;
    /// this is pulled from msg.value. After submitting all requests, any remaining fee is
    /// refunded to the caller by calling its fallback function.
    /// @dev This contract exposes `getConsolidationRequestFee` to query the current fee for
    /// a single request. If submitting multiple requests in a single block, the total fee
    /// is equal to (fee * requests.length). This fee is updated at the end of each block.
    ///
    /// (See https://eips.ethereum.org/EIPS/eip-7251#fee-calculation for details)
    ///
    /// @dev Note on beacon chain behavior:
    /// - If request.srcPubkey == request.targetPubkey, this is a "switch" consolidation. Once
    ///   processed on the beacon chain, the validator's withdrawal credentials will be changed
    ///   to compounding (0x02).
    /// - The rest of the notes assume src != target.
    /// - The target validator MUST already have 0x02 credentials. The source validator can have either.
    /// - Consolidation sets the source validator's exit_epoch and withdrawable_epoch, similar to an exit.
    ///   When the exit epoch is reached, an epoch sweep will process the consolidation and transfer balance
    ///   from the source to the target validator.
    /// - Consolidation transfers min(srcValidator.effective_balance, state.balance[srcIndex]) to the target.
    ///   This may not be the entirety of the source validator's balance; any remainder will be moved to the
    ///   pod when hit by a subsequent withdrawal sweep.
    ///
    /// @dev Note that consolidation requests CAN FAIL for a variety of reasons. Failures occur when the request
    /// is processed on the beacon chain, and are invisible to the pod. The pod and predeploy cannot guarantee
    /// a request will succeed; it's up to the pod owner to determine this for themselves. If your request fails,
    /// you can retry by initiating another request via this method.
    ///
    /// Some requirements that are NOT checked by the pod:
    /// - If request.srcPubkey == request.targetPubkey, the validator MUST have 0x01 credentials
    /// - If request.srcPubkey != request.targetPubkey, the target validator MUST have 0x02 credentials
    /// - Both the source and target validators MUST be active on the beacon chain and MUST NOT have
    ///   initiated exits
    /// - The source validator MUST NOT have pending partial withdrawal requests (via `requestWithdrawal`)
    /// - If the source validator is slashed after requesting consolidation (but before processing),
    ///   the consolidation will be skipped.
    ///
    /// For further reference, see consolidation processing at block and epoch boundaries:
    /// - Block: https://github.com/ethereum/consensus-specs/blob/dev/specs/electra/beacon-chain.md#new-process_consolidation_request
    /// - Epoch: https://github.com/ethereum/consensus-specs/blob/dev/specs/electra/beacon-chain.md#new-process_pending_consolidations
    function requestConsolidation(
        ConsolidationRequest[] calldata requests
    ) external payable;

    /// @notice Allows the owner or proof submitter to initiate one or more requests to
    /// withdraw funds from validators on the beacon chain.
    /// @param requests An array of requests consisting of the source validator and an
    /// amount to withdraw
    /// @dev The withdrawal request predeploy requires a fee is sent with each request;
    /// this is pulled from msg.value. After submitting all requests, any remaining fee is
    /// refunded to the caller by calling its fallback function.
    /// @dev This contract exposes `getWithdrawalRequestFee` to query the current fee for
    /// a single request. If submitting multiple requests in a single block, the total fee
    /// is equal to (fee * requests.length). This fee is updated at the end of each block.
    ///
    /// (See https://eips.ethereum.org/EIPS/eip-7002#fee-update-rule for details)
    ///
    /// @dev Note on beacon chain behavior:
    /// - Withdrawal requests have two types: full exit requests, and partial exit requests.
    ///   Partial exit requests will be skipped if the validator has 0x01 withdrawal credentials.
    ///   If you want your validators to have access to partial exits, use `requestConsolidation`
    ///   to change their withdrawal credentials to compounding (0x02).
    /// - If request.amount == 0, this is a FULL exit request. A full exit request initiates a
    ///   standard validator exit.
    /// - Other amounts are treated as PARTIAL exit requests. A partial exit request will NOT result
    ///   in a validator with less than 32 ETH balance. Any requested amount above this is ignored.
    /// - The actual amount withdrawn for a partial exit is given by the formula:
    ///   min(request.amount, state.balances[vIdx] - 32 ETH - pending_balance_to_withdraw)
    ///   (where `pending_balance_to_withdraw` is the sum of any outstanding partial exit requests)
    ///   (Note that this means you may request more than is actually withdrawn!)
    ///
    /// @dev Note that withdrawal requests CAN FAIL for a variety of reasons. Failures occur when the request
    /// is processed on the beacon chain, and are invisible to the pod. The pod and predeploy cannot guarantee
    /// a request will succeed; it's up to the pod owner to determine this for themselves. If your request fails,
    /// you can retry by initiating another request via this method.
    ///
    /// Some requirements that are NOT checked by the pod:
    /// - request.pubkey MUST be a valid validator pubkey
    /// - request.pubkey MUST belong to a validator whose withdrawal credentials are this pod
    /// - If request.amount is for a partial exit, the validator MUST have 0x02 withdrawal credentials
    /// - If request.amount is for a full exit, the validator MUST NOT have any pending partial exits
    /// - The validator MUST be active and MUST NOT have initiated exit
    ///
    /// For further reference: https://github.com/ethereum/consensus-specs/blob/dev/specs/electra/beacon-chain.md#new-process_withdrawal_request
    function requestWithdrawal(
        WithdrawalRequest[] calldata requests
    ) external payable;

    /// @notice called by owner of a pod to remove any ERC20s deposited in the pod
    function recoverTokens(
        IERC20[] memory tokenList,
        uint256[] memory amountsToWithdraw,
        address recipient
    ) external;

    /// @notice Allows the owner of a pod to update the proof submitter, a permissioned
    /// address that can call various EigenPod methods, but cannot trigger asset withdrawals
    /// from the DelegationManager.
    /// @dev Note that EITHER the podOwner OR proofSubmitter can access these methods,
    /// so it's fine to set your proofSubmitter to 0 if you want the podOwner to be the
    /// only address that can call these methods.
    /// @param newProofSubmitter The new proof submitter address. If set to 0, only the
    /// pod owner will be able to call EigenPod methods.
    function setProofSubmitter(
        address newProofSubmitter
    ) external;

    ///
    ///                                VIEW METHODS
    ///

    /// @notice An address with permissions to call `startCheckpoint` and `verifyWithdrawalCredentials`, set
    /// by the podOwner. This role exists to allow a podOwner to designate a hot wallet that can call
    /// these methods, allowing the podOwner to remain a cold wallet that is only used to manage funds.
    /// @dev If this address is NOT set, only the podOwner can call `startCheckpoint` and `verifyWithdrawalCredentials`
    function proofSubmitter() external view returns (address);

    /// @notice Native ETH in the pod that has been accounted for in a checkpoint (denominated in gwei).
    /// This amount is withdrawable from the pod via the DelegationManager withdrawal flow.
    function withdrawableRestakedExecutionLayerGwei() external view returns (uint64);

    /// @notice The single EigenPodManager for EigenLayer
    function eigenPodManager() external view returns (IEigenPodManager);

    /// @notice The owner of this EigenPod
    function podOwner() external view returns (address);

    /// @notice Returns the validatorInfo struct for the provided pubkeyHash
    function validatorPubkeyHashToInfo(
        bytes32 validatorPubkeyHash
    ) external view returns (ValidatorInfo memory);

    /// @notice Returns the validatorInfo struct for the provided pubkey
    function validatorPubkeyToInfo(
        bytes calldata validatorPubkey
    ) external view returns (ValidatorInfo memory);

    /// @notice Returns the validator status for a given validator pubkey hash
    function validatorStatus(
        bytes32 pubkeyHash
    ) external view returns (VALIDATOR_STATUS);

    /// @notice Returns the validator status for a given validator pubkey
    function validatorStatus(
        bytes calldata validatorPubkey
    ) external view returns (VALIDATOR_STATUS);

    /// @notice Number of validators with proven withdrawal credentials, who do not have proven full withdrawals
    function activeValidatorCount() external view returns (uint256);

    /// @notice The timestamp of the last checkpoint finalized
    function lastCheckpointTimestamp() external view returns (uint64);

    /// @notice The timestamp of the currently-active checkpoint. Will be 0 if there is not active checkpoint
    function currentCheckpointTimestamp() external view returns (uint64);

    /// @notice Returns the currently-active checkpoint
    /// If there's not an active checkpoint, this method returns the checkpoint that was last active.
    function currentCheckpoint() external view returns (Checkpoint memory);

    /// @notice For each checkpoint, the total balance attributed to exited validators, in gwei
    ///
    /// NOTE that the values added to this mapping are NOT guaranteed to capture the entirety of a validator's
    /// exit - rather, they capture the total change in a validator's balance when a checkpoint shows their
    /// balance change from nonzero to zero. While a change from nonzero to zero DOES guarantee that a validator
    /// has been fully exited, it is possible that the magnitude of this change does not capture what is
    /// typically thought of as a "full exit."
    ///
    /// For example:
    /// 1. Consider a validator was last checkpointed at 32 ETH before exiting. Once the exit has been processed,
    /// it is expected that the validator's exited balance is calculated to be `32 ETH`.
    /// 2. However, before `startCheckpoint` is called, a deposit is made to the validator for 1 ETH. The beacon
    /// chain will automatically withdraw this ETH, but not until the withdrawal sweep passes over the validator
    /// again. Until this occurs, the validator's current balance (used for checkpointing) is 1 ETH.
    /// 3. If `startCheckpoint` is called at this point, the balance delta calculated for this validator will be
    /// `-31 ETH`, and because the validator has a nonzero balance, it is not marked WITHDRAWN.
    /// 4. After the exit is processed by the beacon chain, a subsequent `startCheckpoint` and checkpoint proof
    /// will calculate a balance delta of `-1 ETH` and attribute a 1 ETH exit to the validator.
    ///
    /// If this edge case impacts your usecase, it should be possible to mitigate this by monitoring for deposits
    /// to your exited validators, and waiting to call `startCheckpoint` until those deposits have been automatically
    /// exited.
    ///
    /// Additional edge cases this mapping does not cover:
    /// - If a validator is slashed, their balance exited will reflect their original balance rather than the slashed amount
    /// - The final partial withdrawal for an exited validator will be likely be included in this mapping.
    ///   i.e. if a validator was last checkpointed at 32.1 ETH before exiting, the next checkpoint will calculate their
    ///   "exited" amount to be 32.1 ETH rather than 32 ETH.
    function checkpointBalanceExitedGwei(
        uint64
    ) external view returns (uint64);

    /// @notice Query the 4788 oracle to get the parent block root of the slot with the given `timestamp`
    /// @param timestamp of the block for which the parent block root will be returned. MUST correspond
    /// to an existing slot within the last 24 hours. If the slot at `timestamp` was skipped, this method
    /// will revert.
    function getParentBlockRoot(
        uint64 timestamp
    ) external view returns (bytes32);

    /// @notice Returns the fee required to add a consolidation request to the EIP-7251 predeploy this block.
    /// @dev Note that the predeploy updates its fee every block according to https://eips.ethereum.org/EIPS/eip-7251#fee-calculation
    /// Consider overestimating the amount sent to ensure the fee does not update before your transaction.
    function getConsolidationRequestFee() external view returns (uint256);

    /// @notice Returns the current fee required to add a withdrawal request to the EIP-7002 predeploy.
    /// @dev Note that the predeploy updates its fee every block according to https://eips.ethereum.org/EIPS/eip-7002#fee-update-rule
    /// Consider overestimating the amount sent to ensure the fee does not update before your transaction.
    function getWithdrawalRequestFee() external view returns (uint256);
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity ^0.8.0;

import "./Merkle.sol";
import "../libraries/Endian.sol";

//Utility library for parsing and PHASE0 beacon chain block headers
//SSZ Spec: https://github.com/ethereum/consensus-specs/blob/dev/ssz/simple-serialize.md#merkleization
//BeaconBlockHeader Spec: https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/beacon-chain.md#beaconblockheader
//BeaconState Spec: https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/beacon-chain.md#beaconstate
library BeaconChainProofs {
    /// @dev Thrown when a proof is invalid.
    error InvalidProof();
    /// @dev Thrown when a proof with an invalid length is provided.
    error InvalidProofLength();
    /// @dev Thrown when a validator fields length is invalid.
    error InvalidValidatorFieldsLength();

    /// @notice Heights of various merkle trees in the beacon chain
    ///         beaconBlockRoot
    ///                |                              HEIGHT: BEACON_BLOCK_HEADER_TREE_HEIGHT
    ///         beaconStateRoot
    ///        /               \                      HEIGHT: BEACON_STATE_TREE_HEIGHT
    /// validatorContainerRoot, balanceContainerRoot
    ///          |                       |            HEIGHT: BALANCE_TREE_HEIGHT
    ///          |              individual balances
    ///          |                                    HEIGHT: VALIDATOR_TREE_HEIGHT
    /// individual validators
    uint256 internal constant BEACON_BLOCK_HEADER_TREE_HEIGHT = 3;
    uint256 internal constant DENEB_BEACON_STATE_TREE_HEIGHT = 5;
    uint256 internal constant PECTRA_BEACON_STATE_TREE_HEIGHT = 6;
    uint256 internal constant BALANCE_TREE_HEIGHT = 38;
    uint256 internal constant VALIDATOR_TREE_HEIGHT = 40;

    /// @notice Index of the beaconStateRoot in the `BeaconBlockHeader` container
    ///
    /// BeaconBlockHeader = [..., state_root, ...]
    ///                      0...      3
    ///
    /// (See https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/beacon-chain.md#beaconblockheader)
    uint256 internal constant STATE_ROOT_INDEX = 3;

    /// @notice Indices for fields in the `BeaconState` container
    ///
    /// BeaconState = [..., validators, balances, ...]
    ///                0...     11         12
    ///
    /// (See https://github.com/ethereum/consensus-specs/blob/dev/specs/capella/beacon-chain.md#beaconstate)
    uint256 internal constant VALIDATOR_CONTAINER_INDEX = 11;
    uint256 internal constant BALANCE_CONTAINER_INDEX = 12;

    /// @notice Number of fields in the `Validator` container
    /// (See https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/beacon-chain.md#validator)
    uint256 internal constant VALIDATOR_FIELDS_LENGTH = 8;

    /// @notice Indices for fields in the `Validator` container
    uint256 internal constant VALIDATOR_PUBKEY_INDEX = 0;
    uint256 internal constant VALIDATOR_WITHDRAWAL_CREDENTIALS_INDEX = 1;
    uint256 internal constant VALIDATOR_BALANCE_INDEX = 2;
    uint256 internal constant VALIDATOR_SLASHED_INDEX = 3;
    uint256 internal constant VALIDATOR_ACTIVATION_EPOCH_INDEX = 5;
    uint256 internal constant VALIDATOR_EXIT_EPOCH_INDEX = 6;

    /// @notice Slot/Epoch timings
    uint64 internal constant SECONDS_PER_SLOT = 12;
    uint64 internal constant SLOTS_PER_EPOCH = 32;
    uint64 internal constant SECONDS_PER_EPOCH = SLOTS_PER_EPOCH * SECONDS_PER_SLOT;

    /// @notice `FAR_FUTURE_EPOCH` is used as the default value for certain `Validator`
    /// fields when a `Validator` is first created on the beacon chain
    uint64 internal constant FAR_FUTURE_EPOCH = type(uint64).max;
    bytes8 internal constant UINT64_MASK = 0xffffffffffffffff;

    /// @notice The beacon chain version to validate against
    enum ProofVersion {
        DENEB,
        PECTRA
    }

    /// @notice Contains a beacon state root and a merkle proof verifying its inclusion under a beacon block root
    struct StateRootProof {
        bytes32 beaconStateRoot;
        bytes proof;
    }

    /// @notice Contains a validator's fields and a merkle proof of their inclusion under a beacon state root
    struct ValidatorProof {
        bytes32[] validatorFields;
        bytes proof;
    }

    /// @notice Contains a beacon balance container root and a proof of this root under a beacon block root
    struct BalanceContainerProof {
        bytes32 balanceContainerRoot;
        bytes proof;
    }

    /// @notice Contains a validator balance root and a proof of its inclusion under a balance container root
    struct BalanceProof {
        bytes32 pubkeyHash;
        bytes32 balanceRoot;
        bytes proof;
    }

    ///
    ///              VALIDATOR FIELDS -> BEACON STATE ROOT -> BEACON BLOCK ROOT
    ///

    /// @notice Verify a merkle proof of the beacon state root against a beacon block root
    /// @param beaconBlockRoot merkle root of the beacon block
    /// @param proof the beacon state root and merkle proof of its inclusion under `beaconBlockRoot`
    function verifyStateRoot(
        bytes32 beaconBlockRoot,
        StateRootProof calldata proof
    ) internal view {
        require(proof.proof.length == 32 * (BEACON_BLOCK_HEADER_TREE_HEIGHT), InvalidProofLength());

        /// This merkle proof verifies the `beaconStateRoot` under the `beaconBlockRoot`
        /// - beaconBlockRoot
        /// |                            HEIGHT: BEACON_BLOCK_HEADER_TREE_HEIGHT
        /// -- beaconStateRoot
        require(
            Merkle.verifyInclusionSha256({
                proof: proof.proof,
                root: beaconBlockRoot,
                leaf: proof.beaconStateRoot,
                index: STATE_ROOT_INDEX
            }),
            InvalidProof()
        );
    }

    /// @notice Verify a merkle proof of a validator container against a `beaconStateRoot`
    /// @dev This proof starts at a validator's container root, proves through the validator container root,
    /// and continues proving to the root of the `BeaconState`
    /// @dev See https://eth2book.info/capella/part3/containers/dependencies/#validator for info on `Validator` containers
    /// @dev See https://eth2book.info/capella/part3/containers/state/#beaconstate for info on `BeaconState` containers
    /// @param beaconStateRoot merkle root of the `BeaconState` container
    /// @param validatorFields an individual validator's fields. These are merklized to form a `validatorRoot`,
    /// which is used as the leaf to prove against `beaconStateRoot`
    /// @param validatorFieldsProof a merkle proof of inclusion of `validatorFields` under `beaconStateRoot`
    /// @param validatorIndex the validator's unique index
    function verifyValidatorFields(
        ProofVersion proofVersion,
        bytes32 beaconStateRoot,
        bytes32[] calldata validatorFields,
        bytes calldata validatorFieldsProof,
        uint40 validatorIndex
    ) internal view {
        require(validatorFields.length == VALIDATOR_FIELDS_LENGTH, InvalidValidatorFieldsLength());

        uint256 beaconStateTreeHeight = getBeaconStateTreeHeight(proofVersion);

        /// Note: the reason we use `VALIDATOR_TREE_HEIGHT + 1` here is because the merklization process for
        /// this container includes hashing the root of the validator tree with the length of the validator list
        require(
            validatorFieldsProof.length == 32 * ((VALIDATOR_TREE_HEIGHT + 1) + beaconStateTreeHeight),
            InvalidProofLength()
        );

        // Merkleize `validatorFields` to get the leaf to prove
        bytes32 validatorRoot = Merkle.merkleizeSha256(validatorFields);

        /// This proof combines two proofs, so its index accounts for the relative position of leaves in two trees:
        /// - beaconStateRoot
        /// |                            HEIGHT: BEACON_STATE_TREE_HEIGHT
        /// -- validatorContainerRoot
        /// |                            HEIGHT: VALIDATOR_TREE_HEIGHT + 1
        /// ---- validatorRoot
        uint256 index = (VALIDATOR_CONTAINER_INDEX << (VALIDATOR_TREE_HEIGHT + 1)) | uint256(validatorIndex);

        require(
            Merkle.verifyInclusionSha256({
                proof: validatorFieldsProof,
                root: beaconStateRoot,
                leaf: validatorRoot,
                index: index
            }),
            InvalidProof()
        );
    }

    ///
    ///          VALIDATOR BALANCE -> BALANCE CONTAINER ROOT -> BEACON BLOCK ROOT
    ///

    /// @notice Verify a merkle proof of the beacon state's balances container against the beacon block root
    /// @dev This proof starts at the balance container root, proves through the beacon state root, and
    /// continues proving through the beacon block root. As a result, this proof will contain elements
    /// of a `StateRootProof` under the same block root, with the addition of proving the balances field
    /// within the beacon state.
    /// @dev This is used to make checkpoint proofs more efficient, as a checkpoint will verify multiple balances
    /// against the same balance container root.
    /// @param beaconBlockRoot merkle root of the beacon block
    /// @param proof a beacon balance container root and merkle proof of its inclusion under `beaconBlockRoot`
    function verifyBalanceContainer(
        ProofVersion proofVersion,
        bytes32 beaconBlockRoot,
        BalanceContainerProof calldata proof
    ) internal view {
        uint256 beaconStateTreeHeight = getBeaconStateTreeHeight(proofVersion);

        require(
            proof.proof.length == 32 * (BEACON_BLOCK_HEADER_TREE_HEIGHT + beaconStateTreeHeight), InvalidProofLength()
        );

        /// This proof combines two proofs, so its index accounts for the relative position of leaves in two trees:
        /// - beaconBlockRoot
        /// |                            HEIGHT: BEACON_BLOCK_HEADER_TREE_HEIGHT
        /// -- beaconStateRoot
        /// |                            HEIGHT: BEACON_STATE_TREE_HEIGHT
        /// ---- balancesContainerRoot
        uint256 index = (STATE_ROOT_INDEX << (beaconStateTreeHeight)) | BALANCE_CONTAINER_INDEX;

        require(
            Merkle.verifyInclusionSha256({
                proof: proof.proof,
                root: beaconBlockRoot,
                leaf: proof.balanceContainerRoot,
                index: index
            }),
            InvalidProof()
        );
    }

    /// @notice Verify a merkle proof of a validator's balance against the beacon state's `balanceContainerRoot`
    /// @param balanceContainerRoot the merkle root of all validators' current balances
    /// @param validatorIndex the index of the validator whose balance we are proving
    /// @param proof the validator's associated balance root and a merkle proof of inclusion under `balanceContainerRoot`
    /// @return validatorBalanceGwei the validator's current balance (in gwei)
    function verifyValidatorBalance(
        bytes32 balanceContainerRoot,
        uint40 validatorIndex,
        BalanceProof calldata proof
    ) internal view returns (uint64 validatorBalanceGwei) {
        /// Note: the reason we use `BALANCE_TREE_HEIGHT + 1` here is because the merklization process for
        /// this container includes hashing the root of the balances tree with the length of the balances list
        require(proof.proof.length == 32 * (BALANCE_TREE_HEIGHT + 1), InvalidProofLength());

        /// When merkleized, beacon chain balances are combined into groups of 4 called a `balanceRoot`. The merkle
        /// proof here verifies that this validator's `balanceRoot` is included in the `balanceContainerRoot`
        /// - balanceContainerRoot
        /// |                            HEIGHT: BALANCE_TREE_HEIGHT
        /// -- balanceRoot
        uint256 balanceIndex = uint256(validatorIndex / 4);

        require(
            Merkle.verifyInclusionSha256({
                proof: proof.proof,
                root: balanceContainerRoot,
                leaf: proof.balanceRoot,
                index: balanceIndex
            }),
            InvalidProof()
        );

        /// Extract the individual validator's balance from the `balanceRoot`
        return getBalanceAtIndex(proof.balanceRoot, validatorIndex);
    }

    /// @notice Parses a balanceRoot to get the uint64 balance of a validator.
    /// @dev During merkleization of the beacon state balance tree, four uint64 values are treated as a single
    /// leaf in the merkle tree. We use validatorIndex % 4 to determine which of the four uint64 values to
    /// extract from the balanceRoot.
    /// @param balanceRoot is the combination of 4 validator balances being proven for
    /// @param validatorIndex is the index of the validator being proven for
    /// @return The validator's balance, in Gwei
    function getBalanceAtIndex(
        bytes32 balanceRoot,
        uint40 validatorIndex
    ) internal pure returns (uint64) {
        uint256 bitShiftAmount = (validatorIndex % 4) * 64;
        return Endian.fromLittleEndianUint64(bytes32((uint256(balanceRoot) << bitShiftAmount)));
    }

    /// @notice Indices for fields in the `Validator` container:
    /// 0: pubkey
    /// 1: withdrawal credentials
    /// 2: effective balance
    /// 3: slashed?
    /// 4: activation eligibility epoch
    /// 5: activation epoch
    /// 6: exit epoch
    /// 7: withdrawable epoch
    ///
    /// (See https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/beacon-chain.md#validator)

    /// @dev Retrieves a validator's pubkey hash
    function getPubkeyHash(
        bytes32[] memory validatorFields
    ) internal pure returns (bytes32) {
        return validatorFields[VALIDATOR_PUBKEY_INDEX];
    }

    /// @dev Retrieves a validator's withdrawal credentials
    function getWithdrawalCredentials(
        bytes32[] memory validatorFields
    ) internal pure returns (bytes32) {
        return validatorFields[VALIDATOR_WITHDRAWAL_CREDENTIALS_INDEX];
    }

    /// @dev Retrieves a validator's effective balance (in gwei)
    function getEffectiveBalanceGwei(
        bytes32[] memory validatorFields
    ) internal pure returns (uint64) {
        return Endian.fromLittleEndianUint64(validatorFields[VALIDATOR_BALANCE_INDEX]);
    }

    /// @dev Retrieves a validator's activation epoch
    function getActivationEpoch(
        bytes32[] memory validatorFields
    ) internal pure returns (uint64) {
        return Endian.fromLittleEndianUint64(validatorFields[VALIDATOR_ACTIVATION_EPOCH_INDEX]);
    }

    /// @dev Retrieves true IFF a validator is marked slashed
    function isValidatorSlashed(
        bytes32[] memory validatorFields
    ) internal pure returns (bool) {
        return validatorFields[VALIDATOR_SLASHED_INDEX] != 0;
    }

    /// @dev Retrieves a validator's exit epoch
    function getExitEpoch(
        bytes32[] memory validatorFields
    ) internal pure returns (uint64) {
        return Endian.fromLittleEndianUint64(validatorFields[VALIDATOR_EXIT_EPOCH_INDEX]);
    }

    /// @dev We check if the proofTimestamp is <= pectraForkTimestamp because a `proofTimestamp` at the `pectraForkTimestamp`
    ///      is considered to be Pre-Pectra given the EIP-4788 oracle returns the parent block.
    function getBeaconStateTreeHeight(
        ProofVersion proofVersion
    ) internal pure returns (uint256) {
        return proofVersion == ProofVersion.DENEB ? DENEB_BEACON_STATE_TREE_HEIGHT : PECTRA_BEACON_STATE_TREE_HEIGHT;
    }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.0;

library Endian {
    /// @notice Converts a little endian-formatted uint64 to a big endian-formatted uint64
    /// @param lenum little endian-formatted uint64 input, provided as 'bytes32' type
    /// @return n The big endian-formatted uint64
    /// @dev Note that the input is formatted as a 'bytes32' type (i.e. 256 bits), but it is immediately truncated to a uint64 (i.e. 64 bits)
    /// through a right-shift/shr operation.
    function fromLittleEndianUint64(
        bytes32 lenum
    ) internal pure returns (uint64 n) {
        // the number needs to be stored in little-endian encoding (ie in bytes 0-8)
        n = uint64(uint256(lenum >> 192));
        // forgefmt: disable-next-item
        return (n >> 56) | 
            ((0x00FF000000000000 & n) >> 40) | 
            ((0x0000FF0000000000 & n) >> 24) | 
            ((0x000000FF00000000 & n) >> 8)  | 
            ((0x00000000FF000000 & n) << 8)  | 
            ((0x0000000000FF0000 & n) << 24) | 
            ((0x000000000000FF00 & n) << 40) | 
            ((0x00000000000000FF & n) << 56);
    }
}

{
  "remappings": [
    "@openzeppelin/=lib/openzeppelin-contracts-v4.9.0/",
    "@openzeppelin-upgrades/=lib/openzeppelin-contracts-upgradeable-v4.9.0/",
    "ds-test/=lib/ds-test/src/",
    "forge-std/=lib/forge-std/src/",
    "erc4626-tests/=lib/openzeppelin-contracts-upgradeable-v4.9.0/lib/erc4626-tests/",
    "openzeppelin-contracts-upgradeable-v4.9.0/=lib/openzeppelin-contracts-upgradeable-v4.9.0/",
    "openzeppelin-contracts-v4.9.0/=lib/openzeppelin-contracts-v4.9.0/",
    "openzeppelin/=lib/openzeppelin-contracts-upgradeable-v4.9.0/contracts/",
    "zeus-templates/=lib/zeus-templates/src/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "prague",
  "viaIR": false
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"components":[{"internalType":"contract IDelegationManager","name":"delegationManager","type":"address"},{"internalType":"contract IStrategyManager","name":"strategyManager","type":"address"},{"internalType":"contract IAllocationManager","name":"allocationManager","type":"address"},{"internalType":"contract IPauserRegistry","name":"pauserRegistry","type":"address"},{"internalType":"contract IPermissionController","name":"permissionController","type":"address"},{"internalType":"uint32","name":"CALCULATION_INTERVAL_SECONDS","type":"uint32"},{"internalType":"uint32","name":"MAX_REWARDS_DURATION","type":"uint32"},{"internalType":"uint32","name":"MAX_RETROACTIVE_LENGTH","type":"uint32"},{"internalType":"uint32","name":"MAX_FUTURE_LENGTH","type":"uint32"},{"internalType":"uint32","name":"GENESIS_REWARDS_TIMESTAMP","type":"uint32"}],"internalType":"struct IRewardsCoordinatorTypes.RewardsCoordinatorConstructorParams","name":"params","type":"tuple"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AmountExceedsMax","type":"error"},{"inputs":[],"name":"AmountIsZero","type":"error"},{"inputs":[],"name":"CurrentlyPaused","type":"error"},{"inputs":[],"name":"DurationExceedsMax","type":"error"},{"inputs":[],"name":"DurationIsZero","type":"error"},{"inputs":[],"name":"EarningsNotGreaterThanClaimed","type":"error"},{"inputs":[],"name":"EmptyRoot","type":"error"},{"inputs":[],"name":"InputAddressZero","type":"error"},{"inputs":[],"name":"InputArrayLengthMismatch","type":"error"},{"inputs":[],"name":"InputArrayLengthZero","type":"error"},{"inputs":[],"name":"InvalidAddressZero","type":"error"},{"inputs":[],"name":"InvalidCalculationIntervalSecondsRemainder","type":"error"},{"inputs":[],"name":"InvalidClaimProof","type":"error"},{"inputs":[],"name":"InvalidDurationRemainder","type":"error"},{"inputs":[],"name":"InvalidEarner","type":"error"},{"inputs":[],"name":"InvalidEarnerLeafIndex","type":"error"},{"inputs":[],"name":"InvalidGenesisRewardsTimestampRemainder","type":"error"},{"inputs":[],"name":"InvalidIndex","type":"error"},{"inputs":[],"name":"InvalidNewPausedStatus","type":"error"},{"inputs":[],"name":"InvalidOperatorSet","type":"error"},{"inputs":[],"name":"InvalidPermissions","type":"error"},{"inputs":[],"name":"InvalidProofLength","type":"error"},{"inputs":[],"name":"InvalidRoot","type":"error"},{"inputs":[],"name":"InvalidRootIndex","type":"error"},{"inputs":[],"name":"InvalidStartTimestampRemainder","type":"error"},{"inputs":[],"name":"InvalidTokenLeafIndex","type":"error"},{"inputs":[],"name":"NewRootMustBeForNewCalculatedPeriod","type":"error"},{"inputs":[],"name":"OnlyPauser","type":"error"},{"inputs":[],"name":"OnlyUnpauser","type":"error"},{"inputs":[],"name":"OperatorsNotInAscendingOrder","type":"error"},{"inputs":[],"name":"PreviousSplitPending","type":"error"},{"inputs":[],"name":"RewardsEndTimestampNotElapsed","type":"error"},{"inputs":[],"name":"RootAlreadyActivated","type":"error"},{"inputs":[],"name":"RootDisabled","type":"error"},{"inputs":[],"name":"RootNotActivated","type":"error"},{"inputs":[],"name":"SplitExceedsMax","type":"error"},{"inputs":[],"name":"StartTimestampTooFarInFuture","type":"error"},{"inputs":[],"name":"StartTimestampTooFarInPast","type":"error"},{"inputs":[],"name":"StrategiesNotInAscendingOrder","type":"error"},{"inputs":[],"name":"StrategyNotWhitelisted","type":"error"},{"inputs":[],"name":"SubmissionNotRetroactive","type":"error"},{"inputs":[],"name":"UnauthorizedCaller","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"avs","type":"address"},{"indexed":true,"internalType":"uint256","name":"submissionNonce","type":"uint256"},{"indexed":true,"internalType":"bytes32","name":"rewardsSubmissionHash","type":"bytes32"},{"components":[{"components":[{"internalType":"contract IStrategy","name":"strategy","type":"address"},{"internalType":"uint96","name":"multiplier","type":"uint96"}],"internalType":"struct IRewardsCoordinatorTypes.StrategyAndMultiplier[]","name":"strategiesAndMultipliers","type":"tuple[]"},{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint32","name":"startTimestamp","type":"uint32"},{"internalType":"uint32","name":"duration","type":"uint32"}],"indexed":false,"internalType":"struct IRewardsCoordinatorTypes.RewardsSubmission","name":"rewardsSubmission","type":"tuple"}],"name":"AVSRewardsSubmissionCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint32","name":"oldActivationDelay","type":"uint32"},{"indexed":false,"internalType":"uint32","name":"newActivationDelay","type":"uint32"}],"name":"ActivationDelaySet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"earner","type":"address"},{"indexed":true,"internalType":"address","name":"oldClaimer","type":"address"},{"indexed":true,"internalType":"address","name":"claimer","type":"address"}],"name":"ClaimerForSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint16","name":"oldDefaultOperatorSplitBips","type":"uint16"},{"indexed":false,"internalType":"uint16","name":"newDefaultOperatorSplitBips","type":"uint16"}],"name":"DefaultOperatorSplitBipsSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint32","name":"rootIndex","type":"uint32"}],"name":"DistributionRootDisabled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint32","name":"rootIndex","type":"uint32"},{"indexed":true,"internalType":"bytes32","name":"root","type":"bytes32"},{"indexed":true,"internalType":"uint32","name":"rewardsCalculationEndTimestamp","type":"uint32"},{"indexed":false,"internalType":"uint32","name":"activatedAt","type":"uint32"}],"name":"DistributionRootSubmitted","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"avs","type":"address"},{"indexed":false,"internalType":"uint32","name":"activatedAt","type":"uint32"},{"indexed":false,"internalType":"uint16","name":"oldOperatorAVSSplitBips","type":"uint16"},{"indexed":false,"internalType":"uint16","name":"newOperatorAVSSplitBips","type":"uint16"}],"name":"OperatorAVSSplitBipsSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":true,"internalType":"address","name":"avs","type":"address"},{"indexed":true,"internalType":"bytes32","name":"operatorDirectedRewardsSubmissionHash","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"submissionNonce","type":"uint256"},{"components":[{"components":[{"internalType":"contract IStrategy","name":"strategy","type":"address"},{"internalType":"uint96","name":"multiplier","type":"uint96"}],"internalType":"struct IRewardsCoordinatorTypes.StrategyAndMultiplier[]","name":"strategiesAndMultipliers","type":"tuple[]"},{"internalType":"contract IERC20","name":"token","type":"address"},{"components":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct IRewardsCoordinatorTypes.OperatorReward[]","name":"operatorRewards","type":"tuple[]"},{"internalType":"uint32","name":"startTimestamp","type":"uint32"},{"internalType":"uint32","name":"duration","type":"uint32"},{"internalType":"string","name":"description","type":"string"}],"indexed":false,"internalType":"struct IRewardsCoordinatorTypes.OperatorDirectedRewardsSubmission","name":"operatorDirectedRewardsSubmission","type":"tuple"}],"name":"OperatorDirectedAVSRewardsSubmissionCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":true,"internalType":"bytes32","name":"operatorDirectedRewardsSubmissionHash","type":"bytes32"},{"components":[{"internalType":"address","name":"avs","type":"address"},{"internalType":"uint32","name":"id","type":"uint32"}],"indexed":false,"internalType":"struct OperatorSet","name":"operatorSet","type":"tuple"},{"indexed":false,"internalType":"uint256","name":"submissionNonce","type":"uint256"},{"components":[{"components":[{"internalType":"contract IStrategy","name":"strategy","type":"address"},{"internalType":"uint96","name":"multiplier","type":"uint96"}],"internalType":"struct IRewardsCoordinatorTypes.StrategyAndMultiplier[]","name":"strategiesAndMultipliers","type":"tuple[]"},{"internalType":"contract IERC20","name":"token","type":"address"},{"components":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct IRewardsCoordinatorTypes.OperatorReward[]","name":"operatorRewards","type":"tuple[]"},{"internalType":"uint32","name":"startTimestamp","type":"uint32"},{"internalType":"uint32","name":"duration","type":"uint32"},{"internalType":"string","name":"description","type":"string"}],"indexed":false,"internalType":"struct IRewardsCoordinatorTypes.OperatorDirectedRewardsSubmission","name":"operatorDirectedRewardsSubmission","type":"tuple"}],"name":"OperatorDirectedOperatorSetRewardsSubmissionCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"uint32","name":"activatedAt","type":"uint32"},{"indexed":false,"internalType":"uint16","name":"oldOperatorPISplitBips","type":"uint16"},{"indexed":false,"internalType":"uint16","name":"newOperatorPISplitBips","type":"uint16"}],"name":"OperatorPISplitBipsSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"components":[{"internalType":"address","name":"avs","type":"address"},{"internalType":"uint32","name":"id","type":"uint32"}],"indexed":false,"internalType":"struct OperatorSet","name":"operatorSet","type":"tuple"},{"indexed":false,"internalType":"uint32","name":"activatedAt","type":"uint32"},{"indexed":false,"internalType":"uint16","name":"oldOperatorSetSplitBips","type":"uint16"},{"indexed":false,"internalType":"uint16","name":"newOperatorSetSplitBips","type":"uint16"}],"name":"OperatorSetSplitBipsSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"newPausedStatus","type":"uint256"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"root","type":"bytes32"},{"indexed":true,"internalType":"address","name":"earner","type":"address"},{"indexed":true,"internalType":"address","name":"claimer","type":"address"},{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"contract IERC20","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"claimedAmount","type":"uint256"}],"name":"RewardsClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"rewardsForAllSubmitter","type":"address"},{"indexed":true,"internalType":"bool","name":"oldValue","type":"bool"},{"indexed":true,"internalType":"bool","name":"newValue","type":"bool"}],"name":"RewardsForAllSubmitterSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"submitter","type":"address"},{"indexed":true,"internalType":"uint256","name":"submissionNonce","type":"uint256"},{"indexed":true,"internalType":"bytes32","name":"rewardsSubmissionHash","type":"bytes32"},{"components":[{"components":[{"internalType":"contract IStrategy","name":"strategy","type":"address"},{"internalType":"uint96","name":"multiplier","type":"uint96"}],"internalType":"struct IRewardsCoordinatorTypes.StrategyAndMultiplier[]","name":"strategiesAndMultipliers","type":"tuple[]"},{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint32","name":"startTimestamp","type":"uint32"},{"internalType":"uint32","name":"duration","type":"uint32"}],"indexed":false,"internalType":"struct IRewardsCoordinatorTypes.RewardsSubmission","name":"rewardsSubmission","type":"tuple"}],"name":"RewardsSubmissionForAllCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"tokenHopper","type":"address"},{"indexed":true,"internalType":"uint256","name":"submissionNonce","type":"uint256"},{"indexed":true,"internalType":"bytes32","name":"rewardsSubmissionHash","type":"bytes32"},{"components":[{"components":[{"internalType":"contract IStrategy","name":"strategy","type":"address"},{"internalType":"uint96","name":"multiplier","type":"uint96"}],"internalType":"struct IRewardsCoordinatorTypes.StrategyAndMultiplier[]","name":"strategiesAndMultipliers","type":"tuple[]"},{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint32","name":"startTimestamp","type":"uint32"},{"internalType":"uint32","name":"duration","type":"uint32"}],"indexed":false,"internalType":"struct IRewardsCoordinatorTypes.RewardsSubmission","name":"rewardsSubmission","type":"tuple"}],"name":"RewardsSubmissionForAllEarnersCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldRewardsUpdater","type":"address"},{"indexed":true,"internalType":"address","name":"newRewardsUpdater","type":"address"}],"name":"RewardsUpdaterSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"newPausedStatus","type":"uint256"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"CALCULATION_INTERVAL_SECONDS","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"GENESIS_REWARDS_TIMESTAMP","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_FUTURE_LENGTH","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_RETROACTIVE_LENGTH","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_REWARDS_DURATION","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"activationDelay","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"allocationManager","outputs":[{"internalType":"contract IAllocationManager","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"beaconChainETHStrategy","outputs":[{"internalType":"contract IStrategy","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"earner","type":"address"},{"internalType":"bytes32","name":"earnerTokenRoot","type":"bytes32"}],"internalType":"struct IRewardsCoordinatorTypes.EarnerTreeMerkleLeaf","name":"leaf","type":"tuple"}],"name":"calculateEarnerLeafHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"pure","type":"function"},{"inputs":[{"components":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"uint256","name":"cumulativeEarnings","type":"uint256"}],"internalType":"struct IRewardsCoordinatorTypes.TokenTreeMerkleLeaf","name":"leaf","type":"tuple"}],"name":"calculateTokenLeafHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"pure","type":"function"},{"inputs":[{"components":[{"internalType":"uint32","name":"rootIndex","type":"uint32"},{"internalType":"uint32","name":"earnerIndex","type":"uint32"},{"internalType":"bytes","name":"earnerTreeProof","type":"bytes"},{"components":[{"internalType":"address","name":"earner","type":"address"},{"internalType":"bytes32","name":"earnerTokenRoot","type":"bytes32"}],"internalType":"struct IRewardsCoordinatorTypes.EarnerTreeMerkleLeaf","name":"earnerLeaf","type":"tuple"},{"internalType":"uint32[]","name":"tokenIndices","type":"uint32[]"},{"internalType":"bytes[]","name":"tokenTreeProofs","type":"bytes[]"},{"components":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"uint256","name":"cumulativeEarnings","type":"uint256"}],"internalType":"struct IRewardsCoordinatorTypes.TokenTreeMerkleLeaf[]","name":"tokenLeaves","type":"tuple[]"}],"internalType":"struct IRewardsCoordinatorTypes.RewardsMerkleClaim","name":"claim","type":"tuple"}],"name":"checkClaim","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"earner","type":"address"}],"name":"claimerFor","outputs":[{"internalType":"address","name":"claimer","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"components":[{"internalType":"contract IStrategy","name":"strategy","type":"address"},{"internalType":"uint96","name":"multiplier","type":"uint96"}],"internalType":"struct IRewardsCoordinatorTypes.StrategyAndMultiplier[]","name":"strategiesAndMultipliers","type":"tuple[]"},{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint32","name":"startTimestamp","type":"uint32"},{"internalType":"uint32","name":"duration","type":"uint32"}],"internalType":"struct IRewardsCoordinatorTypes.RewardsSubmission[]","name":"rewardsSubmissions","type":"tuple[]"}],"name":"createAVSRewardsSubmission","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"avs","type":"address"},{"components":[{"components":[{"internalType":"contract IStrategy","name":"strategy","type":"address"},{"internalType":"uint96","name":"multiplier","type":"uint96"}],"internalType":"struct IRewardsCoordinatorTypes.StrategyAndMultiplier[]","name":"strategiesAndMultipliers","type":"tuple[]"},{"internalType":"contract IERC20","name":"token","type":"address"},{"components":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct IRewardsCoordinatorTypes.OperatorReward[]","name":"operatorRewards","type":"tuple[]"},{"internalType":"uint32","name":"startTimestamp","type":"uint32"},{"internalType":"uint32","name":"duration","type":"uint32"},{"internalType":"string","name":"description","type":"string"}],"internalType":"struct IRewardsCoordinatorTypes.OperatorDirectedRewardsSubmission[]","name":"operatorDirectedRewardsSubmissions","type":"tuple[]"}],"name":"createOperatorDirectedAVSRewardsSubmission","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"avs","type":"address"},{"internalType":"uint32","name":"id","type":"uint32"}],"internalType":"struct OperatorSet","name":"operatorSet","type":"tuple"},{"components":[{"components":[{"internalType":"contract IStrategy","name":"strategy","type":"address"},{"internalType":"uint96","name":"multiplier","type":"uint96"}],"internalType":"struct IRewardsCoordinatorTypes.StrategyAndMultiplier[]","name":"strategiesAndMultipliers","type":"tuple[]"},{"internalType":"contract IERC20","name":"token","type":"address"},{"components":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct IRewardsCoordinatorTypes.OperatorReward[]","name":"operatorRewards","type":"tuple[]"},{"internalType":"uint32","name":"startTimestamp","type":"uint32"},{"internalType":"uint32","name":"duration","type":"uint32"},{"internalType":"string","name":"description","type":"string"}],"internalType":"struct IRewardsCoordinatorTypes.OperatorDirectedRewardsSubmission[]","name":"operatorDirectedRewardsSubmissions","type":"tuple[]"}],"name":"createOperatorDirectedOperatorSetRewardsSubmission","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"components":[{"internalType":"contract IStrategy","name":"strategy","type":"address"},{"internalType":"uint96","name":"multiplier","type":"uint96"}],"internalType":"struct IRewardsCoordinatorTypes.StrategyAndMultiplier[]","name":"strategiesAndMultipliers","type":"tuple[]"},{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint32","name":"startTimestamp","type":"uint32"},{"internalType":"uint32","name":"duration","type":"uint32"}],"internalType":"struct IRewardsCoordinatorTypes.RewardsSubmission[]","name":"rewardsSubmissions","type":"tuple[]"}],"name":"createRewardsForAllEarners","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"components":[{"internalType":"contract IStrategy","name":"strategy","type":"address"},{"internalType":"uint96","name":"multiplier","type":"uint96"}],"internalType":"struct IRewardsCoordinatorTypes.StrategyAndMultiplier[]","name":"strategiesAndMultipliers","type":"tuple[]"},{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint32","name":"startTimestamp","type":"uint32"},{"internalType":"uint32","name":"duration","type":"uint32"}],"internalType":"struct IRewardsCoordinatorTypes.RewardsSubmission[]","name":"rewardsSubmissions","type":"tuple[]"}],"name":"createRewardsForAllSubmission","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"earner","type":"address"},{"internalType":"contract IERC20","name":"token","type":"address"}],"name":"cumulativeClaimed","outputs":[{"internalType":"uint256","name":"totalClaimed","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currRewardsCalculationEndTimestamp","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"defaultOperatorSplitBips","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"delegationManager","outputs":[{"internalType":"contract IDelegationManager","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"rootIndex","type":"uint32"}],"name":"disableRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getCurrentClaimableDistributionRoot","outputs":[{"components":[{"internalType":"bytes32","name":"root","type":"bytes32"},{"internalType":"uint32","name":"rewardsCalculationEndTimestamp","type":"uint32"},{"internalType":"uint32","name":"activatedAt","type":"uint32"},{"internalType":"bool","name":"disabled","type":"bool"}],"internalType":"struct IRewardsCoordinatorTypes.DistributionRoot","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCurrentDistributionRoot","outputs":[{"components":[{"internalType":"bytes32","name":"root","type":"bytes32"},{"internalType":"uint32","name":"rewardsCalculationEndTimestamp","type":"uint32"},{"internalType":"uint32","name":"activatedAt","type":"uint32"},{"internalType":"bool","name":"disabled","type":"bool"}],"internalType":"struct IRewardsCoordinatorTypes.DistributionRoot","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getDistributionRootAtIndex","outputs":[{"components":[{"internalType":"bytes32","name":"root","type":"bytes32"},{"internalType":"uint32","name":"rewardsCalculationEndTimestamp","type":"uint32"},{"internalType":"uint32","name":"activatedAt","type":"uint32"},{"internalType":"bool","name":"disabled","type":"bool"}],"internalType":"struct IRewardsCoordinatorTypes.DistributionRoot","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getDistributionRootsLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"avs","type":"address"}],"name":"getOperatorAVSSplit","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"getOperatorPISplit","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"components":[{"internalType":"address","name":"avs","type":"address"},{"internalType":"uint32","name":"id","type":"uint32"}],"internalType":"struct OperatorSet","name":"operatorSet","type":"tuple"}],"name":"getOperatorSetSplit","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"rootHash","type":"bytes32"}],"name":"getRootIndexFromHash","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"initialOwner","type":"address"},{"internalType":"uint256","name":"initialPausedStatus","type":"uint256"},{"internalType":"address","name":"_rewardsUpdater","type":"address"},{"internalType":"uint32","name":"_activationDelay","type":"uint32"},{"internalType":"uint16","name":"_defaultSplitBips","type":"uint16"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"avs","type":"address"},{"internalType":"bytes32","name":"hash","type":"bytes32"}],"name":"isAVSRewardsSubmissionHash","outputs":[{"internalType":"bool","name":"valid","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"avs","type":"address"},{"internalType":"bytes32","name":"hash","type":"bytes32"}],"name":"isOperatorDirectedAVSRewardsSubmissionHash","outputs":[{"internalType":"bool","name":"valid","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"avs","type":"address"},{"internalType":"bytes32","name":"hash","type":"bytes32"}],"name":"isOperatorDirectedOperatorSetRewardsSubmissionHash","outputs":[{"internalType":"bool","name":"valid","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"submitter","type":"address"}],"name":"isRewardsForAllSubmitter","outputs":[{"internalType":"bool","name":"valid","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"avs","type":"address"},{"internalType":"bytes32","name":"hash","type":"bytes32"}],"name":"isRewardsSubmissionForAllEarnersHash","outputs":[{"internalType":"bool","name":"valid","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"avs","type":"address"},{"internalType":"bytes32","name":"hash","type":"bytes32"}],"name":"isRewardsSubmissionForAllHash","outputs":[{"internalType":"bool","name":"valid","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"newPausedStatus","type":"uint256"}],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"pauseAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint8","name":"index","type":"uint8"}],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pauserRegistry","outputs":[{"internalType":"contract IPauserRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"permissionController","outputs":[{"internalType":"contract IPermissionController","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint32","name":"rootIndex","type":"uint32"},{"internalType":"uint32","name":"earnerIndex","type":"uint32"},{"internalType":"bytes","name":"earnerTreeProof","type":"bytes"},{"components":[{"internalType":"address","name":"earner","type":"address"},{"internalType":"bytes32","name":"earnerTokenRoot","type":"bytes32"}],"internalType":"struct IRewardsCoordinatorTypes.EarnerTreeMerkleLeaf","name":"earnerLeaf","type":"tuple"},{"internalType":"uint32[]","name":"tokenIndices","type":"uint32[]"},{"internalType":"bytes[]","name":"tokenTreeProofs","type":"bytes[]"},{"components":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"uint256","name":"cumulativeEarnings","type":"uint256"}],"internalType":"struct IRewardsCoordinatorTypes.TokenTreeMerkleLeaf[]","name":"tokenLeaves","type":"tuple[]"}],"internalType":"struct IRewardsCoordinatorTypes.RewardsMerkleClaim","name":"claim","type":"tuple"},{"internalType":"address","name":"recipient","type":"address"}],"name":"processClaim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint32","name":"rootIndex","type":"uint32"},{"internalType":"uint32","name":"earnerIndex","type":"uint32"},{"internalType":"bytes","name":"earnerTreeProof","type":"bytes"},{"components":[{"internalType":"address","name":"earner","type":"address"},{"internalType":"bytes32","name":"earnerTokenRoot","type":"bytes32"}],"internalType":"struct IRewardsCoordinatorTypes.EarnerTreeMerkleLeaf","name":"earnerLeaf","type":"tuple"},{"internalType":"uint32[]","name":"tokenIndices","type":"uint32[]"},{"internalType":"bytes[]","name":"tokenTreeProofs","type":"bytes[]"},{"components":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"uint256","name":"cumulativeEarnings","type":"uint256"}],"internalType":"struct IRewardsCoordinatorTypes.TokenTreeMerkleLeaf[]","name":"tokenLeaves","type":"tuple[]"}],"internalType":"struct IRewardsCoordinatorTypes.RewardsMerkleClaim[]","name":"claims","type":"tuple[]"},{"internalType":"address","name":"recipient","type":"address"}],"name":"processClaims","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardsUpdater","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"_activationDelay","type":"uint32"}],"name":"setActivationDelay","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"claimer","type":"address"}],"name":"setClaimerFor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"earner","type":"address"},{"internalType":"address","name":"claimer","type":"address"}],"name":"setClaimerFor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"split","type":"uint16"}],"name":"setDefaultOperatorSplit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"avs","type":"address"},{"internalType":"uint16","name":"split","type":"uint16"}],"name":"setOperatorAVSSplit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint16","name":"split","type":"uint16"}],"name":"setOperatorPISplit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"components":[{"internalType":"address","name":"avs","type":"address"},{"internalType":"uint32","name":"id","type":"uint32"}],"internalType":"struct OperatorSet","name":"operatorSet","type":"tuple"},{"internalType":"uint16","name":"split","type":"uint16"}],"name":"setOperatorSetSplit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_submitter","type":"address"},{"internalType":"bool","name":"_newValue","type":"bool"}],"name":"setRewardsForAllSubmitter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_rewardsUpdater","type":"address"}],"name":"setRewardsUpdater","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"strategyManager","outputs":[{"internalType":"contract IStrategyManager","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"avs","type":"address"}],"name":"submissionNonce","outputs":[{"internalType":"uint256","name":"nonce","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"root","type":"bytes32"},{"internalType":"uint32","name":"rewardsCalculationEndTimestamp","type":"uint32"}],"name":"submitRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newPausedStatus","type":"uint256"}],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

00000000000000000000000039053d51b77dc0d36036fc1fcc8cb819df8ef37a000000000000000000000000858646372cc42e1a627fce94aa7a7033e7cf075a000000000000000000000000948a420b8cc1d6bfd0b6087c2e7c344a2cd0bc39000000000000000000000000b8765ed72235d279c3fb53936e4606db0ef1280600000000000000000000000025e5f8b1e7adf44518d35d5b2271f114e081f0e5000000000000000000000000000000000000000000000000000000000001518000000000000000000000000000000000000000000000000000000000005c49000000000000000000000000000000000000000000000000000000000000dd7c000000000000000000000000000000000000000000000000000000000000278d000000000000000000000000000000000000000000000000000000000065fb7880

-----Decoded View---------------
Arg [0] : params (tuple): 
     Arg [1] : delegationManager (address): 0x39053D51B77DC0d36036Fc1fCc8Cb819df8Ef37A
     Arg [2] : strategyManager (address): 0x858646372CC42E1A627fcE94aa7A7033e7CF075A
     Arg [3] : allocationManager (address): 0x948a420b8CC1d6BFd0B6087C2E7c344a2CD0bc39
     Arg [4] : pauserRegistry (address): 0xB8765ed72235d279c3Fb53936E4606db0Ef12806
     Arg [5] : permissionController (address): 0x25E5F8B1E7aDf44518d35D5B2271f114e081f0E5
     Arg [6] : CALCULATION_INTERVAL_SECONDS (uint32): 86400
     Arg [7] : MAX_REWARDS_DURATION (uint32): 6048000
     Arg [8] : MAX_RETROACTIVE_LENGTH (uint32): 14515200
     Arg [9] : MAX_FUTURE_LENGTH (uint32): 2592000
     Arg [10] : GENESIS_REWARDS_TIMESTAMP (uint32): 1710979200


-----Encoded View---------------
10 Constructor Arguments found :
Arg [0] : 00000000000000000000000039053d51b77dc0d36036fc1fcc8cb819df8ef37a
Arg [1] : 000000000000000000000000858646372cc42e1a627fce94aa7a7033e7cf075a
Arg [2] : 000000000000000000000000948a420b8cc1d6bfd0b6087c2e7c344a2cd0bc39
Arg [3] : 000000000000000000000000b8765ed72235d279c3fb53936e4606db0ef12806
Arg [4] : 00000000000000000000000025e5f8b1e7adf44518d35d5b2271f114e081f0e5
Arg [5] : 0000000000000000000000000000000000000000000000000000000000015180
Arg [6] : 00000000000000000000000000000000000000000000000000000000005c4900
Arg [7] : 0000000000000000000000000000000000000000000000000000000000dd7c00
Arg [8] : 0000000000000000000000000000000000000000000000000000000000278d00
Arg [9] : 0000000000000000000000000000000000000000000000000000000065fb7880