Cryo Explorer Ethereum Mainnet

/* SPDX-License-Identifier: UNLICENSED */
pragma solidity ^0.8.0;

import './utils/Withdrawable.sol';
import './utils/IWETH.sol';


/// @title ITBContract contract that implements common owner only functions accross all strategies
/// @author IntoTheBlock Corp
/// @dev Abstract
abstract contract ITBContract is Withdrawable {
    using SafeERC20 for IERC20;
    event ApproveToken(address indexed token, address guy, uint256 wad);
    address payable immutable public WNATIVE;

    uint constant ONE = 1e18;

    /// @param _executors Executor addresses
    constructor(address[] memory _executors, address payable _wnative) Executable(_executors) {
        WNATIVE = _wnative;
    }

    function _percentageAmount(uint _amount, uint _percentage) internal pure returns (uint) {
        return _amount * _percentage / ONE;
    }

    /// @notice Set allowance for a given token, amount and spender
    /// @param _token Token to spend
    /// @param _guy Spender
    /// @param _wad Max amount to spend
    function _approveToken(address _token, address _guy, uint256 _wad) internal {
        if (_wad != 0) {
            if (IERC20(_token).allowance(address(this), _guy) >= _wad)
                return;
            IERC20(_token).safeApprove(_guy, 0);
        }
        IERC20(_token).safeApprove(_guy, _wad);
        emit ApproveToken(_token, _guy, _wad);
    }

    /// @notice Check current allowance and, if necessary, set it to a new amount for a given token, amount and spender
    /// @param _token Token to spend
    /// @param _guy Spender
    /// @param _amount New max amount to spend
    function _checkAllowanceAndApprove(address _token, address _guy, uint256 _amount) internal {
        if (IERC20(_token).allowance(address(this), _guy) < _amount)
            _approveToken(_token, _guy, type(uint256).max);
    }

    /// @notice Only owner. Set allowance for a given token, amount and spender
    /// @param _token Token to spend
    /// @param _guy Spender
    /// @param _wad Max amount to spend
    function approveToken(address _token, address _guy, uint256 _wad) external onlyOwner {
        _approveToken(_token, _guy, _wad);
    }

    /// @notice Only owner. Revoke allowance for a given token and spender
    /// @param _token Token to spend
    /// @param _guy Spender
    function revokeToken(address _token, address _guy) external onlyOwner {
        _approveToken(_token, _guy, 0);
    }

    /// @notice Only owner. Execute an arbitrary call
    /// @param _to Target address
    /// @param _value Value (i. e. msg.value)
    /// @param _data Invocation data
    function execute(address _to, uint256 _value, bytes calldata _data) external payable onlyOwner {
        (bool success, bytes memory returnData) = _to.call{ value: _value }(_data);
        require(success, string(returnData));
    }

    /// @notice Only owner. Execute multiple arbitrary calls in order
    /// @param _tos Target address for each call
    /// @param _values Value for each call (i. e. msg.value)
    /// @param _datas Invocation data for each call
    function batchExecute(address[] calldata _tos, uint256[] calldata _values, bytes[] calldata _datas) external payable onlyOwner {
        require(_tos.length == _values.length && _tos.length == _datas.length, "Arguments length mismatch");
        for (uint256 i = 0; i < _tos.length; i++) {
            (bool success, bytes memory returnData) = _tos[i].call{ value: _values[i] }(_datas[i]);
            require(success, string(returnData));
        }
    }

    function wrapNative(uint256 _amount) public onlyExecutor {
        IWETH(WNATIVE).deposit{ value: _amount }();
    }

    function unwrapNative(uint256 _amount) public onlyExecutor {
        IWETH(WNATIVE).withdraw(_amount);
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/access/Ownable2Step.sol";

/// @title Base contract that implements executor related functions
/// @author IntoTheBlock Corp
/// @dev Abstract
abstract contract Executable is Ownable2Step {
    mapping(address => bool) public executors;

    event ExecutorUpdated(address indexed executor, bool enabled);

    /// @param _executors Initial whitelisted executor addresses
    constructor(address[] memory _executors) {
        for (uint256 i = 0; i < _executors.length; i++) {
            addExecutor(_executors[i]);
        }
    }

    /// @notice Revert if call is not being made from the owner or an executor
    modifier onlyExecutor() {
        require(owner() == msg.sender || executors[msg.sender], "Executable: caller is not the executor");
        _;
    }

    /// @notice Only owner. Add an executor
    /// @param _executor New executor address
    function addExecutor(address _executor) public onlyOwner {
        emit ExecutorUpdated(_executor, true);
        executors[_executor] = true;
    }

    /// @notice Only owner. Remove an executor
    /// @param _executor Executor address to remove
    function removeExecutor(address _executor) external onlyOwner {
        emit ExecutorUpdated(_executor, false);
        executors[_executor] = false;
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;

interface IWETH {
    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);

    event Approval(address indexed src, address indexed guy, uint256 wad);
    event Transfer(address indexed src, address indexed dst, uint256 wad);
    event Deposit(address indexed dst, uint256 wad);
    event Withdrawal(address indexed src, uint256 wad);

    function balanceOf(address) external view returns (uint256);
    function allowance(address, address) external view returns (uint256);

    fallback() external payable;
    receive() external payable;
    function deposit() external payable;
    function withdraw(uint256 wad) external;
    function totalSupply() external view returns (uint256);
    function approve(address guy, uint256 wad) external returns (bool);
    function transfer(address dst, uint256 wad) external returns (bool);
    function transferFrom(address src, address dst, uint256 wad) external returns (bool);
}

/* SPDX-License-Identifier: UNLICENSED */
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/access/Ownable2Step.sol";

abstract contract Ownable2StepWithShortcut is Ownable2Step {
    function transferOwnership1Step(address newOwner) public onlyOwner {
        require(newOwner != address(0), "ITBOwnable: zero address");
        _transferOwnership(newOwner);
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import './Executable.sol';

/**
    Ensures that any contract that inherits from this contract is able to
    withdraw funds that are accidentally received or stuck.
 */

/// @title Base contract that implements withdrawal related functions
/// @author IntoTheBlock Corp
/// @dev Abstract
abstract contract Withdrawable is Executable {
    using SafeERC20 for IERC20;
    address constant ETHER = address(0);

    event LogWithdraw(
        address indexed _to,
        address indexed _asset_address,
        uint256 amount
    );

    receive() external payable {}

    /// @notice ERC20 or ETH balance of this contract given a token address
    /// @param _asset_address Token address or address(0) for ETH
    /// @return Balance    
    function _balance(address _asset_address) internal view returns (uint256) {
        return _asset_address == ETHER ? address(this).balance : _erc20Balance(_asset_address);
    }

    function _erc20Balance(address _asset_address) internal view returns (uint256) {
        return IERC20(_asset_address).balanceOf(address(this));
    }
    
    /// @notice ERC20 balance of given account
    /// @param _asset_address Token address 
    /// @param _account Account address 
    /// @return Balance  
    function balanceOf(address _asset_address, address _account) public view returns (uint256) {
        return IERC20(_asset_address).balanceOf(_account);
    }

    /// @notice Send the given amount of the given token or ETH to the given receiver
    /// @param _asset_address Token address or address(0) for ETH
    /// @param _amount Amount to send
    /// @param _to Receiver address
    function _withdraw_to(address _asset_address, uint256 _amount, address payable _to) internal {
        require(_to != address(0), 'Invalid address');
        uint256 balance = _balance(_asset_address);
        require(balance >= _amount, 'Insufficient funds');
        if (_asset_address == ETHER) {
            (bool success, ) = _to.call{value: _amount}(''); /* carry gas over so it works with contracts with custom fallback, we dont care about reentrancy on onlyOwner */
            require(success, 'Native transfer failed.');
        } else
            IERC20(_asset_address).safeTransfer(_to, _amount);
        emit LogWithdraw(_to, _asset_address, _amount);
    }

    /// @notice Only owner. Send the given amount of the given token or ETH to the caller
    /// @param _asset_address Token address or address(0) for ETH
    /// @param _amount Amount to send
    function withdraw(address _asset_address, uint256 _amount) external onlyOwner {
        _withdraw_to(_asset_address, _amount, payable(msg.sender));
    }

    /// @notice Only owner. Send the given amount of the given token or ETH to the given receiver
    /// @param _asset_address Token address or address(0) for ETH
    /// @param _amount Amount to send
    /// @param _to Receiver address
    function withdrawTo(address _asset_address, uint256 _amount, address payable _to) external onlyOwner {
        _withdraw_to(_asset_address, _amount, _to);
    }

    /// @notice Only owner. Send its entire balance of the given token or ETH to the caller
    /// @param _asset_address Token address or address(0) for ETH
    function withdrawAll(address _asset_address) external onlyOwner {
        uint256 balance = _balance(_asset_address);
        _withdraw_to(_asset_address, balance, payable(msg.sender));
    }

    /// @notice Only owner. Send its entire balance of the given token or ETH to the given receiver
    /// @param _asset_address Token address or address(0) for ETH
    /// @param _to Receiver address
    function withdrawAllTo(address _asset_address, address payable _to) external onlyOwner {
        uint256 balance = _balance(_asset_address);
        _withdraw_to(_asset_address, balance, _to);
    }
}

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

pragma solidity ^0.8.0;

import "../utils/Context.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 Ownable is Context {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _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);
    }
}

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

pragma solidity ^0.8.0;

import "./Ownable.sol";

/**
 * @dev Contract module which provides 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} and {acceptOwnership}.
 *
 * This module is used through inheritance. It will make available all functions
 * from parent (Ownable).
 */
abstract contract Ownable2Step is Ownable {
    address private _pendingOwner;

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

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

    /**
     * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual override onlyOwner {
        _pendingOwner = newOwner;
        emit OwnershipTransferStarted(owner(), newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual override {
        delete _pendingOwner;
        super._transferOwnership(newOwner);
    }

    /**
     * @dev The new owner accepts the ownership transfer.
     */
    function acceptOwnership() public virtual {
        address sender = _msgSender();
        require(pendingOwner() == sender, "Ownable2Step: caller is not the new owner");
        _transferOwnership(sender);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.4) (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.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
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].
     *
     * CAUTION: See Security Considerations above.
     */
    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) (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.3) (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. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    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
// 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: MIT
// OpenZeppelin Contracts (last updated v4.9.4) (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @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 Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

/* SPDX-License-Identifier: UNLICENSED */
pragma solidity 0.8.15;

interface IAllocationManager {
  function getMaxMagnitude(address operator, address strategy) external view returns (uint64);

  function getMaxMagnitudesAtBlock(address operator, address[] memory strategies, uint32 blockNumber) external view returns (uint64[] memory);
}

/* SPDX-License-Identifier: UNLICENSED */
pragma solidity 0.8.15;

interface IDelegation {

  struct QueuedWithdrawalParams {
      address[] strategies;
      uint256[] shares;
      address withdrawer;
  }

  struct Withdrawal {
      address staker;
      address delegatedTo;
      address withdrawer;
      uint256 nonce;
      uint32 startBlock;
      address[] strategies;
      uint256[] scaledShares;
  } 

  struct SignatureWithExpiry {
    bytes signature;
    uint expiry;
  }

  function queueWithdrawals(QueuedWithdrawalParams[] memory) external returns (bytes32[] memory shares);
  
  function minWithdrawalDelayBlocks() external view returns (uint256);

  function delegatedTo(address) external view returns (address);
  
  function delegateTo(address, SignatureWithExpiry memory, bytes32) external;

  function undelegate(address) external returns (bytes32[] memory);
  
  function cumulativeWithdrawalsQueued(address) external view returns (uint);

  function completeQueuedWithdrawal(Withdrawal memory, address[] memory, bool) external;

  function calculateWithdrawalRoot(Withdrawal memory) external pure returns (bytes32);

  function pendingWithdrawals(bytes32) external view returns (bool); 

  function delegationApprover(address operator) external view returns (address);

  function getQueuedWithdrawals(address staker) external view returns (Withdrawal[] memory withdrawals, uint256[][] memory shares);

  function getWithdrawableShares(address staker, address[] memory strategies) external view returns (uint256[] memory withdrawableShares, uint256[] memory depositShares);

  function allocationManager() external view returns (address);

  function isOperator(address operator) external view returns (bool);

  function calculateDelegationApprovalDigestHash(address staker, address operator, address approver, bytes32 approverSalt, uint256 expiry) external view returns (bytes32);
}

/* SPDX-License-Identifier: UNLICENSED */
pragma solidity 0.8.15;

interface ILiquidStaking {

  function sharesToUnderlying(uint) external view returns (uint256 shares);

  function shares(address) external view returns (uint256 shares);
  
  function totalShares() external view returns (uint256);

  function underlyingToken() external view returns (address);
  
}

/* SPDX-License-Identifier: UNLICENSED */
pragma solidity 0.8.15;

/**
 * @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 {
    /// STRUCTS ///
    /**
     * @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 {
        address strategy;
        uint96 multiplier;
    }

    /**
     * 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;
        address token;
        uint256 amount;
        uint32 startTimestamp;
        uint32 duration;
    }

    /**
     * @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 {
        address 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;
    }

    /// EVENTS ///

    /// @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 rewardsUpdater is responsible for submiting 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 GlobalCommissionBipsSet(uint16 oldGlobalCommissionBips, uint16 newGlobalCommissionBips);
    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,
        address token,
        uint256 claimedAmount
    );

    /**
     *
     *                         VIEW FUNCTIONS
     *
     */

    /// @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);

    /// @notice Delay in timestamp (seconds) before a posted root can be claimed against
    function activationDelay() 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, address token) external view returns (uint256);

    /// @notice the commission for all operators across all avss
    function globalOperatorCommissionBips() external view returns (uint16);

    /// @notice the commission for a specific operator for a specific avs
    /// NOTE: Currently unused and simply returns the globalOperatorCommissionBips value but will be used in future release
    function operatorCommissionBips(address operator, address avs) 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 The timestamp until which RewardsSubmissions have been calculated
    function currRewardsCalculationEndTimestamp() external view returns (uint32);

    /// @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);

    /**
     *
     *                         EXTERNAL FUNCTIONS
     *
     */

    /**
     * @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 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.
     */
    function createRewardsForAllSubmission(RewardsSubmission[] calldata rewardsSubmission) 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 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 Creates a new distribution root. activatedAt is set to block.timestamp + activationDelay
     * @param root The merkle root of the distribution
     * @param rewardsCalculationEndTimestamp The timestamp (seconds) 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 behalf of the earner (msg.sender)
     * @param claimer The address of the entity that can claim rewards on behalf of the earner
     * @dev Only callable by the `earner`
     */
    function setClaimerFor(address claimer) external;

    /**
     * @notice Sets the delay in timestamp before a posted root can be claimed against
     * @param _activationDelay Delay in timestamp (seconds) before a posted root can be claimed against
     * @dev Only callable by the contract owner
     */
    function setActivationDelay(uint32 _activationDelay) external;

    /**
     * @notice Sets the global commission for all operators across all avss
     * @param _globalCommissionBips The commission for all operators across all avss
     * @dev Only callable by the contract owner
     */
    function setGlobalOperatorCommission(uint16 _globalCommissionBips) external;

    /**
     * @notice Sets the permissioned `rewardsUpdater` address which can post new roots
     * @dev Only callable by the contract owner
     */
    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;
}

/* SPDX-License-Identifier: UNLICENSED */
pragma solidity 0.8.15;

interface IStrategyManager {

  function depositIntoStrategy(address strategy, address token, uint256 amount) external returns (uint256 shares);

}

/* SPDX-License-Identifier: UNLICENSED */
pragma solidity 0.8.15;

import '@itb/quant-common/contracts/solidity8/ITBContract.sol';
import './interfaces/IStrategyManager.sol';
import './interfaces/ILiquidStaking.sol';
import './interfaces/IDelegation.sol';
import './interfaces/IAllocationManager.sol';
import './interfaces/IRewardsCoordinator.sol';

/// @title PositionManager for EigenLayer
/// @author IntoTheBlock Corp
contract PositionManager is ITBContract {
    uint64 constant WAD = 1e18;

    struct PositionConfig {
        address liquid_staking;
        address underlying;
        address delegate_to;
    }

    struct QueuedWithdrawal {
        uint withdrawal_block;
        address[] tokens;
        IDelegation.Withdrawal withdrawal;
    }

    event Deposit(address indexed caller, address token, uint amount, uint lpt_change);
    event StartWithdrawal(address indexed caller, address token, uint withdrawal_nonce, uint withdrawal_index, uint start_block, uint withdrawal_block, uint lpt_amount);
    event Withdraw(address indexed caller, address token, uint withdrawal_nonce, uint withdrawal_index, uint amount, uint lpt_change);

    event Assemble(address indexed caller, address[] tokens, uint[] amounts, uint lpt_change);
    event Disassemble(address indexed caller, address[] tokens, uint[] amounts, uint lpt_change);
    event UpdateStrategyManager(address indexed caller, address strategy_manager);
    event UpdateDelegationManager(address indexed caller, address delegation_manager);
    event UpdateRewardsCoordinator(address indexed caller, address rewards_coordinator);
    event UpdatePositionConfig(address indexed caller, address liquid_staking, address underlying, address delegate_to);

    PositionConfig public positionConfig;
    
    IStrategyManager public strategyManager;
    IDelegation public delegationManager;
    IRewardsCoordinator public rewardsCoordinator;

    mapping(uint => QueuedWithdrawal) public withdrawalQueue;
    uint public cumulativeWithdrawalsQueued;
    uint public indexNextWithdrawal;

    function VERSION() external pure returns (string memory) {
        return "1.0.0";
    }

    constructor(address[] memory _executors, address payable _wnative, address _strategy_manager, address _delegation_manager, address _rewards_coordinator, address _liquid_staking, address _underlying, address _delegate_to) ITBContract(_executors, _wnative) {
        updateStrategyManager(_strategy_manager);
        updateDelegationManager(_delegation_manager);
        updateRewardsCoordinator(_rewards_coordinator);
        updatePositionConfig(_liquid_staking, _underlying, _delegate_to);
        if (_delegate_to != address(0))
            delegate();
    }

    /// @notice Only owner. Updates the strategy manager, responsible of deposits
    /// @param _strategy_manager Address of the strategy manager
    function updateStrategyManager(address _strategy_manager) public onlyOwner {
        strategyManager = IStrategyManager(_strategy_manager);
        emit UpdateStrategyManager(msg.sender, _strategy_manager);
    }

    /// @notice Only owner. Updates the delegation manager, responsible of withdrawals and delegation
    /// @param _delegation_manager Address of the delegation manager
    function updateDelegationManager(address _delegation_manager) public onlyOwner {
        delegationManager = IDelegation(_delegation_manager);
        emit UpdateDelegationManager(msg.sender, _delegation_manager);
    }

    /// @notice Only owner. Updates the rewards coordinator
    /// @param _rewards_coordinator Address of the rewards coordinator
    function updateRewardsCoordinator(address _rewards_coordinator) public onlyOwner {
        rewardsCoordinator = IRewardsCoordinator(_rewards_coordinator);
        emit UpdateRewardsCoordinator(msg.sender, _rewards_coordinator);
    }

    /// @notice Only owner. Updates the position config
    /// @param _liquid_staking Address of the liquid staking contract to deposit into
    /// @param _underlying Address of the underlying token
    /// @param _delegate_to Address of the operator to delegate to
    function updatePositionConfig(address _liquid_staking, address _underlying, address _delegate_to) public onlyOwner {
        require(ILiquidStaking(_liquid_staking).underlyingToken() == _underlying, 'PC1');
        require(_delegate_to == address(0) || delegationManager.isOperator(_delegate_to), 'PC2');
        positionConfig = PositionConfig(
            _liquid_staking,
            _underlying,
            _delegate_to
        );
        emit UpdatePositionConfig(msg.sender, _liquid_staking, _underlying, _delegate_to);
    }

    modifier hasConfig() {
        require(positionConfig.liquid_staking != address(0), 'A3'); // position_config is missing
        _;
    }

    function _strategies() internal view returns (address[] memory strategies) {
        strategies = new address[](1);
        strategies[0] = positionConfig.liquid_staking;
    }

    /// @notice Returns the queued amount of shares for the given withdrawal after slashing
    /// @param queued_withdrawal Queued withdrawal to check
    /// @return Amount of shares after slashing
    function _scaledSharesWithSlashing(QueuedWithdrawal memory queued_withdrawal) internal view returns (uint) {
        address allocation_manager = delegationManager.allocationManager();
        uint64[] memory magnitude_at_completion = IAllocationManager(allocation_manager).getMaxMagnitudesAtBlock(queued_withdrawal.withdrawal.delegatedTo, _strategies(), uint32(queued_withdrawal.withdrawal_block));
        return queued_withdrawal.withdrawal.scaledShares[0] * magnitude_at_completion[0] / WAD;
    }

    /// @notice Get the withdrawal delay
    /// @return Withdrawal delay in blocks
    function getWithdrawalDelay() public view returns (uint) {
        return delegationManager.minWithdrawalDelayBlocks();
    }

    /// @notice Get underlyings addresses
    /// @return All underlying assets
    function getPositionAssets() public view returns (address[] memory) {
        address[] memory assets = new address[](1);
        assets[0] = positionConfig.underlying;
        return assets;
    }

    /// @notice Get underlyings addresses and amounts
    /// @return assets all underlying assets
    /// @return amounts amounts of all underlying assets
    function getUnderlyings() external view returns (address[] memory assets, uint[] memory amounts) {
        address[] memory tokens = getPositionAssets();
        uint[] memory balances = new uint[](tokens.length);
        balances[0] = ILiquidStaking(positionConfig.liquid_staking).sharesToUnderlying(getTotalLPT());
        return (tokens, balances);
    }

    /// @notice Get the withdrawable and deposited shares
    /// @return Amount of shares that can be withdrawn
    /// @return Amount of shares that were originally deposited
    function getLPTWithdrawableAndDeposited() public view returns (uint, uint) {
        (uint[] memory withdrawable, uint[] memory deposited) = delegationManager.getWithdrawableShares(address(this), _strategies());
        return (withdrawable[0], deposited[0]);
    }

    /// @notice Get the shares staked into the liquid staking contract
    /// @return withdrawable Amount of shares that can be withdrawn
    function getLPTStaked() public view returns (uint withdrawable) {
        (withdrawable, ) = getLPTWithdrawableAndDeposited();
    }

    /// @notice Get the total shares deposited into the liquid staking contract
    /// @return deposited Amount of shares that were originally deposited
    function getLPTDeposited() public view returns (uint deposited) {
        (, deposited) = getLPTWithdrawableAndDeposited();
    }

    /// @notice Get the total shares pending withdrawal accounting for slashing
    /// @return amount_pending Total shares pending withdrawal accounting for slashing
    function lptPendingOfWithdraw() public view returns (uint amount_pending) {
        for (uint i = indexNextWithdrawal; i < cumulativeWithdrawalsQueued; i++)
            amount_pending += _scaledSharesWithSlashing(withdrawalQueue[i]);
    }

    /// @notice Get total shares (active and pending withdrawal) accounting for slashing
    /// @return Total shares accounting for slashing
    function getTotalLPT() public view returns (uint) {
        return getLPTStaked() + lptPendingOfWithdraw();
    }

    /// @notice Check if there are any withdrawals queued
    /// @return True if there are withdrawals queued
    function haveWithdrawalsQueued() public view returns (bool) {
        return cumulativeWithdrawalsQueued > indexNextWithdrawal;
    }

    /// @notice Check if the given withdrawal index is pending
    /// @param _withdrawal_index Index of the withdrawal to check
    /// @return True if the withdrawal is pending
    function withdrawalIsPending(uint _withdrawal_index) public view returns (bool) {
        bytes32 root = delegationManager.calculateWithdrawalRoot(withdrawalQueue[_withdrawal_index].withdrawal);
        return delegationManager.pendingWithdrawals(root);
    }

    /// @notice Check if the given withdrawal index is ready to be completed
    /// @param _withdrawal_index Index of the withdrawal to check
    /// @return True if the withdrawal is ready
    function withdrawalIsReady(uint _withdrawal_index) public view returns (bool) {
        QueuedWithdrawal memory w = withdrawalQueue[_withdrawal_index];
        return withdrawalIsPending(_withdrawal_index) && block.number >= w.withdrawal_block;
    }

    /// @notice Check if the next queued withdrawal is ready to be completed
    /// @return True if the next withdrawal is ready
    function nextWithdrawalIsReady() public view returns (bool) {
        return withdrawalIsReady(indexNextWithdrawal);
    }

    /// @notice Check if the next queued withdrawal, if any, is ready to be completed
    /// @return True if the next withdrawal is ready
    function canCompleteWithdrawals() public view returns (bool) {
        return haveWithdrawalsQueued() && nextWithdrawalIsReady();
    }

    /// @notice Only executor. Delegate shares to the configured operator which doesnt have an approver
    function delegate() public onlyExecutor hasConfig {
        require(delegationManager.delegationApprover(positionConfig.delegate_to) == address(0), 'DL2');
        _delegate(new bytes(0), 0, bytes32(0));
    }

    /// @notice Only owner. Delegate shares to the configured operator with a signature
    /// @param _signature Signature to delegate
    /// @param _expiry Expiry of the signature
    /// @param _salt Salt to use for the signature
    function delegateWithSignature(bytes memory _signature, uint _expiry, bytes32 _salt) public onlyOwner hasConfig {
        _delegate(_signature, _expiry, _salt);
    }

    /// @notice Delegate shares to the configured operator
    /// @dev If the shared are already delegated, undelegate first
    function _delegate(bytes memory _signature, uint _expiry, bytes32 _salt) internal {
        address delegate_to = positionConfig.delegate_to;
        require(delegate_to != address(0), 'DL1');
        if (delegationManager.delegatedTo(address(this)) != address(0))
            undelegate();
        delegationManager.delegateTo(delegate_to, IDelegation.SignatureWithExpiry(_signature, _expiry), _salt);
    }

    /// @notice Undelegate shares
    function _undelegate() internal { 
        delegationManager.undelegate(address(this));
    }

    /// @notice Only owner. Undelegate shares without waiting for withdrawals
    /// @dev In case owner wants to undelegate without waiting for withdrawals
    function undelegateUnsafe() external onlyOwner {
        _undelegate();
    }

    /// @notice Only executor. Undelegate shares
    function undelegate() public onlyExecutor hasConfig {
        uint lpt = getTotalLPT();
        require(lpt == 0, 'U1');
        _undelegate();
    }

    /// @notice Only executor. Deposits underlying into the liquid staking contract
    /// @param _amount Amount of underlying to deposit
    /// @param _min_lpt_out Minimum amount of shares expected from the deposit
    /// @return lpt_out Amount of shares received from the deposit
    function deposit(uint _amount, uint _min_lpt_out) public onlyExecutor hasConfig returns (uint lpt_out) {
        PositionConfig memory c = positionConfig;

        lpt_out = strategyManager.depositIntoStrategy(c.liquid_staking, c.underlying, _amount);
        require(lpt_out >= _min_lpt_out, 'D1');

        emit Deposit(msg.sender, c.underlying, _amount, lpt_out);
    }
    
    /// @notice Queue the given withdrawals
    /// @param _withdrawal_params Array of withdrawal parameters to queue
    function _queueWithdrawals(IDelegation.QueuedWithdrawalParams[] memory _withdrawal_params) internal {
        delegationManager.queueWithdrawals(_withdrawal_params);
    }

    /// @notice Only owner. Queue the given withdrawals
    /// @dev In case owner wants to manually queue withdrawals
    /// @param _withdrawal_params Array of withdrawal parameters to queue
    function queueWithdrawals(IDelegation.QueuedWithdrawalParams[] memory _withdrawal_params) external onlyOwner {
        _queueWithdrawals(_withdrawal_params);
    }

    /// @notice Only executor. Starts a withdrawal for the given amount of shares
    /// @param _shares_amount Shares amount to withdraw
    function startWithdrawal(uint _shares_amount) public onlyExecutor hasConfig {
        if (_shares_amount == 0)
            return;

        PositionConfig memory c = positionConfig;
        uint nonce = delegationManager.cumulativeWithdrawalsQueued(address(this));
        uint withdrawal_block = block.number + getWithdrawalDelay();
        uint withdrawal_index = cumulativeWithdrawalsQueued;
        cumulativeWithdrawalsQueued++;

        {
            uint[] memory shares = new uint[](1);
            shares[0] = _shares_amount;
            
            IDelegation.QueuedWithdrawalParams[] memory queuedWithdrawalParams = new IDelegation.QueuedWithdrawalParams[](1);
            queuedWithdrawalParams[0] = IDelegation.QueuedWithdrawalParams({
                strategies: _strategies(),
                shares: shares,
                withdrawer: address(this)
            });

            _queueWithdrawals(queuedWithdrawalParams);
        }

        address[] memory tokens = new address[](1);
        tokens[0] = c.underlying;
        (IDelegation.Withdrawal[] memory pending_withdrawals, ) = delegationManager.getQueuedWithdrawals(address(this));
        IDelegation.Withdrawal memory new_withdrawal = pending_withdrawals[pending_withdrawals.length - 1];
        withdrawalQueue[withdrawal_index] = QueuedWithdrawal({
            withdrawal_block: withdrawal_block,
            tokens: tokens,
            withdrawal: new_withdrawal
        });

        emit StartWithdrawal(msg.sender, c.underlying, nonce, withdrawal_index, block.number, withdrawal_block, _shares_amount);
    }

    /// @notice Completes the given queued withdrawal
    /// @param _withdrawal Withdrawal to complete
    /// @param _tokens Tokens to receive
    /// @param _receive_as_tokens If true, the tokens will be received as tokens, otherwise as shares
    function _completeQueuedWithdrawal(IDelegation.Withdrawal memory _withdrawal, address[] memory _tokens, bool _receive_as_tokens) internal {
        delegationManager.completeQueuedWithdrawal(_withdrawal, _tokens, _receive_as_tokens);
    }

    /// @notice Only owner. Completes the given queued withdrawal
    /// @param _withdrawal Withdrawal to complete
    /// @param _tokens Tokens to receive
    /// @param _receive_as_tokens If true, the tokens will be received as tokens, otherwise as shares
    function completeQueuedWithdrawal(IDelegation.Withdrawal memory _withdrawal, address[] memory _tokens, bool _receive_as_tokens) external onlyOwner {
        _completeQueuedWithdrawal(_withdrawal, _tokens, _receive_as_tokens);
    }

    /// @notice Only executor. Completes the pending withdrawal at the given index
    /// @dev Should not be used under normal circumstances, will break withdrawal index flow
    /// @param _withdrawal_index Index of the withdrawal to complete
    /// @param _min_out Minimum amount of underlying expected from the withdrawal
    /// @return lpt_burnt Amount of shares burnt
    /// @return coin_out Amount of underlying received
    function completeWithdrawal(uint _withdrawal_index, uint _min_out) public onlyExecutor hasConfig returns (uint lpt_burnt, uint coin_out) {
        require(withdrawalIsReady(_withdrawal_index), 'W2');

        QueuedWithdrawal memory w = withdrawalQueue[_withdrawal_index];
        address underlying = w.tokens[0];
        uint underlying_before = _balance(underlying);
        
        _completeQueuedWithdrawal(w.withdrawal, w.tokens, true);
        
        lpt_burnt = _scaledSharesWithSlashing(w);
        coin_out = _balance(underlying) - underlying_before;
        require(coin_out >= _min_out, 'W3');

        emit Withdraw(msg.sender, underlying, w.withdrawal.nonce, _withdrawal_index, coin_out, lpt_burnt);
    }

    /// @notice Only executor. Completes the next pending withdrawal
    /// @param _min_out Minimum amount of underlying expected from the withdrawal
    /// @return lpt_burnt Shares burnt from completing the withdrawal
    /// @return coin_out Collateral received after completing the withdrawal
    function completeNextWithdrawal(uint _min_out) public onlyExecutor hasConfig returns (uint lpt_burnt, uint coin_out) {
        uint i = indexNextWithdrawal;
        indexNextWithdrawal++;
        (lpt_burnt, coin_out) = completeWithdrawal(i, _min_out);
    }

    /// @notice Only executor. Completes all available pending withdrawals
    /// @param _min_out Minimum total amount of underlying expected from the withdrawals
    /// @return total_lpt_burnt Total shares burnt from completing the withdrawals
    /// @return total_coin_out Total underlying out after completing the withdrawals
    function completeNextWithdrawals(uint _min_out) public onlyExecutor hasConfig returns (uint total_lpt_burnt, uint total_coin_out) {
        while (canCompleteWithdrawals()) {
            (uint lpt_burnt, uint coin_out) = completeNextWithdrawal(0);
            total_lpt_burnt += lpt_burnt;
            total_coin_out += coin_out;
        }
        require(total_coin_out >= _min_out, 'W4');
    }

    /// @notice Only executor. Override withdrawal indexes
    /// @dev Should not be used under normal circumstances
    /// @param _cumulativeWithdrawalsQueued New cumulative withdrawals queued
    /// @param _indexNextWithdrawal New index of the next withdrawal
    function overrideWithdrawalIndexes(uint _cumulativeWithdrawalsQueued, uint _indexNextWithdrawal) external onlyExecutor {
        cumulativeWithdrawalsQueued = _cumulativeWithdrawalsQueued;
        indexNextWithdrawal = _indexNextWithdrawal;
    }

    /* Self service */

    /// @notice Only executor. Deposits underlying into the liquid staking contract
    /// @param _min_lpt_out Minimum amount of shares expected from the deposit
    /// @return lpt_out Amount of shares received from the deposit
    function assemble(uint _min_lpt_out) public onlyExecutor hasConfig returns (uint lpt_out) {
        PositionConfig memory c = positionConfig;
        uint underlying_amount = _balance(c.underlying);

        lpt_out = deposit(underlying_amount, _min_lpt_out);

        address[] memory tokens = getPositionAssets();
        uint[] memory underlyings_change = new uint[](tokens.length);
        underlyings_change[0] = underlying_amount - _balance(c.underlying);

        emit Assemble(msg.sender, tokens, underlyings_change, lpt_out);
    }

    /// @notice Only executor. Starts a withdrawal if requested and completes all available pending withdrawals
    /// @param _percentage Percentage of shares to start the withdrawal
    /// @param _min_coin_out Minimum total amount of underlying expected from claims
    /// @return coin_out Total underlying out after completing the withdrawals
    function disassemble(uint _percentage, uint _min_coin_out) public onlyExecutor hasConfig returns (uint coin_out) {
        require(_percentage <= ONE, 'P1');
        uint lpt_burnt;
        
        if (_percentage > 0) {
            uint lpt_amount = _percentageAmount(getLPTDeposited(), _percentage);
            startWithdrawal(lpt_amount);
        }
        (lpt_burnt, coin_out) = completeNextWithdrawals(_min_coin_out);
        
        address[] memory tokens = getPositionAssets();
        uint[] memory underlyings_change = new uint[](tokens.length);
        underlyings_change[0] = coin_out;
        emit Disassemble(msg.sender, tokens, underlyings_change, lpt_burnt);
    }

    /// @notice Only executor. Starts a withdrawal for all shares and completes all available pending withdrawals
    /// @param _min_coin_out Minimum total underlying expected from completed withdrawals
    /// @return Total underlying out after completing the withdrawals
    function fullDisassemble(uint _min_coin_out) public onlyExecutor hasConfig returns (uint) {
        return disassemble(ONE, _min_coin_out);
    }

    /* Rewards */

    /// @notice Claim rewards from EigenLayer
    /// @param _claim Merkle data to claim rewards
    /// @param _recipient Address to receive the rewards
    function _processClaim(IRewardsCoordinator.RewardsMerkleClaim calldata _claim, address _recipient) internal {
        rewardsCoordinator.processClaim(_claim, _recipient);
    }

    /// @notice Only owner. Sets an address that can call `rewardsCoordinator.processClaim` on behalf of the position manager
    /// @param _claimer Address of the claimer
    function setRewardsClaimer(address _claimer) external onlyOwner {
        rewardsCoordinator.setClaimerFor(_claimer);
    }

    /// @notice Only owner. Claim rewards from EigenLayer with a recipient address
    /// @param _claim Merkle data to claim rewards
    /// @param _recipient Address to receive the rewards
    function processClaim(IRewardsCoordinator.RewardsMerkleClaim calldata _claim, address _recipient) external onlyOwner {
        require(_recipient != address(0), 'C1');
        _processClaim(_claim, _recipient);
    }

    /// @notice Only executor. Claim rewards from EigenLayer to the position manager
    /// @param _claim Merkle data to claim rewards
    function claimRewards(IRewardsCoordinator.RewardsMerkleClaim calldata _claim) external onlyExecutor {
        _processClaim(_claim, address(this));
    }
}

/* SPDX-License-Identifier: UNLICENSED */
pragma solidity 0.8.15;

import './PositionManager.sol';
import '@itb/quant-common/contracts/solidity8/utils/Ownable2StepWithShortcut.sol';

contract PositionManagerOwnable2StepWithShortcut is PositionManager, Ownable2StepWithShortcut {
    constructor(address[] memory _executors, address payable _wnative, address _strategy_manager, address _delegation_manager, address _rewards_coordinator, address _liquid_staking, address _underlying, address _delegate_to) PositionManager(_executors, _wnative, _strategy_manager, _delegation_manager, _rewards_coordinator, _liquid_staking, _underlying, _delegate_to) {}
}