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.25;

import "../interfaces/strategies/IRatiosStrategy.sol";

contract RatiosStrategy is IRatiosStrategy {
    /// @inheritdoc IRatiosStrategy
    uint256 public constant D18 = 1e18;
    /// @inheritdoc IRatiosStrategy
    bytes32 public constant RATIOS_STRATEGY_SET_RATIOS_ROLE =
        keccak256("RATIOS_STRATEGY_SET_RATIOS_ROLE");

    /// @inheritdoc IRatiosStrategy
    mapping(address vault => mapping(address subvault => Ratio)) public ratios;

    /// @inheritdoc IRatiosStrategy
    function setRatios(address vault, address[] calldata subvaults, Ratio[] calldata ratios_)
        external
    {
        require(
            IAccessControl(vault).hasRole(RATIOS_STRATEGY_SET_RATIOS_ROLE, msg.sender),
            "RatiosStrategy: forbidden"
        );
        require(
            subvaults.length == ratios_.length,
            "RatiosStrategy: subvaults and ratios length mismatch"
        );
        IMultiVault multiVault = IMultiVault(vault);
        uint256 n = subvaults.length;
        for (uint256 i = 0; i < n; i++) {
            if (multiVault.indexOfSubvault(subvaults[i]) != 0) {
                require(
                    ratios_[i].minRatioD18 <= ratios_[i].maxRatioD18
                        && ratios_[i].maxRatioD18 <= D18,
                    "RatiosStrategy: invalid ratios"
                );
            } else {
                require(
                    ratios_[i].minRatioD18 == 0 && ratios_[i].maxRatioD18 == 0,
                    "RatiosStrategy: invalid subvault"
                );
            }
        }
        mapping(address => Ratio) storage vaultRatios_ = ratios[vault];
        for (uint256 i = 0; i < n; i++) {
            vaultRatios_[subvaults[i]] = ratios_[i];
        }

        emit RatiosSet(vault, subvaults, ratios_);
    }

    /// @inheritdoc IRatiosStrategy
    function calculateState(address vault, bool isDeposit, uint256 increment)
        public
        view
        returns (Amounts[] memory state, uint256 liquid)
    {
        IMultiVault multiVault = IMultiVault(vault);
        uint256 n = multiVault.subvaultsCount();
        state = new Amounts[](n);

        liquid = IERC20(IERC4626(vault).asset()).balanceOf(vault);
        IDefaultCollateral collateral = multiVault.defaultCollateral();
        if (address(collateral) != address(0)) {
            liquid += collateral.balanceOf(vault);
        }
        uint256 totalAssets = liquid;
        IMultiVaultStorage.Subvault memory subvault;
        for (uint256 i = 0; i < n; i++) {
            subvault = multiVault.subvaultAt(i);
            IProtocolAdapter adapter = multiVault.adapterOf(subvault.protocol);
            state[i].staked = adapter.stakedAt(subvault.vault);
            if (!isDeposit && adapter.areWithdrawalsPaused(subvault.vault, vault)) {
                revert("RatiosStrategy: withdrawals paused");
            }
            if (subvault.withdrawalQueue != address(0)) {
                state[i].claimable =
                    IWithdrawalQueue(subvault.withdrawalQueue).claimableAssetsOf(vault);
                state[i].pending = IWithdrawalQueue(subvault.withdrawalQueue).pendingAssetsOf(vault);
                totalAssets += state[i].staked + state[i].pending + state[i].claimable;
            } else {
                totalAssets += state[i].staked;
            }
            uint256 maxDeposit = adapter.maxDeposit(subvault.vault);
            if (type(uint256).max - state[i].staked > maxDeposit) {
                state[i].max = maxDeposit + state[i].staked;
            } else {
                state[i].max = type(uint256).max;
            }
        }
        totalAssets = isDeposit ? totalAssets + increment : totalAssets - increment;
        mapping(address => Ratio) storage vaultRatios_ = ratios[vault];
        for (uint256 i = 0; i < n; i++) {
            Ratio memory ratio = vaultRatios_[multiVault.subvaultAt(i).vault];
            if (ratio.maxRatioD18 == 0) {
                state[i].max = 0;
                state[i].min = 0;
            } else {
                state[i].max = Math.min(state[i].max, (totalAssets * ratio.maxRatioD18) / D18);
                state[i].min = Math.min(state[i].max, (totalAssets * ratio.minRatioD18) / D18);
            }
        }
    }

    /// @inheritdoc IDepositStrategy
    function calculateDepositAmounts(address vault, uint256 amount)
        external
        view
        override
        returns (DepositData[] memory data)
    {
        (Amounts[] memory state,) = calculateState(vault, true, amount);
        uint256 n = state.length;
        for (uint256 i = 0; i < n; i++) {
            uint256 assets_ = state[i].staked;
            if (state[i].min > assets_) {
                state[i].min -= assets_;
                state[i].max -= assets_;
            } else if (state[i].max > assets_) {
                state[i].min = 0;
                state[i].max -= assets_;
            } else {
                state[i].min = 0;
                state[i].max = 0;
            }
        }
        data = new DepositData[](n);
        for (uint256 i = 0; i < n && amount != 0; i++) {
            data[i].subvaultIndex = i;
            if (state[i].min == 0) {
                continue;
            }
            uint256 assets_ = Math.min(state[i].min, amount);
            state[i].max -= assets_;
            amount -= assets_;
            data[i].deposit = assets_;
        }
        for (uint256 i = 0; i < n && amount != 0; i++) {
            if (state[i].max == 0) {
                continue;
            }
            uint256 assets_ = Math.min(state[i].max, amount);
            amount -= assets_;
            data[i].deposit += assets_;
        }
        uint256 count = 0;
        for (uint256 i = 0; i < n; i++) {
            if (data[i].deposit != 0) {
                if (count != i) {
                    data[count] = data[i];
                }
                count++;
            }
        }
        assembly {
            mstore(data, count)
        }
    }

    /// @inheritdoc IWithdrawalStrategy
    function calculateWithdrawalAmounts(address vault, uint256 amount)
        external
        view
        override
        returns (WithdrawalData[] memory data)
    {
        (Amounts[] memory state, uint256 liquid) = calculateState(vault, false, amount);
        if (amount <= liquid) {
            return data;
        }
        amount -= liquid;
        uint256 n = state.length;
        data = new WithdrawalData[](n);
        for (uint256 i = 0; i < n && amount != 0; i++) {
            data[i].subvaultIndex = i;
            if (state[i].staked > state[i].max) {
                uint256 extra = state[i].staked - state[i].max;
                if (extra > amount) {
                    data[i].staked = amount;
                    amount = 0;
                } else {
                    data[i].staked = extra;
                    amount -= extra;
                }
                state[i].staked -= data[i].staked;
            }
        }
        for (uint256 i = 0; i < n && amount != 0; i++) {
            if (state[i].staked > state[i].min) {
                uint256 allowed = state[i].staked - state[i].min;
                if (allowed > amount) {
                    data[i].staked += amount;
                    amount = 0;
                } else {
                    data[i].staked += allowed;
                    amount -= allowed;
                    state[i].staked -= allowed;
                }
            }
        }
        for (uint256 i = 0; i < n && amount != 0; i++) {
            if (state[i].pending > 0) {
                if (state[i].pending > amount) {
                    data[i].pending += amount;
                    amount = 0;
                } else {
                    data[i].pending += state[i].pending;
                    amount -= state[i].pending;
                }
            }
        }
        for (uint256 i = 0; i < n && amount != 0; i++) {
            if (state[i].claimable > 0) {
                if (state[i].claimable > amount) {
                    data[i].claimable += amount;
                    amount = 0;
                } else {
                    data[i].claimable += state[i].claimable;
                    amount -= state[i].claimable;
                }
            }
        }
        for (uint256 i = 0; i < n && amount != 0; i++) {
            uint256 staked = state[i].staked;
            if (staked > 0) {
                if (staked > amount) {
                    data[i].staked += amount;
                    amount = 0;
                } else {
                    data[i].staked += staked;
                    amount -= staked;
                }
            }
        }

        uint256 count = 0;
        for (uint256 i = 0; i < n; i++) {
            if (data[i].staked + data[i].pending + data[i].claimable != 0) {
                if (count != i) {
                    data[count] = data[i];
                }
                count++;
            }
        }
        assembly {
            mstore(data, count)
        }
    }

    /// @inheritdoc IRebalanceStrategy
    function calculateRebalanceAmounts(address vault)
        external
        view
        override
        returns (RebalanceData[] memory data)
    {
        (Amounts[] memory state, uint256 liquid) = calculateState(vault, false, 0);
        uint256 n = state.length;
        data = new RebalanceData[](n);
        uint256 totalRequired = 0;
        uint256 pending = 0;
        for (uint256 i = 0; i < n; i++) {
            data[i].subvaultIndex = i;
            data[i].claimable = state[i].claimable;
            liquid += state[i].claimable;
            pending += state[i].pending;
            if (state[i].staked > state[i].max) {
                data[i].staked = state[i].staked - state[i].max;
                pending += data[i].staked;
                state[i].staked = state[i].max;
            }
            if (state[i].min > state[i].staked) {
                totalRequired += state[i].min - state[i].staked;
            }
        }

        if (totalRequired > liquid + pending) {
            uint256 unstake = totalRequired - liquid - pending;
            for (uint256 i = 0; i < n && unstake > 0; i++) {
                if (state[i].staked > state[i].min) {
                    uint256 allowed = state[i].staked - state[i].min;
                    if (allowed > unstake) {
                        data[i].staked += unstake;
                        unstake = 0;
                    } else {
                        data[i].staked += allowed;
                        unstake -= allowed;
                    }
                }
            }
        }

        for (uint256 i = 0; i < n && liquid > 0; i++) {
            if (state[i].staked < state[i].min) {
                uint256 required = state[i].min - state[i].staked;
                if (required > liquid) {
                    data[i].deposit = liquid;
                    liquid = 0;
                } else {
                    data[i].deposit = required;
                    liquid -= required;
                    state[i].max -= data[i].deposit;
                }
            }
        }

        for (uint256 i = 0; i < n && liquid > 0; i++) {
            if (state[i].staked < state[i].max) {
                uint256 allowed = state[i].max - state[i].staked;
                if (allowed > liquid) {
                    data[i].deposit += liquid;
                    liquid = 0;
                } else {
                    data[i].deposit += allowed;
                    liquid -= allowed;
                }
            }
        }
    }
}

// // SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.25;

import {IDefaultCollateral, IERC20} from "../tokens/IDefaultCollateral.sol";
import {
    IMultiVault,
    IMultiVaultStorage,
    IProtocolAdapter,
    IWithdrawalQueue
} from "../vaults/IMultiVault.sol";
import {IDepositStrategy} from "./IDepositStrategy.sol";
import {IRebalanceStrategy} from "./IRebalanceStrategy.sol";
import {IWithdrawalStrategy} from "./IWithdrawalStrategy.sol";
import {IAccessControl} from "@openzeppelin/contracts/access/IAccessControl.sol";
import {IERC4626} from "@openzeppelin/contracts/interfaces/IERC4626.sol";
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";

interface IRatiosStrategy is IDepositStrategy, IWithdrawalStrategy, IRebalanceStrategy {
    struct Ratio {
        uint64 minRatioD18;
        uint64 maxRatioD18;
    }

    struct Amounts {
        uint256 min;
        uint256 max;
        uint256 claimable;
        uint256 pending;
        uint256 staked;
    }

    function D18() external view returns (uint256);

    function RATIOS_STRATEGY_SET_RATIOS_ROLE() external view returns (bytes32);

    function ratios(address vault, address subvault)
        external
        view
        returns (uint64 minRatioD18, uint64 maxRatioD18);

    function setRatios(address vault, address[] calldata subvaults, Ratio[] calldata ratios)
        external;

    function calculateState(address vault, bool isDeposit, uint256 increment)
        external
        view
        returns (Amounts[] memory state, uint256 liquid);

    event RatiosSet(address indexed vault, address[] subvaults, Ratio[] ratios);
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.25;

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

interface IDefaultCollateral is IERC20 {
    /**
     * @notice Emitted when debt is issued.
     * @param issuer address of the debt's issuer
     * @param recipient address that should receive the underlying asset
     * @param debtIssued amount of the debt issued
     */
    event IssueDebt(address indexed issuer, address indexed recipient, uint256 debtIssued);

    /**
     * @notice Emitted when debt is repaid.
     * @param issuer address of the debt's issuer
     * @param recipient address that received the underlying asset
     * @param debtRepaid amount of the debt repaid
     */
    event RepayDebt(address indexed issuer, address indexed recipient, uint256 debtRepaid);

    /**
     * @notice Get the collateral's underlying asset.
     * @return asset address of the underlying asset
     */
    function asset() external view returns (address);

    /**
     * @notice Get a total amount of repaid debt.
     * @return total repaid debt
     */
    function totalRepaidDebt() external view returns (uint256);

    /**
     * @notice Get an amount of repaid debt created by a particular issuer.
     * @param issuer address of the debt's issuer
     * @return particular issuer's repaid debt
     */
    function issuerRepaidDebt(address issuer) external view returns (uint256);

    /**
     * @notice Get an amount of repaid debt to a particular recipient.
     * @param recipient address that received the underlying asset
     * @return particular recipient's repaid debt
     */
    function recipientRepaidDebt(address recipient) external view returns (uint256);

    /**
     * @notice Get an amount of repaid debt for a particular issuer-recipient pair.
     * @param issuer address of the debt's issuer
     * @param recipient address that received the underlying asset
     * @return particular pair's repaid debt
     */
    function repaidDebt(address issuer, address recipient) external view returns (uint256);

    /**
     * @notice Get a total amount of debt.
     * @return total debt
     */
    function totalDebt() external view returns (uint256);

    /**
     * @notice Get a current debt created by a particular issuer.
     * @param issuer address of the debt's issuer
     * @return particular issuer's debt
     */
    function issuerDebt(address issuer) external view returns (uint256);

    /**
     * @notice Get a current debt to a particular recipient.
     * @param recipient address that should receive the underlying asset
     * @return particular recipient's debt
     */
    function recipientDebt(address recipient) external view returns (uint256);

    /**
     * @notice Get a current debt for a particular issuer-recipient pair.
     * @param issuer address of the debt's issuer
     * @param recipient address that should receive the underlying asset
     * @return particular pair's debt
     */
    function debt(address issuer, address recipient) external view returns (uint256);

    /**
     * @notice Burn a given amount of the collateral, and increase a debt of the underlying asset for the caller.
     * @param recipient address that should receive the underlying asset
     * @param amount amount of the collateral
     */
    function issueDebt(address recipient, uint256 amount) external;

    error NotLimitIncreaser();
    error InsufficientDeposit();
    error ExceedsLimit();
    error InsufficientWithdraw();
    error InsufficientIssueDebt();

    /**
     * @notice Emmited when deposit happens.
     * @param depositor address of the depositor
     * @param recipient address of the collateral's recipient
     * @param amount amount of the collateral minted
     */
    event Deposit(address indexed depositor, address indexed recipient, uint256 amount);

    /**
     * @notice Emmited when withdrawal happens.
     * @param withdrawer address of the withdrawer
     * @param recipient address of the underlying asset's recipient
     * @param amount amount of the collateral burned
     */
    event Withdraw(address indexed withdrawer, address indexed recipient, uint256 amount);

    /**
     * @notice Emmited when limit is increased.
     * @param amount amount to increase the limit by
     */
    event IncreaseLimit(uint256 amount);

    /**
     * @notice Emmited when new limit increaser is set.
     * @param limitIncreaser address of the new limit increaser
     */
    event SetLimitIncreaser(address indexed limitIncreaser);

    /**
     * @notice Get a maximum possible collateral total supply.
     * @return maximum collateral total supply
     */
    function limit() external view returns (uint256);

    /**
     * @notice Get an address of the limit increaser.
     * @return address of the limit increaser
     */
    function limitIncreaser() external view returns (address);

    /**
     * @notice Deposit a given amount of the underlying asset, and mint the collateral to a particular recipient.
     * @param recipient address of the collateral's recipient
     * @param amount amount of the underlying asset
     * @return amount of the collateral minted
     */
    function deposit(address recipient, uint256 amount) external returns (uint256);

    /**
     * @notice Deposit a given amount of the underlying asset using a permit functionality, and mint the collateral to a particular recipient.
     * @param recipient address of the collateral's recipient
     * @param amount amount of the underlying asset
     * @param deadline timestamp of the signature's deadline
     * @param v v component of the signature
     * @param r r component of the signature
     * @param s s component of the signature
     * @return amount of the collateral minted
     */
    function deposit(
        address recipient,
        uint256 amount,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256);

    /**
     * @notice Withdraw a given amount of the underlying asset, and transfer it to a particular recipient.
     * @param recipient address of the underlying asset's recipient
     * @param amount amount of the underlying asset
     */
    function withdraw(address recipient, uint256 amount) external;

    /**
     * @notice Increase a limit of maximum collateral total supply.
     * @param amount amount to increase the limit by
     * @dev Called only by limitIncreaser.
     */
    function increaseLimit(uint256 amount) external;

    /**
     * @notice Set a new limit increaser.
     * @param limitIncreaser address of the new limit increaser
     * @dev Called only by limitIncreaser.
     */
    function setLimitIncreaser(address limitIncreaser) external;
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.25;

import "./IMultiVaultStorage.sol";

interface IMultiVault is IMultiVaultStorage {
    struct InitParams {
        address admin;
        uint256 limit;
        bool depositPause;
        bool withdrawalPause;
        bool depositWhitelist;
        address asset;
        string name;
        string symbol;
        address depositStrategy;
        address withdrawalStrategy;
        address rebalanceStrategy;
        address defaultCollateral;
        address symbioticAdapter;
        address eigenLayerAdapter;
        address erc4626Adapter;
    }

    function initialize(InitParams calldata initParams) external;

    function rebalance() external;

    function addSubvault(address vault, Protocol protocol) external;

    function removeSubvault(address subvault) external;

    function setDepositStrategy(address newDepositStrategy) external;

    function setWithdrawalStrategy(address newWithdrawalStrategy) external;

    function setRebalanceStrategy(address newRebalanceStrategy) external;

    function setRewardsData(uint256 farmId, RewardData calldata rewardData) external;

    function setDefaultCollateral(address defaultCollateral_) external;

    function setSymbioticAdapter(address adapter_) external;

    function setEigenLayerAdapter(address adapter_) external;

    function setERC4626Adapter(address adapter_) external;

    function pushRewards(uint256 farmId, bytes calldata data) external;

    event Rebalance(IRebalanceStrategy.RebalanceData[] data, uint256 timestamp);

    event DepositIntoCollateral(uint256 assets);

    event RewardsPushed(
        uint256 indexed farmId,
        uint256 indexed rewardAmount,
        uint256 indexed curatorFee,
        uint256 timestamp
    );
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.25;

interface IDepositStrategy {
    struct DepositData {
        uint256 subvaultIndex;
        uint256 deposit;
    }

    function calculateDepositAmounts(address vault, uint256 assets)
        external
        view
        returns (DepositData[] memory subvaultsData);
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.25;

interface IRebalanceStrategy {
    struct RebalanceData {
        uint256 subvaultIndex;
        uint256 deposit;
        uint256 claimable;
        uint256 staked;
    }

    function calculateRebalanceAmounts(address vault)
        external
        view
        returns (RebalanceData[] memory subvaultsData);
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.25;

interface IWithdrawalStrategy {
    struct WithdrawalData {
        uint256 subvaultIndex;
        uint256 claimable;
        uint256 pending;
        uint256 staked;
    }

    function calculateWithdrawalAmounts(address vault, uint256 amount)
        external
        view
        returns (WithdrawalData[] memory subvaultsData);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/IAccessControl.sol)

pragma solidity ^0.8.20;

/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControl {
    /**
     * @dev The `account` is missing a role.
     */
    error AccessControlUnauthorizedAccount(address account, bytes32 neededRole);

    /**
     * @dev The caller of a function is not the expected one.
     *
     * NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.
     */
    error AccessControlBadConfirmation();

    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {AccessControl-_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) external view returns (bool);

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `callerConfirmation`.
     */
    function renounceRole(bytes32 role, address callerConfirmation) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC4626.sol)

pragma solidity ^0.8.20;

import {IERC20} from "../token/ERC20/IERC20.sol";
import {IERC20Metadata} from "../token/ERC20/extensions/IERC20Metadata.sol";

/**
 * @dev Interface of the ERC4626 "Tokenized Vault Standard", as defined in
 * https://eips.ethereum.org/EIPS/eip-4626[ERC-4626].
 */
interface IERC4626 is IERC20, IERC20Metadata {
    event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares);

    event Withdraw(
        address indexed sender,
        address indexed receiver,
        address indexed owner,
        uint256 assets,
        uint256 shares
    );

    /**
     * @dev Returns the address of the underlying token used for the Vault for accounting, depositing, and withdrawing.
     *
     * - MUST be an ERC-20 token contract.
     * - MUST NOT revert.
     */
    function asset() external view returns (address assetTokenAddress);

    /**
     * @dev Returns the total amount of the underlying asset that is “managed” by Vault.
     *
     * - SHOULD include any compounding that occurs from yield.
     * - MUST be inclusive of any fees that are charged against assets in the Vault.
     * - MUST NOT revert.
     */
    function totalAssets() external view returns (uint256 totalManagedAssets);

    /**
     * @dev Returns the amount of shares that the Vault would exchange for the amount of assets provided, in an ideal
     * scenario where all the conditions are met.
     *
     * - MUST NOT be inclusive of any fees that are charged against assets in the Vault.
     * - MUST NOT show any variations depending on the caller.
     * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.
     * - MUST NOT revert.
     *
     * NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the
     * “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and
     * from.
     */
    function convertToShares(uint256 assets) external view returns (uint256 shares);

    /**
     * @dev Returns the amount of assets that the Vault would exchange for the amount of shares provided, in an ideal
     * scenario where all the conditions are met.
     *
     * - MUST NOT be inclusive of any fees that are charged against assets in the Vault.
     * - MUST NOT show any variations depending on the caller.
     * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.
     * - MUST NOT revert.
     *
     * NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the
     * “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and
     * from.
     */
    function convertToAssets(uint256 shares) external view returns (uint256 assets);

    /**
     * @dev Returns the maximum amount of the underlying asset that can be deposited into the Vault for the receiver,
     * through a deposit call.
     *
     * - MUST return a limited value if receiver is subject to some deposit limit.
     * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of assets that may be deposited.
     * - MUST NOT revert.
     */
    function maxDeposit(address receiver) external view returns (uint256 maxAssets);

    /**
     * @dev Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given
     * current on-chain conditions.
     *
     * - MUST return as close to and no more than the exact amount of Vault shares that would be minted in a deposit
     *   call in the same transaction. I.e. deposit should return the same or more shares as previewDeposit if called
     *   in the same transaction.
     * - MUST NOT account for deposit limits like those returned from maxDeposit and should always act as though the
     *   deposit would be accepted, regardless if the user has enough tokens approved, etc.
     * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.
     * - MUST NOT revert.
     *
     * NOTE: any unfavorable discrepancy between convertToShares and previewDeposit SHOULD be considered slippage in
     * share price or some other type of condition, meaning the depositor will lose assets by depositing.
     */
    function previewDeposit(uint256 assets) external view returns (uint256 shares);

    /**
     * @dev Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens.
     *
     * - MUST emit the Deposit event.
     * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
     *   deposit execution, and are accounted for during deposit.
     * - MUST revert if all of assets cannot be deposited (due to deposit limit being reached, slippage, the user not
     *   approving enough underlying tokens to the Vault contract, etc).
     *
     * NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.
     */
    function deposit(uint256 assets, address receiver) external returns (uint256 shares);

    /**
     * @dev Returns the maximum amount of the Vault shares that can be minted for the receiver, through a mint call.
     * - MUST return a limited value if receiver is subject to some mint limit.
     * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of shares that may be minted.
     * - MUST NOT revert.
     */
    function maxMint(address receiver) external view returns (uint256 maxShares);

    /**
     * @dev Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given
     * current on-chain conditions.
     *
     * - MUST return as close to and no fewer than the exact amount of assets that would be deposited in a mint call
     *   in the same transaction. I.e. mint should return the same or fewer assets as previewMint if called in the
     *   same transaction.
     * - MUST NOT account for mint limits like those returned from maxMint and should always act as though the mint
     *   would be accepted, regardless if the user has enough tokens approved, etc.
     * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.
     * - MUST NOT revert.
     *
     * NOTE: any unfavorable discrepancy between convertToAssets and previewMint SHOULD be considered slippage in
     * share price or some other type of condition, meaning the depositor will lose assets by minting.
     */
    function previewMint(uint256 shares) external view returns (uint256 assets);

    /**
     * @dev Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens.
     *
     * - MUST emit the Deposit event.
     * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the mint
     *   execution, and are accounted for during mint.
     * - MUST revert if all of shares cannot be minted (due to deposit limit being reached, slippage, the user not
     *   approving enough underlying tokens to the Vault contract, etc).
     *
     * NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.
     */
    function mint(uint256 shares, address receiver) external returns (uint256 assets);

    /**
     * @dev Returns the maximum amount of the underlying asset that can be withdrawn from the owner balance in the
     * Vault, through a withdraw call.
     *
     * - MUST return a limited value if owner is subject to some withdrawal limit or timelock.
     * - MUST NOT revert.
     */
    function maxWithdraw(address owner) external view returns (uint256 maxAssets);

    /**
     * @dev Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block,
     * given current on-chain conditions.
     *
     * - MUST return as close to and no fewer than the exact amount of Vault shares that would be burned in a withdraw
     *   call in the same transaction. I.e. withdraw should return the same or fewer shares as previewWithdraw if
     *   called
     *   in the same transaction.
     * - MUST NOT account for withdrawal limits like those returned from maxWithdraw and should always act as though
     *   the withdrawal would be accepted, regardless if the user has enough shares, etc.
     * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.
     * - MUST NOT revert.
     *
     * NOTE: any unfavorable discrepancy between convertToShares and previewWithdraw SHOULD be considered slippage in
     * share price or some other type of condition, meaning the depositor will lose assets by depositing.
     */
    function previewWithdraw(uint256 assets) external view returns (uint256 shares);

    /**
     * @dev Burns shares from owner and sends exactly assets of underlying tokens to receiver.
     *
     * - MUST emit the Withdraw event.
     * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
     *   withdraw execution, and are accounted for during withdraw.
     * - MUST revert if all of assets cannot be withdrawn (due to withdrawal limit being reached, slippage, the owner
     *   not having enough shares, etc).
     *
     * Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed.
     * Those methods should be performed separately.
     */
    function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);

    /**
     * @dev Returns the maximum amount of Vault shares that can be redeemed from the owner balance in the Vault,
     * through a redeem call.
     *
     * - MUST return a limited value if owner is subject to some withdrawal limit or timelock.
     * - MUST return balanceOf(owner) if owner is not subject to any withdrawal limit or timelock.
     * - MUST NOT revert.
     */
    function maxRedeem(address owner) external view returns (uint256 maxShares);

    /**
     * @dev Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block,
     * given current on-chain conditions.
     *
     * - MUST return as close to and no more than the exact amount of assets that would be withdrawn in a redeem call
     *   in the same transaction. I.e. redeem should return the same or more assets as previewRedeem if called in the
     *   same transaction.
     * - MUST NOT account for redemption limits like those returned from maxRedeem and should always act as though the
     *   redemption would be accepted, regardless if the user has enough shares, etc.
     * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.
     * - MUST NOT revert.
     *
     * NOTE: any unfavorable discrepancy between convertToAssets and previewRedeem SHOULD be considered slippage in
     * share price or some other type of condition, meaning the depositor will lose assets by redeeming.
     */
    function previewRedeem(uint256 shares) external view returns (uint256 assets);

    /**
     * @dev Burns exactly shares from owner and sends assets of underlying tokens to receiver.
     *
     * - MUST emit the Withdraw event.
     * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
     *   redeem execution, and are accounted for during redeem.
     * - MUST revert if all of shares cannot be redeemed (due to withdrawal limit being reached, slippage, the owner
     *   not having enough shares, etc).
     *
     * NOTE: some implementations will require pre-requesting to the Vault before a withdrawal may be performed.
     * Those methods should be performed separately.
     */
    function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);
}

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

pragma solidity ^0.8.20;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @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 towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }

        // (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 = x * y; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                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.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }

            ///////////////////////////////////////////////
            // 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.

            uint256 twos = denominator & (0 - denominator);
            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 (unsignedRoundsUp(rounding) && 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
     * towards zero.
     *
     * 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 + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * 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 + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10 of a positive value rounded towards zero.
     * 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 + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256 of a positive value rounded towards zero.
     * 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 + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
        }
    }

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}

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

pragma solidity ^0.8.20;

/**
 * @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 value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens 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 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` 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 value) external returns (bool);
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.25;

import {IProtocolAdapter} from "../adapters/IProtocolAdapter.sol";
import {IWithdrawalQueue} from "../queues/IWithdrawalQueue.sol";
import {IDepositStrategy} from "../strategies/IDepositStrategy.sol";
import {IRebalanceStrategy} from "../strategies/IRebalanceStrategy.sol";
import {IWithdrawalStrategy} from "../strategies/IWithdrawalStrategy.sol";
import {IDefaultCollateral} from "../tokens/IDefaultCollateral.sol";
import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import {
    ERC4626Upgradeable,
    IERC4626
} from "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC4626Upgradeable.sol";
import {IERC20, SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {Address} from "@openzeppelin/contracts/utils/Address.sol";
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";

interface IMultiVaultStorage {
    enum Protocol {
        SYMBIOTIC,
        EIGEN_LAYER,
        ERC4626
    }

    struct Subvault {
        Protocol protocol;
        address vault;
        address withdrawalQueue;
    }

    struct RewardData {
        address distributionFarm;
        address curatorTreasury;
        address token;
        uint256 curatorFeeD6;
        Protocol protocol;
        bytes data;
    }

    struct MultiStorage {
        address depositStrategy;
        address withdrawalStrategy;
        address rebalanceStrategy;
        Subvault[] subvaults;
        mapping(address subvault => uint256 index) indexOfSubvault;
        mapping(uint256 id => RewardData) rewardData;
        EnumerableSet.UintSet farmIds;
        address defaultCollateral;
        address symbioticAdapter;
        address eigenLayerAdapter;
        address erc4626Adapter;
        bytes32[16] _gap;
    }

    function subvaultsCount() external view returns (uint256);

    function subvaultAt(uint256 index) external view returns (Subvault memory);

    function indexOfSubvault(address subvault) external view returns (uint256);

    function farmIds() external view returns (uint256[] memory);

    function farmCount() external view returns (uint256);

    function farmIdAt(uint256 index) external view returns (uint256);

    function farmIdsContains(uint256 farmId) external view returns (bool);

    function defaultCollateral() external view returns (IDefaultCollateral);

    function depositStrategy() external view returns (IDepositStrategy);

    function withdrawalStrategy() external view returns (IWithdrawalStrategy);

    function rebalanceStrategy() external view returns (IRebalanceStrategy);

    function eigenLayerAdapter() external view returns (IProtocolAdapter);

    function symbioticAdapter() external view returns (IProtocolAdapter);

    function erc4626Adapter() external view returns (IProtocolAdapter);

    function adapterOf(Protocol protocol) external view returns (IProtocolAdapter);

    function rewardData(uint256 farmId) external view returns (RewardData memory);

    event SubvaultAdded(
        address indexed subvault, address withdrawalQueue, Protocol protocol, uint256 subvaultIndex
    );

    event SubvaultRemoved(address indexed subvault, uint256 subvaultIndex);

    event SubvaultIndexChanged(address indexed subvault, uint256 oldIndex, uint256 newIndex);

    event RewardDataRemoved(uint256 indexed farmId);

    event RewardDataSet(uint256 indexed farmId, RewardData data);

    event DefaultCollateralSet(address indexed defaultCollateral);

    event DepositStrategySet(address indexed depositStrategy);

    event WithdrawalStrategySet(address indexed withdrawalStrategy);

    event RebalanceStrategySet(address indexed rebalanceStrategy);

    event SymbioticAdapterSet(address indexed symbioticAdapter);

    event EigenLayerAdapterSet(address indexed eigenLayerAdapter);

    event ERC4626AdapterSet(address indexed erc4626Adapter);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.20;

import {IERC20} from "../IERC20.sol";

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.25;

interface IProtocolAdapter {
    function vault() external view returns (address);

    function maxDeposit(address subvault) external view returns (uint256);

    function stakedAt(address subvault) external view returns (uint256);

    function assetOf(address subvault) external view returns (address);

    function validateRewardData(bytes calldata data) external view;

    function pushRewards(address rewardToken, bytes calldata farmData, bytes memory rewardData)
        external;

    function withdraw(
        address subvault,
        address withdrawalQueue,
        address receiver,
        uint256 request,
        address owner
    ) external;

    function deposit(address subvault, uint256 assets) external;

    function handleVault(address subvault) external returns (address withdrawalQueue);

    function areWithdrawalsPaused(address subvault, address account) external view returns (bool);
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.25;

/**
 * @title IWithdrawalQueue
 * @notice Interface to handle the withdrawal process from the underlying vault.
 * @dev Provides functions to manage withdrawals, claimable assets, and interactions with vault epochs.
 */
interface IWithdrawalQueue {
    /**
     * @notice Returns the pending collateral amount for a specific account.
     * @param account The address of the account.
     * @return pendingAssets The total amount of pending collateral for the account.
     */
    function pendingAssetsOf(address account) external view returns (uint256);

    /**
     * @notice Returns the claimable collateral amount for a specific account.
     * @param account The address of the account.
     * @return claimableAssets The total amount of claimable collateral for the account.
     */
    function claimableAssetsOf(address account) external view returns (uint256);

    /**
     * @notice Claims collateral from the External Vault for a specified epoch.
     * @param epoch The epoch number from which to claim collateral.
     *
     * @custom:requirements
     * - The epoch MUST be claimable.
     * - There MUST be claimable withdrawals for the given epoch.
     *
     * @custom:effects
     * - Emits an `EpochClaimed` event.
     */
    function pull(uint256 epoch) external;

    /**
     * @notice Finalizes the collateral claim process for a specific account and transfers it to the recipient.
     * @dev Transfers the lesser of the claimable amount or the specified maximum amount to the recipient.
     * @param account The address of the account to claim collateral from.
     * @param recipient The address of the recipient receiving the collateral.
     * @param maxAmount The maximum amount of collateral to be claimed.
     * @return amount The actual amount of collateral claimed and transferred.
     *
     * @custom:requirements
     * - `msg.sender` MUST be the vault or the account itself.
     * - The claimable amount MUST be greater than zero.
     * - There MUST be claimable withdrawals for the given account.
     *
     * @custom:effects
     * - Emits a `Claimed` event.
     */
    function claim(address account, address recipient, uint256 maxAmount)
        external
        returns (uint256 amount);

    function transferPendingAssets(address recipient, uint256 assets) external;

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

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

pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/ERC4626.sol)

pragma solidity ^0.8.20;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import {ERC20Upgradeable} from "../ERC20Upgradeable.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {IERC4626} from "@openzeppelin/contracts/interfaces/IERC4626.sol";
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
import {Initializable} from "../../../proxy/utils/Initializable.sol";

/**
 * @dev Implementation of the ERC4626 "Tokenized Vault Standard" as defined in
 * https://eips.ethereum.org/EIPS/eip-4626[EIP-4626].
 *
 * This extension allows the minting and burning of "shares" (represented using the ERC20 inheritance) in exchange for
 * underlying "assets" through standardized {deposit}, {mint}, {redeem} and {burn} workflows. This contract extends
 * the ERC20 standard. Any additional extensions included along it would affect the "shares" token represented by this
 * contract and not the "assets" token which is an independent contract.
 *
 * [CAUTION]
 * ====
 * In empty (or nearly empty) ERC-4626 vaults, deposits are at high risk of being stolen through frontrunning
 * with a "donation" to the vault that inflates the price of a share. This is variously known as a donation or inflation
 * attack and is essentially a problem of slippage. Vault deployers can protect against this attack by making an initial
 * deposit of a non-trivial amount of the asset, such that price manipulation becomes infeasible. Withdrawals may
 * similarly be affected by slippage. Users can protect against this attack as well as unexpected slippage in general by
 * verifying the amount received is as expected, using a wrapper that performs these checks such as
 * https://github.com/fei-protocol/ERC4626#erc4626router-and-base[ERC4626Router].
 *
 * Since v4.9, this implementation uses virtual assets and shares to mitigate that risk. The `_decimalsOffset()`
 * corresponds to an offset in the decimal representation between the underlying asset's decimals and the vault
 * decimals. This offset also determines the rate of virtual shares to virtual assets in the vault, which itself
 * determines the initial exchange rate. While not fully preventing the attack, analysis shows that the default offset
 * (0) makes it non-profitable, as a result of the value being captured by the virtual shares (out of the attacker's
 * donation) matching the attacker's expected gains. With a larger offset, the attack becomes orders of magnitude more
 * expensive than it is profitable. More details about the underlying math can be found
 * xref:erc4626.adoc#inflation-attack[here].
 *
 * The drawback of this approach is that the virtual shares do capture (a very small) part of the value being accrued
 * to the vault. Also, if the vault experiences losses, the users try to exit the vault, the virtual shares and assets
 * will cause the first user to exit to experience reduced losses in detriment to the last users that will experience
 * bigger losses. Developers willing to revert back to the pre-v4.9 behavior just need to override the
 * `_convertToShares` and `_convertToAssets` functions.
 *
 * To learn more, check out our xref:ROOT:erc4626.adoc[ERC-4626 guide].
 * ====
 */
abstract contract ERC4626Upgradeable is Initializable, ERC20Upgradeable, IERC4626 {
    using Math for uint256;

    /// @custom:storage-location erc7201:openzeppelin.storage.ERC4626
    struct ERC4626Storage {
        IERC20 _asset;
        uint8 _underlyingDecimals;
    }

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.ERC4626")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant ERC4626StorageLocation = 0x0773e532dfede91f04b12a73d3d2acd361424f41f76b4fb79f090161e36b4e00;

    function _getERC4626Storage() private pure returns (ERC4626Storage storage $) {
        assembly {
            $.slot := ERC4626StorageLocation
        }
    }

    /**
     * @dev Attempted to deposit more assets than the max amount for `receiver`.
     */
    error ERC4626ExceededMaxDeposit(address receiver, uint256 assets, uint256 max);

    /**
     * @dev Attempted to mint more shares than the max amount for `receiver`.
     */
    error ERC4626ExceededMaxMint(address receiver, uint256 shares, uint256 max);

    /**
     * @dev Attempted to withdraw more assets than the max amount for `receiver`.
     */
    error ERC4626ExceededMaxWithdraw(address owner, uint256 assets, uint256 max);

    /**
     * @dev Attempted to redeem more shares than the max amount for `receiver`.
     */
    error ERC4626ExceededMaxRedeem(address owner, uint256 shares, uint256 max);

    /**
     * @dev Set the underlying asset contract. This must be an ERC20-compatible contract (ERC20 or ERC777).
     */
    function __ERC4626_init(IERC20 asset_) internal onlyInitializing {
        __ERC4626_init_unchained(asset_);
    }

    function __ERC4626_init_unchained(IERC20 asset_) internal onlyInitializing {
        ERC4626Storage storage $ = _getERC4626Storage();
        (bool success, uint8 assetDecimals) = _tryGetAssetDecimals(asset_);
        $._underlyingDecimals = success ? assetDecimals : 18;
        $._asset = asset_;
    }

    /**
     * @dev Attempts to fetch the asset decimals. A return value of false indicates that the attempt failed in some way.
     */
    function _tryGetAssetDecimals(IERC20 asset_) private view returns (bool, uint8) {
        (bool success, bytes memory encodedDecimals) = address(asset_).staticcall(
            abi.encodeCall(IERC20Metadata.decimals, ())
        );
        if (success && encodedDecimals.length >= 32) {
            uint256 returnedDecimals = abi.decode(encodedDecimals, (uint256));
            if (returnedDecimals <= type(uint8).max) {
                return (true, uint8(returnedDecimals));
            }
        }
        return (false, 0);
    }

    /**
     * @dev Decimals are computed by adding the decimal offset on top of the underlying asset's decimals. This
     * "original" value is cached during construction of the vault contract. If this read operation fails (e.g., the
     * asset has not been created yet), a default of 18 is used to represent the underlying asset's decimals.
     *
     * See {IERC20Metadata-decimals}.
     */
    function decimals() public view virtual override(IERC20Metadata, ERC20Upgradeable) returns (uint8) {
        ERC4626Storage storage $ = _getERC4626Storage();
        return $._underlyingDecimals + _decimalsOffset();
    }

    /** @dev See {IERC4626-asset}. */
    function asset() public view virtual returns (address) {
        ERC4626Storage storage $ = _getERC4626Storage();
        return address($._asset);
    }

    /** @dev See {IERC4626-totalAssets}. */
    function totalAssets() public view virtual returns (uint256) {
        ERC4626Storage storage $ = _getERC4626Storage();
        return $._asset.balanceOf(address(this));
    }

    /** @dev See {IERC4626-convertToShares}. */
    function convertToShares(uint256 assets) public view virtual returns (uint256) {
        return _convertToShares(assets, Math.Rounding.Floor);
    }

    /** @dev See {IERC4626-convertToAssets}. */
    function convertToAssets(uint256 shares) public view virtual returns (uint256) {
        return _convertToAssets(shares, Math.Rounding.Floor);
    }

    /** @dev See {IERC4626-maxDeposit}. */
    function maxDeposit(address) public view virtual returns (uint256) {
        return type(uint256).max;
    }

    /** @dev See {IERC4626-maxMint}. */
    function maxMint(address) public view virtual returns (uint256) {
        return type(uint256).max;
    }

    /** @dev See {IERC4626-maxWithdraw}. */
    function maxWithdraw(address owner) public view virtual returns (uint256) {
        return _convertToAssets(balanceOf(owner), Math.Rounding.Floor);
    }

    /** @dev See {IERC4626-maxRedeem}. */
    function maxRedeem(address owner) public view virtual returns (uint256) {
        return balanceOf(owner);
    }

    /** @dev See {IERC4626-previewDeposit}. */
    function previewDeposit(uint256 assets) public view virtual returns (uint256) {
        return _convertToShares(assets, Math.Rounding.Floor);
    }

    /** @dev See {IERC4626-previewMint}. */
    function previewMint(uint256 shares) public view virtual returns (uint256) {
        return _convertToAssets(shares, Math.Rounding.Ceil);
    }

    /** @dev See {IERC4626-previewWithdraw}. */
    function previewWithdraw(uint256 assets) public view virtual returns (uint256) {
        return _convertToShares(assets, Math.Rounding.Ceil);
    }

    /** @dev See {IERC4626-previewRedeem}. */
    function previewRedeem(uint256 shares) public view virtual returns (uint256) {
        return _convertToAssets(shares, Math.Rounding.Floor);
    }

    /** @dev See {IERC4626-deposit}. */
    function deposit(uint256 assets, address receiver) public virtual returns (uint256) {
        uint256 maxAssets = maxDeposit(receiver);
        if (assets > maxAssets) {
            revert ERC4626ExceededMaxDeposit(receiver, assets, maxAssets);
        }

        uint256 shares = previewDeposit(assets);
        _deposit(_msgSender(), receiver, assets, shares);

        return shares;
    }

    /** @dev See {IERC4626-mint}.
     *
     * As opposed to {deposit}, minting is allowed even if the vault is in a state where the price of a share is zero.
     * In this case, the shares will be minted without requiring any assets to be deposited.
     */
    function mint(uint256 shares, address receiver) public virtual returns (uint256) {
        uint256 maxShares = maxMint(receiver);
        if (shares > maxShares) {
            revert ERC4626ExceededMaxMint(receiver, shares, maxShares);
        }

        uint256 assets = previewMint(shares);
        _deposit(_msgSender(), receiver, assets, shares);

        return assets;
    }

    /** @dev See {IERC4626-withdraw}. */
    function withdraw(uint256 assets, address receiver, address owner) public virtual returns (uint256) {
        uint256 maxAssets = maxWithdraw(owner);
        if (assets > maxAssets) {
            revert ERC4626ExceededMaxWithdraw(owner, assets, maxAssets);
        }

        uint256 shares = previewWithdraw(assets);
        _withdraw(_msgSender(), receiver, owner, assets, shares);

        return shares;
    }

    /** @dev See {IERC4626-redeem}. */
    function redeem(uint256 shares, address receiver, address owner) public virtual returns (uint256) {
        uint256 maxShares = maxRedeem(owner);
        if (shares > maxShares) {
            revert ERC4626ExceededMaxRedeem(owner, shares, maxShares);
        }

        uint256 assets = previewRedeem(shares);
        _withdraw(_msgSender(), receiver, owner, assets, shares);

        return assets;
    }

    /**
     * @dev Internal conversion function (from assets to shares) with support for rounding direction.
     */
    function _convertToShares(uint256 assets, Math.Rounding rounding) internal view virtual returns (uint256) {
        return assets.mulDiv(totalSupply() + 10 ** _decimalsOffset(), totalAssets() + 1, rounding);
    }

    /**
     * @dev Internal conversion function (from shares to assets) with support for rounding direction.
     */
    function _convertToAssets(uint256 shares, Math.Rounding rounding) internal view virtual returns (uint256) {
        return shares.mulDiv(totalAssets() + 1, totalSupply() + 10 ** _decimalsOffset(), rounding);
    }

    /**
     * @dev Deposit/mint common workflow.
     */
    function _deposit(address caller, address receiver, uint256 assets, uint256 shares) internal virtual {
        ERC4626Storage storage $ = _getERC4626Storage();
        // If _asset is ERC777, `transferFrom` can trigger a reentrancy BEFORE the transfer happens through the
        // `tokensToSend` hook. On the other hand, the `tokenReceived` hook, that is triggered after the transfer,
        // calls the vault, which is assumed not malicious.
        //
        // Conclusion: we need to do the transfer before we mint so that any reentrancy would happen before the
        // assets are transferred and before the shares are minted, which is a valid state.
        // slither-disable-next-line reentrancy-no-eth
        SafeERC20.safeTransferFrom($._asset, caller, address(this), assets);
        _mint(receiver, shares);

        emit Deposit(caller, receiver, assets, shares);
    }

    /**
     * @dev Withdraw/redeem common workflow.
     */
    function _withdraw(
        address caller,
        address receiver,
        address owner,
        uint256 assets,
        uint256 shares
    ) internal virtual {
        ERC4626Storage storage $ = _getERC4626Storage();
        if (caller != owner) {
            _spendAllowance(owner, caller, shares);
        }

        // If _asset is ERC777, `transfer` can trigger a reentrancy AFTER the transfer happens through the
        // `tokensReceived` hook. On the other hand, the `tokensToSend` hook, that is triggered before the transfer,
        // calls the vault, which is assumed not malicious.
        //
        // Conclusion: we need to do the transfer after the burn so that any reentrancy would happen after the
        // shares are burned and after the assets are transferred, which is a valid state.
        _burn(owner, shares);
        SafeERC20.safeTransfer($._asset, receiver, assets);

        emit Withdraw(caller, receiver, owner, assets, shares);
    }

    function _decimalsOffset() internal view virtual returns (uint8) {
        return 0;
    }
}

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

pragma solidity ^0.8.20;

import {IERC20} from "../IERC20.sol";
import {IERC20Permit} from "../extensions/IERC20Permit.sol";
import {Address} from "../../../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 An operation with an ERC20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    /**
     * @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.encodeCall(token.transfer, (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.encodeCall(token.transferFrom, (from, to, 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);
        forceApprove(token, spender, oldAllowance + value);
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

    /**
     * @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.encodeCall(token.approve, (spender, value));

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

    /**
     * @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);
        if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @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(token).code.length > 0;
    }
}

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

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedInnerCall();

    /**
     * @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.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert AddressInsufficientBalance(address(this));
        }

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

    /**
     * @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 or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {FailedInnerCall} error.
     *
     * 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.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @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`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

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

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

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
     * unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {FailedInnerCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
     */
    function _revert(bytes memory returndata) 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 FailedInnerCall();
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.

pragma solidity ^0.8.20;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```solidity
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableSet.
 * ====
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position is the index of the value in the `values` array plus 1.
        // Position 0 is used to mean a value is not in the set.
        mapping(bytes32 value => uint256) _positions;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._positions[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We cache the value's position to prevent multiple reads from the same storage slot
        uint256 position = set._positions[value];

        if (position != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 valueIndex = position - 1;
            uint256 lastIndex = set._values.length - 1;

            if (valueIndex != lastIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the lastValue to the index where the value to delete is
                set._values[valueIndex] = lastValue;
                // Update the tracked position of the lastValue (that was just moved)
                set._positions[lastValue] = position;
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the tracked position for the deleted slot
            delete set._positions[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._positions[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will 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. Developers 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 set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will 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. Developers 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 set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        bytes32[] memory store = _values(set._inner);
        bytes32[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will 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. Developers 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 set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will 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. Developers 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 set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import {ContextUpgradeable} from "../../utils/ContextUpgradeable.sol";
import {IERC20Errors} from "@openzeppelin/contracts/interfaces/draft-IERC6093.sol";
import {Initializable} from "../../proxy/utils/Initializable.sol";

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 */
abstract contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20, IERC20Metadata, IERC20Errors {
    /// @custom:storage-location erc7201:openzeppelin.storage.ERC20
    struct ERC20Storage {
        mapping(address account => uint256) _balances;

        mapping(address account => mapping(address spender => uint256)) _allowances;

        uint256 _totalSupply;

        string _name;
        string _symbol;
    }

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.ERC20")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant ERC20StorageLocation = 0x52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace00;

    function _getERC20Storage() private pure returns (ERC20Storage storage $) {
        assembly {
            $.slot := ERC20StorageLocation
        }
    }

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    function __ERC20_init(string memory name_, string memory symbol_) internal onlyInitializing {
        __ERC20_init_unchained(name_, symbol_);
    }

    function __ERC20_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
        ERC20Storage storage $ = _getERC20Storage();
        $._name = name_;
        $._symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual returns (string memory) {
        ERC20Storage storage $ = _getERC20Storage();
        return $._name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual returns (string memory) {
        ERC20Storage storage $ = _getERC20Storage();
        return $._symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the default value returned by this function, unless
     * it's overridden.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual returns (uint256) {
        ERC20Storage storage $ = _getERC20Storage();
        return $._totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual returns (uint256) {
        ERC20Storage storage $ = _getERC20Storage();
        return $._balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `value`.
     */
    function transfer(address to, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, value);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual returns (uint256) {
        ERC20Storage storage $ = _getERC20Storage();
        return $._allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, value);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `value`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `value`.
     */
    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, value);
        _transfer(from, to, value);
        return true;
    }

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _transfer(address from, address to, uint256 value) internal {
        if (from == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        if (to == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(from, to, value);
    }

    /**
     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
     * this function.
     *
     * Emits a {Transfer} event.
     */
    function _update(address from, address to, uint256 value) internal virtual {
        ERC20Storage storage $ = _getERC20Storage();
        if (from == address(0)) {
            // Overflow check required: The rest of the code assumes that totalSupply never overflows
            $._totalSupply += value;
        } else {
            uint256 fromBalance = $._balances[from];
            if (fromBalance < value) {
                revert ERC20InsufficientBalance(from, fromBalance, value);
            }
            unchecked {
                // Overflow not possible: value <= fromBalance <= totalSupply.
                $._balances[from] = fromBalance - value;
            }
        }

        if (to == address(0)) {
            unchecked {
                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
                $._totalSupply -= value;
            }
        } else {
            unchecked {
                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
                $._balances[to] += value;
            }
        }

        emit Transfer(from, to, value);
    }

    /**
     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
     * Relies on the `_update` mechanism
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _mint(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(address(0), account, value);
    }

    /**
     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
     * Relies on the `_update` mechanism.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead
     */
    function _burn(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        _update(account, address(0), value);
    }

    /**
     * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address owner, address spender, uint256 value) internal {
        _approve(owner, spender, value, true);
    }

    /**
     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
     *
     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
     * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
     * `Approval` event during `transferFrom` operations.
     *
     * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
     * true using the following override:
     * ```
     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
     *     super._approve(owner, spender, value, true);
     * }
     * ```
     *
     * Requirements are the same as {_approve}.
     */
    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
        ERC20Storage storage $ = _getERC20Storage();
        if (owner == address(0)) {
            revert ERC20InvalidApprover(address(0));
        }
        if (spender == address(0)) {
            revert ERC20InvalidSpender(address(0));
        }
        $._allowances[owner][spender] = value;
        if (emitEvent) {
            emit Approval(owner, spender, value);
        }
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `value`.
     *
     * Does not update the allowance value in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Does not emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            if (currentAllowance < value) {
                revert ERC20InsufficientAllowance(spender, currentAllowance, value);
            }
            unchecked {
                _approve(owner, spender, currentAllowance - value, false);
            }
        }
    }
}

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

pragma solidity ^0.8.20;

/**
 * @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 v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;
import {Initializable} from "../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;
    }

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}

{
  "remappings": [
    "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    "@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
    "@symbiotic/core/=lib/core/src/",
    "@symbiotic/core-test/=lib/core/test/",
    "@symbiotic/rewards/=lib/rewards/src/",
    "@symbiotic/burners/=lib/burners/src/",
    "@eigenlayer-interfaces/=lib/eigenlayer-contracts/src/contracts/interfaces/",
    "@eigenlayer-src/=lib/eigenlayer-contracts/src/contracts/",
    "@openzeppelin-upgrades-v4.9.0/=lib/eigenlayer-contracts/lib/openzeppelin-contracts-upgradeable-v4.9.0/",
    "@openzeppelin-upgrades/=lib/eigenlayer-contracts/lib/openzeppelin-contracts-upgradeable/",
    "@openzeppelin-v4.9.0/=lib/eigenlayer-contracts/lib/openzeppelin-contracts-v4.9.0/",
    "@symbioticfi/core/=lib/burners/lib/core/",
    "burners/=lib/burners/",
    "core/=lib/core/",
    "ds-test/=lib/eigenlayer-contracts/lib/ds-test/src/",
    "eigenlayer-contracts/=lib/eigenlayer-contracts/",
    "erc4626-tests/=lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/",
    "forge-std/=lib/forge-std/src/",
    "openzeppelin-contracts-upgradeable-v4.9.0/=lib/eigenlayer-contracts/lib/openzeppelin-contracts-upgradeable-v4.9.0/",
    "openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
    "openzeppelin-contracts-v4.9.0/=lib/eigenlayer-contracts/lib/openzeppelin-contracts-v4.9.0/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/",
    "openzeppelin/=lib/eigenlayer-contracts/lib/openzeppelin-contracts-v4.9.0/contracts/",
    "rewards/=lib/rewards/",
    "zeus-templates/=lib/eigenlayer-contracts/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": "shanghai",
  "viaIR": false,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"vault","type":"address"},{"indexed":false,"internalType":"address[]","name":"subvaults","type":"address[]"},{"components":[{"internalType":"uint64","name":"minRatioD18","type":"uint64"},{"internalType":"uint64","name":"maxRatioD18","type":"uint64"}],"indexed":false,"internalType":"struct IRatiosStrategy.Ratio[]","name":"ratios","type":"tuple[]"}],"name":"RatiosSet","type":"event"},{"inputs":[],"name":"D18","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"RATIOS_STRATEGY_SET_RATIOS_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"vault","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"calculateDepositAmounts","outputs":[{"components":[{"internalType":"uint256","name":"subvaultIndex","type":"uint256"},{"internalType":"uint256","name":"deposit","type":"uint256"}],"internalType":"struct IDepositStrategy.DepositData[]","name":"data","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"vault","type":"address"}],"name":"calculateRebalanceAmounts","outputs":[{"components":[{"internalType":"uint256","name":"subvaultIndex","type":"uint256"},{"internalType":"uint256","name":"deposit","type":"uint256"},{"internalType":"uint256","name":"claimable","type":"uint256"},{"internalType":"uint256","name":"staked","type":"uint256"}],"internalType":"struct IRebalanceStrategy.RebalanceData[]","name":"data","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"vault","type":"address"},{"internalType":"bool","name":"isDeposit","type":"bool"},{"internalType":"uint256","name":"increment","type":"uint256"}],"name":"calculateState","outputs":[{"components":[{"internalType":"uint256","name":"min","type":"uint256"},{"internalType":"uint256","name":"max","type":"uint256"},{"internalType":"uint256","name":"claimable","type":"uint256"},{"internalType":"uint256","name":"pending","type":"uint256"},{"internalType":"uint256","name":"staked","type":"uint256"}],"internalType":"struct IRatiosStrategy.Amounts[]","name":"state","type":"tuple[]"},{"internalType":"uint256","name":"liquid","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"vault","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"calculateWithdrawalAmounts","outputs":[{"components":[{"internalType":"uint256","name":"subvaultIndex","type":"uint256"},{"internalType":"uint256","name":"claimable","type":"uint256"},{"internalType":"uint256","name":"pending","type":"uint256"},{"internalType":"uint256","name":"staked","type":"uint256"}],"internalType":"struct IWithdrawalStrategy.WithdrawalData[]","name":"data","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"vault","type":"address"},{"internalType":"address","name":"subvault","type":"address"}],"name":"ratios","outputs":[{"internalType":"uint64","name":"minRatioD18","type":"uint64"},{"internalType":"uint64","name":"maxRatioD18","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"vault","type":"address"},{"internalType":"address[]","name":"subvaults","type":"address[]"},{"components":[{"internalType":"uint64","name":"minRatioD18","type":"uint64"},{"internalType":"uint64","name":"maxRatioD18","type":"uint64"}],"internalType":"struct IRatiosStrategy.Ratio[]","name":"ratios_","type":"tuple[]"}],"name":"setRatios","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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