Echidna Coverage Report

89.0% lib/erc7540-reusable-properties/src/ERC7540Properties.sol

Lines covered: 111 / 124 (89.0%)

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity ^0.8.21;

import {Asserts} from "@chimera/Asserts.sol";

interface IShareLike {
    function balanceOf(address) external view returns (uint256);
    function totalSupply() external view returns (uint256);
    function decimals() external view returns (uint8);
}

interface IERC7540Like {
    function share() external view returns (address shareTokenAddress);
    function convertToShares(
        uint256 assets
    ) external view returns (uint256 shares);
    function convertToAssets(
        uint256 shares
    ) external view returns (uint256 assets);
    function totalAssets() external view returns (uint256 totalManagedAssets);
    function maxDeposit(
        address receiver
    ) external view returns (uint256 maxAssets);
    function previewDeposit(
        uint256 assets
    ) external view returns (uint256 shares);
    function deposit(
        uint256 assets,
        address receiver
    ) external returns (uint256 shares);
    function maxMint(
        address receiver
    ) external view returns (uint256 maxShares);
    function previewMint(uint256 shares) external view returns (uint256 assets);
    function mint(
        uint256 shares,
        address receiver
    ) external returns (uint256 assets);
    function maxWithdraw(
        address owner
    ) external view returns (uint256 maxAssets);
    function previewWithdraw(
        uint256 assets
    ) external view returns (uint256 shares);
    function withdraw(
        uint256 assets,
        address receiver,
        address owner
    ) external returns (uint256 shares);
    function maxRedeem(address owner) external view returns (uint256 maxShares);
    function previewRedeem(
        uint256 shares
    ) external view returns (uint256 assets);
    function redeem(
        uint256 shares,
        address receiver,
        address owner
    ) external returns (uint256 assets);

    function requestRedeem(
        uint256 shares,
        address receiver,
        address owner,
        bytes calldata data
    ) external returns (uint256 requestId);
}

/// @dev ERC-7540 Properties
/// @author The Recon Team
/// @notice A set of reuseable tests for your ERC7540 Vaults
///     To get started, extend from this contract and make sure to add a way to set the actor (the current user)
///     For more info: https://getrecon.xyz/
abstract contract ERC7540Properties is Asserts {
    uint256 public constant MAX_ROUNDING_ERROR = 10 ** 18;

    address actor;

    /// @audit TODO: You must add a way to change this!

    /// @dev 7540-1	convertToAssets(totalSupply) == totalAssets unless price is 0.0
    function erc7540_1(address erc7540Target) public virtual returns (bool) {
        // Doesn't hold on zero price
        if (
            IERC7540Like(erc7540Target).convertToAssets(
                10 ** IShareLike(IERC7540Like(erc7540Target).share()).decimals()
            ) == 0
        ) return true;

        return
            IERC7540Like(erc7540Target).convertToAssets(
                IShareLike(IERC7540Like(erc7540Target).share()).totalSupply()
            ) == IERC7540Like(erc7540Target).totalAssets();
    }

    /// @dev 7540-2	convertToShares(totalAssets) == totalSupply unless price is 0.0
    function erc7540_2(address erc7540Target) public virtual returns (bool) {
        if (
            IERC7540Like(erc7540Target).convertToAssets(
                10 ** IShareLike(IERC7540Like(erc7540Target).share()).decimals()
            ) == 0
        ) return true;

        // convertToShares(totalAssets) == totalSupply
        return
            _diff(
                IERC7540Like(erc7540Target).convertToShares(
                    IERC7540Like(erc7540Target).totalAssets()
                ),
                IShareLike(IERC7540Like(erc7540Target).share()).totalSupply()
            ) <= MAX_ROUNDING_ERROR;
    }

    function _diff(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a - b : b - a;
    }

    /// @dev 7540-3	max* never reverts
    function erc7540_3(address erc7540Target) public virtual returns (bool) {
        // max* never reverts
        try IERC7540Like(erc7540Target).maxDeposit(actor) {} catch {
            return false;
        }
        try IERC7540Like(erc7540Target).maxMint(actor) {} catch {
            return false;
        }
        try IERC7540Like(erc7540Target).maxRedeem(actor) {} catch {
            return false;
        }
        try IERC7540Like(erc7540Target).maxWithdraw(actor) {} catch {
            return false;
        }

        return true;
    }

    /// == erc7540_4 == //

    /// @dev 7540-4 claiming more than max always reverts
    function erc7540_4_deposit(
        address erc7540Target,
        uint256 amt
    ) public virtual returns (bool) {
        // Skip 0
        if (amt == 0) {
            return true; // Skip
        }

        uint256 maxDep = IERC7540Like(erc7540Target).maxDeposit(actor);

        /// @audit No Revert is proven by erc7540_5

        uint256 sum = maxDep + amt;
        if (sum == 0) {
            return true; // Needs to be greater than 0, skip
        }

        try IERC7540Like(erc7540Target).deposit(maxDep + amt, actor) {
            return false;
        } catch {
            // We want this to be hit
            return true; // So we explicitly return here, as a means to ensure that this is the code path
        }

        // NOTE: This code path is never hit per the above
    }

    function erc7540_4_mint(
        address erc7540Target,
        uint256 amt
    ) public virtual returns (bool) {
        // Skip 0
        if (amt == 0) {
            return true;
        }

        uint256 maxDep = IERC7540Like(erc7540Target).maxMint(actor);

        uint256 sum = maxDep + amt;
        if (sum == 0) {
            return true; // Needs to be greater than 0, skip
        }

        try IERC7540Like(erc7540Target).mint(maxDep + amt, actor) {
            return false;
        } catch {
            // We want this to be hit
            return true; // So we explicitly return here, as a means to ensure that this is the code path
        }

        // NOTE: This code path is never hit per the above
    }

    function erc7540_4_withdraw(
        address erc7540Target,
        uint256 amt
    ) public virtual returns (bool) {
        // Skip 0
        if (amt == 0) {
            return true;
        }

        uint256 maxDep = IERC7540Like(erc7540Target).maxWithdraw(actor);

        uint256 sum = maxDep + amt;
        if (sum == 0) {
            return true; // Needs to be greater than 0
        }

        try IERC7540Like(erc7540Target).withdraw(maxDep + amt, actor, actor) {
            return false;
        } catch {
            // We want this to be hit
            return true; // So we explicitly return here, as a means to ensure that this is the code path
        }

        // NOTE: This code path is never hit per the above
    }

    function erc7540_4_redeem(
        address erc7540Target,
        uint256 amt
    ) public virtual returns (bool) {
        // Skip 0
        if (amt == 0) {
            return true;
        }

        uint256 maxDep = IERC7540Like(erc7540Target).maxRedeem(actor);

        uint256 sum = maxDep + amt;
        if (sum == 0) {
            return true; // Needs to be greater than 0
        }

        try IERC7540Like(erc7540Target).redeem(maxDep + amt, actor, actor) {
            return false;
        } catch {
            // We want this to be hit
            return true; // So we explicitly return here, as a means to ensure that this is the code path
        }

        // NOTE: This code path is never hit per the above
    }

    /// == END erc7540_4 == //

    /// @dev 7540-5	requestRedeem reverts if the share balance is less than amount
    function erc7540_5(
        address erc7540Target,
        address shareToken,
        uint256 shares
    ) public virtual returns (bool) {
        if (shares == 0) {
            return true; // Skip
        }

        uint256 actualBal = IShareLike(shareToken).balanceOf(actor);
        uint256 balWeWillUse = actualBal + shares;

        if (balWeWillUse == 0) {
            return true; // Skip
        }

        try
            IERC7540Like(erc7540Target).requestRedeem(
                balWeWillUse,
                actor,
                actor,
                ""
            )
        {
            return false;
        } catch {
            return true;
        }

        // NOTE: This code path is never hit per the above
    }

    /// @dev 7540-6	preview* always reverts
    function erc7540_6(address erc7540Target) public virtual returns (bool) {
        // preview* always reverts
        try IERC7540Like(erc7540Target).previewDeposit(0) {
            return false;
        } catch {}
        try IERC7540Like(erc7540Target).previewMint(0) {
            return false;
        } catch {}
        try IERC7540Like(erc7540Target).previewRedeem(0) {
            return false;
        } catch {}
        try IERC7540Like(erc7540Target).previewWithdraw(0) {
            return false;
        } catch {}

        return true;
    }

    /// == erc7540_7 == //

    /// @dev 7540-7 if max[method] > 0, then [method] (max) should not revert
    function erc7540_7_deposit(
        address erc7540Target,
        uint256 amt
    ) public virtual returns (bool) {
        // Per erc7540_4
        uint256 maxDeposit = IERC7540Like(erc7540Target).maxDeposit(actor);
        amt = between(amt, 0, maxDeposit);

        if (amt == 0) {
            return true; // Skip
        }

        try IERC7540Like(erc7540Target).deposit(amt, actor) {
            // Success here
            return true;
        } catch {
            return false;
        }

        // NOTE: This code path is never hit per the above
    }

    function erc7540_7_mint(
        address erc7540Target,
        uint256 amt
    ) public virtual returns (bool) {
        uint256 maxMint = IERC7540Like(erc7540Target).maxMint(actor);
        amt = between(amt, 0, maxMint);

        if (amt == 0) {
            return true; // Skip
        }

        try IERC7540Like(erc7540Target).mint(amt, actor) {
            // Success here
            return true;
        } catch {
            return false;
        }

        // NOTE: This code path is never hit per the above
    }

    function erc7540_7_withdraw(
        address erc7540Target,
        uint256 amt
    ) public virtual returns (bool) {
        uint256 maxWithdraw = IERC7540Like(erc7540Target).maxWithdraw(actor);
        amt = between(amt, 0, maxWithdraw);

        if (amt == 0) {
            return true; // Skip
        }

        try IERC7540Like(erc7540Target).withdraw(amt, actor, actor) {
            // Success here
            return true;
        } catch {
            return false;
        }

        // NOTE: This code path is never hit per the above
    }

    function erc7540_7_redeem(
        address erc7540Target,
        uint256 amt
    ) public virtual returns (bool) {
        // Per erc7540_4
        uint256 maxRedeem = IERC7540Like(erc7540Target).maxRedeem(actor);
        amt = between(amt, 0, maxRedeem);

        if (amt == 0) {
            return true; // Skip
        }

        try IERC7540Like(erc7540Target).redeem(amt, actor, actor) {
            return true;
        } catch {
            return false;
        }

        // NOTE: This code path is never hit per the above
    }

    /// == END erc7540_7 == //
}


90.0% lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol

Lines covered: 27 / 30 (90.0%)

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.3.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 reinitialization) 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 Pointer to storage slot. Allows integrators to override it with a custom storage location.
     *
     * NOTE: Consider following the ERC-7201 formula to derive storage locations.
     */
    function _initializableStorageSlot() internal pure virtual returns (bytes32) {
        return INITIALIZABLE_STORAGE;
    }

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


83.0% lib/openzeppelin-contracts-upgradeable/contracts/token/ERC20/ERC20Upgradeable.sol

Lines covered: 56 / 67 (83.0%)

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.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 ERC-20
 * applications.
 */
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}.
     *
     * Both 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;
    }

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

    /// @inheritdoc IERC20
    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;
    }

    /// @inheritdoc IERC20
    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}.
     *
     * Skips emitting an {Approval} event indicating an allowance update. This is not
     * required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve].
     *
     * 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:
     *
     * ```solidity
     * 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);
            }
        }
    }
}


100.0% lib/openzeppelin-contracts-upgradeable/contracts/utils/ContextUpgradeable.sol

Lines covered: 1 / 1 (100.0%)

// 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;
    }
}


92.0% lib/openzeppelin-contracts-upgradeable/contracts/utils/ReentrancyGuardUpgradeable.sol

Lines covered: 12 / 13 (92.0%)

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

pragma solidity ^0.8.20;
import {Initializable} from "../proxy/utils/Initializable.sol";

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

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

    /// @custom:storage-location erc7201:openzeppelin.storage.ReentrancyGuard
    struct ReentrancyGuardStorage {
        uint256 _status;
    }

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.ReentrancyGuard")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant ReentrancyGuardStorageLocation = 0x9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00;

    function _getReentrancyGuardStorage() private pure returns (ReentrancyGuardStorage storage $) {
        assembly {
            $.slot := ReentrancyGuardStorageLocation
        }
    }

    /**
     * @dev Unauthorized reentrant call.
     */
    error ReentrancyGuardReentrantCall();

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

    function __ReentrancyGuard_init_unchained() internal onlyInitializing {
        ReentrancyGuardStorage storage $ = _getReentrancyGuardStorage();
        $._status = NOT_ENTERED;
    }

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

    function _nonReentrantBefore() private {
        ReentrancyGuardStorage storage $ = _getReentrancyGuardStorage();
        // On the first call to nonReentrant, _status will be NOT_ENTERED
        if ($._status == ENTERED) {
            revert ReentrancyGuardReentrantCall();
        }

        // Any calls to nonReentrant after this point will fail
        $._status = ENTERED;
    }

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

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


17.0% lib/openzeppelin-contracts-upgradeable/contracts/utils/cryptography/EIP712Upgradeable.sol

Lines covered: 8 / 47 (17.0%)

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (utils/cryptography/EIP712.sol)

pragma solidity ^0.8.20;

import {MessageHashUtils} from "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";
import {IERC5267} from "@openzeppelin/contracts/interfaces/IERC5267.sol";
import {Initializable} from "../../proxy/utils/Initializable.sol";

/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP-712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding scheme specified in the EIP requires a domain separator and a hash of the typed structured data, whose
 * encoding is very generic and therefore its implementation in Solidity is not feasible, thus this contract
 * does not implement the encoding itself. Protocols need to implement the type-specific encoding they need in order to
 * produce the hash of their typed data using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP-712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * NOTE: The upgradeable version of this contract does not use an immutable cache and recomputes the domain separator
 * each time {_domainSeparatorV4} is called. That is cheaper than accessing a cached version in cold storage.
 */
abstract contract EIP712Upgradeable is Initializable, IERC5267 {
    bytes32 private constant TYPE_HASH =
        keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");

    /// @custom:storage-location erc7201:openzeppelin.storage.EIP712
    struct EIP712Storage {
        /// @custom:oz-renamed-from _HASHED_NAME
        bytes32 _hashedName;
        /// @custom:oz-renamed-from _HASHED_VERSION
        bytes32 _hashedVersion;

        string _name;
        string _version;
    }

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.EIP712")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant EIP712StorageLocation = 0xa16a46d94261c7517cc8ff89f61c0ce93598e3c849801011dee649a6a557d100;

    function _getEIP712Storage() private pure returns (EIP712Storage storage $) {
        assembly {
            $.slot := EIP712StorageLocation
        }
    }

    /**
     * @dev Initializes the domain separator and parameter caches.
     *
     * The meaning of `name` and `version` is specified in
     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP-712]:
     *
     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
     * - `version`: the current major version of the signing domain.
     *
     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
     * contract upgrade].
     */
    function __EIP712_init(string memory name, string memory version) internal onlyInitializing {
        __EIP712_init_unchained(name, version);
    }

    function __EIP712_init_unchained(string memory name, string memory version) internal onlyInitializing {
        EIP712Storage storage $ = _getEIP712Storage();
        $._name = name;
        $._version = version;

        // Reset prior values in storage if upgrading
        $._hashedName = 0;
        $._hashedVersion = 0;
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        return _buildDomainSeparator();
    }

    function _buildDomainSeparator() private view returns (bytes32) {
        return keccak256(abi.encode(TYPE_HASH, _EIP712NameHash(), _EIP712VersionHash(), block.chainid, address(this)));
    }

    /**
     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
     * function returns the hash of the fully encoded EIP712 message for this domain.
     *
     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
     *
     * ```solidity
     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
     *     keccak256("Mail(address to,string contents)"),
     *     mailTo,
     *     keccak256(bytes(mailContents))
     * )));
     * address signer = ECDSA.recover(digest, signature);
     * ```
     */
    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
        return MessageHashUtils.toTypedDataHash(_domainSeparatorV4(), structHash);
    }

    /// @inheritdoc IERC5267
    function eip712Domain()
        public
        view
        virtual
        returns (
            bytes1 fields,
            string memory name,
            string memory version,
            uint256 chainId,
            address verifyingContract,
            bytes32 salt,
            uint256[] memory extensions
        )
    {
        EIP712Storage storage $ = _getEIP712Storage();
        // If the hashed name and version in storage are non-zero, the contract hasn't been properly initialized
        // and the EIP712 domain is not reliable, as it will be missing name and version.
        require($._hashedName == 0 && $._hashedVersion == 0, "EIP712: Uninitialized");

        return (
            hex"0f", // 01111
            _EIP712Name(),
            _EIP712Version(),
            block.chainid,
            address(this),
            bytes32(0),
            new uint256[](0)
        );
    }

    /**
     * @dev The name parameter for the EIP712 domain.
     *
     * NOTE: This function reads from storage by default, but can be redefined to return a constant value if gas costs
     * are a concern.
     */
    function _EIP712Name() internal view virtual returns (string memory) {
        EIP712Storage storage $ = _getEIP712Storage();
        return $._name;
    }

    /**
     * @dev The version parameter for the EIP712 domain.
     *
     * NOTE: This function reads from storage by default, but can be redefined to return a constant value if gas costs
     * are a concern.
     */
    function _EIP712Version() internal view virtual returns (string memory) {
        EIP712Storage storage $ = _getEIP712Storage();
        return $._version;
    }

    /**
     * @dev The hash of the name parameter for the EIP712 domain.
     *
     * NOTE: In previous versions this function was virtual. In this version you should override `_EIP712Name` instead.
     */
    function _EIP712NameHash() internal view returns (bytes32) {
        EIP712Storage storage $ = _getEIP712Storage();
        string memory name = _EIP712Name();
        if (bytes(name).length > 0) {
            return keccak256(bytes(name));
        } else {
            // If the name is empty, the contract may have been upgraded without initializing the new storage.
            // We return the name hash in storage if non-zero, otherwise we assume the name is empty by design.
            bytes32 hashedName = $._hashedName;
            if (hashedName != 0) {
                return hashedName;
            } else {
                return keccak256("");
            }
        }
    }

    /**
     * @dev The hash of the version parameter for the EIP712 domain.
     *
     * NOTE: In previous versions this function was virtual. In this version you should override `_EIP712Version` instead.
     */
    function _EIP712VersionHash() internal view returns (bytes32) {
        EIP712Storage storage $ = _getEIP712Storage();
        string memory version = _EIP712Version();
        if (bytes(version).length > 0) {
            return keccak256(bytes(version));
        } else {
            // If the version is empty, the contract may have been upgraded without initializing the new storage.
            // We return the version hash in storage if non-zero, otherwise we assume the version is empty by design.
            bytes32 hashedVersion = $._hashedVersion;
            if (hashedVersion != 0) {
                return hashedVersion;
            } else {
                return keccak256("");
            }
        }
    }
}


0.0% lib/setup-helpers/lib/chimera/src/Asserts.sol

Lines covered: 0 / 0 (0.0%)

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

abstract contract Asserts {
    function gt(uint256 a, uint256 b, string memory reason) internal virtual;

    function gte(uint256 a, uint256 b, string memory reason) internal virtual;

    function lt(uint256 a, uint256 b, string memory reason) internal virtual;

    function lte(uint256 a, uint256 b, string memory reason) internal virtual;

    function eq(uint256 a, uint256 b, string memory reason) internal virtual;

    function t(bool b, string memory reason) internal virtual;

    function between(uint256 value, uint256 low, uint256 high) internal virtual returns (uint256);

    function between(int256 value, int256 low, int256 high) internal virtual returns (int256);

    function precondition(bool p) internal virtual;
}


0.0% lib/setup-helpers/lib/chimera/src/BaseProperties.sol

Lines covered: 0 / 0 (0.0%)

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

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

abstract contract BaseProperties is BaseSetup {}


0.0% lib/setup-helpers/lib/chimera/src/BaseSetup.sol

Lines covered: 0 / 0 (0.0%)

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

abstract contract BaseSetup {
    function setup() internal virtual;
}


0.0% lib/setup-helpers/lib/chimera/src/BaseTargetFunctions.sol

Lines covered: 0 / 0 (0.0%)

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

import {BaseProperties} from "./BaseProperties.sol";
import {Asserts} from "./Asserts.sol";

abstract contract BaseTargetFunctions is BaseProperties, Asserts {}


91.0% lib/setup-helpers/lib/chimera/src/CryticAsserts.sol

Lines covered: 21 / 23 (91.0%)

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

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

contract CryticAsserts is Asserts {
    event Log(string);

    function gt(uint256 a, uint256 b, string memory reason) internal virtual override {
        if (!(a > b)) {
            emit Log(reason);
            assert(false);
        }
    }

    function gte(uint256 a, uint256 b, string memory reason) internal virtual override {
        if (!(a >= b)) {
            emit Log(reason);
            assert(false);
        }
    }

    function lt(uint256 a, uint256 b, string memory reason) internal virtual override {
        if (!(a < b)) {
            emit Log(reason);
            assert(false);
        }
    }

    function lte(uint256 a, uint256 b, string memory reason) internal virtual override {
        if (!(a <= b)) {
            emit Log(reason);
            assert(false);
        }
    }

    function eq(uint256 a, uint256 b, string memory reason) internal virtual override {
        if (!(a == b)) {
            emit Log(reason);
            assert(false);
        }
    }

    function t(bool b, string memory reason) internal virtual override {
        if (!b) {
            emit Log(reason);
            assert(false);
        }
    }

    function between(uint256 value, uint256 low, uint256 high) internal virtual override returns (uint256) {
        if (value < low || value > high) {
            uint256 ans = low + (value % (high - low + 1));
            return ans;
        }
        return value;
    }

    function between(int256 value, int256 low, int256 high) internal virtual override returns (int256) {
        if (value < low || value > high) {
            int256 range = high - low + 1;
            int256 clamped = (value - low) % (range);
            if (clamped < 0) clamped += range;
            int256 ans = low + clamped;
            return ans;
        }
        return value;
    }

    function precondition(bool p) internal virtual override {
        require(p);
    }
}


100.0% lib/setup-helpers/lib/chimera/src/Hevm.sol

Lines covered: 1 / 1 (100.0%)

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

// slither-disable-start shadowing-local

interface IHevm {
    // Set block.timestamp to newTimestamp
    function warp(uint256 newTimestamp) external;

    // Set block.number to newNumber
    function roll(uint256 newNumber) external;

    // Add the condition b to the assumption base for the current branch
    // This function is almost identical to require
    function assume(bool b) external;

    // Sets the eth balance of usr to amt
    function deal(address usr, uint256 amt) external;

    // Loads a storage slot from an address
    function load(address where, bytes32 slot) external returns (bytes32);

    // Stores a value to an address' storage slot
    function store(address where, bytes32 slot, bytes32 value) external;

    // Signs data (privateKey, digest) => (v, r, s)
    function sign(uint256 privateKey, bytes32 digest) external returns (uint8 v, bytes32 r, bytes32 s);

    // Gets address for a given private key
    function addr(uint256 privateKey) external returns (address addr);

    // Performs a foreign function call via terminal
    function ffi(string[] calldata inputs) external returns (bytes memory result);

    // Performs the next smart contract call with specified `msg.sender`
    function prank(address newSender) external;

    // Creates a new fork with the given endpoint and the latest block and returns the identifier of the fork
    function createFork(string calldata urlOrAlias) external returns (uint256);

    // Takes a fork identifier created by createFork and sets the corresponding forked state as active
    function selectFork(uint256 forkId) external;

    // Returns the identifier of the current fork
    function activeFork() external returns (uint256);

    // Labels the address in traces
    function label(address addr, string calldata label) external;

    /// Sets an address' code.
    function etch(address target, bytes calldata newRuntimeBytecode) external;
}

IHevm constant vm = IHevm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);

// slither-disable-end shadowing-local


86.0% lib/setup-helpers/src/ActorManager.sol

Lines covered: 13 / 15 (86.0%)

// SPDX-License-Identifier: GPL-2.0
pragma solidity ^0.8.0;

import {BaseSetup} from "@chimera/BaseSetup.sol";
import {vm} from "@chimera/Hevm.sol";
import {EnumerableSet} from "./EnumerableSet.sol";

/// @dev This is the source of truth for the actors being used in the test
/// @notice No actors should be used in the suite without being added here first
abstract contract ActorManager {
    using EnumerableSet for EnumerableSet.AddressSet;

    ///@notice The current actor being used
    address private _actor;

    ///@notice The list of all actors being used
    EnumerableSet.AddressSet private _actors;

    // If the current target is address(0) then it has not been setup yet and should revert
    error ActorNotSetup();
    // Do not allow duplicates
    error ActorExists();
    // If the actor does not exist
    error ActorNotAdded();
    // Do not allow the default actor
    error DefaultActor();

    /// @notice address(this) is the default actor
    constructor() {
        _actors.add(address(this));
        _actor = address(this);
    }

    /// @notice Returns the current active actor
    function _getActor() internal view returns (address) {
        return _actor;
    }

    /// @notice Returns all actors being used
    function _getActors() internal view returns (address[] memory) {
        return _actors.values();
    }

    /// @notice Adds an actor to the list of actors
    function _addActor(address target) internal {
        if (_actors.contains(target)) {
            revert ActorExists();
        }

        if (target == address(this)) {
            revert DefaultActor();
        }

        _actors.add(target);
    }

    /// @notice Removes an actor from the list of actors
    function _removeActor(address target) internal {
        if (!_actors.contains(target)) {
            revert ActorNotAdded();
        }

        if (target == address(this)) {
            revert DefaultActor();
        }

        _actors.remove(target);
    }

    /// @dev Expose this in the `TargetFunctions` contract to let the fuzzer switch actors
    ///   NOTE: We revert if the entropy is greater than the number of actors, for Halmos compatibility
    /// @dev This may reduce fuzzing performance if using multiple actors, if so add explicitly clamped handlers to ManagersTargets using the index of all added actors
    /// @notice Switches the current actor based on the entropy
    /// @param entropy The entropy to choose a random actor in the array for switching
    /// @return target The new active actor
    function _switchActor(uint256 entropy) internal returns (address target) {
        target = _actors.at(entropy);
        _actor = target;
    }
}


93.0% lib/setup-helpers/src/AssetManager.sol

Lines covered: 31 / 33 (93.0%)

// SPDX-License-Identifier: GPL-2.0
pragma solidity ^0.8.0;

import {BaseSetup} from "@chimera/BaseSetup.sol";
import {vm} from "@chimera/Hevm.sol";

import {EnumerableSet} from "./EnumerableSet.sol";
import {MockERC20} from "./MockERC20.sol";

/// @dev Source of truth for the assets being used in the test
/// @notice No assets should be used in the suite without being added here first
abstract contract AssetManager {
    using EnumerableSet for EnumerableSet.AddressSet;

    /// @notice The current target for this set of variables
    address private __asset;

    /// @notice The list of all assets being used
    EnumerableSet.AddressSet private _assets;

    // If the current target is address(0) then it has not been setup yet and should revert
    error NotSetup();
    // Do not allow duplicates
    error Exists();
    // Enable only added assets
    error NotAdded();

    /// @notice Returns the current active asset
    function _getAsset() internal view returns (address) {
        if (__asset == address(0)) {
            revert NotSetup();
        }

        return __asset;
    }

    /// @notice Returns all assets being used
    function _getAssets() internal view returns (address[] memory) {
        return _assets.values();
    }

    /// @notice Creates a new asset and adds it to the list of assets
    /// @param decimals The number of decimals for the asset
    /// @return The address of the new asset
    function _newAsset(uint8 decimals) internal returns (address) {
        address asset_ = address(new MockERC20("Test Token", "TST", decimals)); // If names get confusing, concatenate the decimals to the name
        _addAsset(asset_);
        __asset = asset_; // sets the asset as the current asset
        return asset_;
    }

    /// @notice Adds an asset to the list of assets
    /// @param target The address of the asset to add
    function _addAsset(address target) internal {
        if (_assets.contains(target)) {
            revert Exists();
        }

        _assets.add(target);
    }

    /// @notice Removes an asset from the list of assets
    /// @param target The address of the asset to remove
    function _removeAsset(address target) internal {
        if (!_assets.contains(target)) {
            revert NotAdded();
        }

        _assets.remove(target);
    }

    /// @notice Switches the current asset based on the entropy
    ///   NOTE: We revert if the entropy is greater than the number of actors, for Halmos compatibility
    /// @param entropy The entropy to choose a random asset in the array for switching
    function _switchAsset(uint256 entropy) internal {
        address target = _assets.at(entropy);
        __asset = target;
    }

    /// === Approve & Mint Asset === ///

    /// @notice Mint initial balance and approve allowances for the active asset
    /// @param actorsArray The array of actors to mint the asset to
    /// @param approvalArray The array of addresses to approve the asset to
    /// @param amount The amount of the asset to mint
    function _finalizeAssetDeployment(address[] memory actorsArray, address[] memory approvalArray, uint256 amount)
        internal
    {
        _mintAssetToAllActors(actorsArray, amount);
        for (uint256 i; i < approvalArray.length; i++) {
            _approveAssetToAddressForAllActors(actorsArray, approvalArray[i]);
        }
    }

    /// @notice Mint the asset to all actors
    /// @param actorsArray The array of actors to mint the asset to
    /// @param amount The amount of the asset to mint
    function _mintAssetToAllActors(address[] memory actorsArray, uint256 amount) private {
        // mint all actors
        address[] memory assets = _getAssets();
        for (uint256 i; i < assets.length; i++) {
            for (uint256 j; j < actorsArray.length; j++) {
                vm.prank(actorsArray[j]);
                MockERC20(assets[i]).mint(actorsArray[j], amount);
            }
        }
    }

    /// @notice Approve the asset to all actors
    /// @param actorsArray The array of actors to approve the asset from
    /// @param addressToApprove The address to approve the asset to
    function _approveAssetToAddressForAllActors(address[] memory actorsArray, address addressToApprove) private {
        // approve to all actors
        address[] memory assets = _getAssets();
        for (uint256 i; i < assets.length; i++) {
            for (uint256 j; j < actorsArray.length; j++) {
                vm.prank(actorsArray[j]);
                MockERC20(assets[i]).approve(addressToApprove, type(uint256).max);
            }
        }
    }
}


92.0% lib/setup-helpers/src/EnumerableSet.sol

Lines covered: 23 / 25 (92.0%)

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

pragma solidity ^0.8.0;

/**
 * @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 of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @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._indexes[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 read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 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 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

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

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastValue;
                // Update the index for the moved value
                set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
            }

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

            // Delete the index for the deleted slot
            delete set._indexes[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._indexes[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;
    }
}


73.0% lib/setup-helpers/src/MockERC20.sol

Lines covered: 55 / 75 (73.0%)

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity ^0.8.0;

/// @notice Modern and gas efficient ERC20 + EIP-2612 implementation.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC20.sol)
/// @author Modified from Uniswap (https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol)
/// @dev Do not manually set balances without updating totalSupply, as the sum of all user balances must not exceed it.
abstract contract ERC20 {
    /*//////////////////////////////////////////////////////////////
                                 ERRORS
    //////////////////////////////////////////////////////////////*/

    /// @notice Thrown when attempting to transfer more tokens than available balance
    error InsufficientBalance(address from, uint256 balance, uint256 amount);

    /// @notice Thrown when attempting to transfer more tokens than allowed
    error InsufficientAllowance(address owner, address spender, uint256 allowance, uint256 amount);

    /// @notice Thrown when minting would cause overflow
    error MintOverflow(uint256 currentSupply, uint256 amount);

    /*//////////////////////////////////////////////////////////////
                                 EVENTS
    //////////////////////////////////////////////////////////////*/

    event Transfer(address indexed from, address indexed to, uint256 amount);

    event Approval(address indexed owner, address indexed spender, uint256 amount);

    /*//////////////////////////////////////////////////////////////
                            METADATA STORAGE
    //////////////////////////////////////////////////////////////*/

    string public name;

    string public symbol;

    uint8 public immutable decimals;

    /*//////////////////////////////////////////////////////////////
                              ERC20 STORAGE
    //////////////////////////////////////////////////////////////*/

    uint256 public totalSupply;

    mapping(address => uint256) public balanceOf;

    mapping(address => mapping(address => uint256)) public allowance;

    /*//////////////////////////////////////////////////////////////
                            EIP-2612 STORAGE
    //////////////////////////////////////////////////////////////*/

    uint256 internal immutable INITIAL_CHAIN_ID;

    bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;

    mapping(address => uint256) public nonces;

    /*//////////////////////////////////////////////////////////////
                               CONSTRUCTOR
    //////////////////////////////////////////////////////////////*/

    constructor(string memory _name, string memory _symbol, uint8 _decimals) {
        name = _name;
        symbol = _symbol;
        decimals = _decimals;

        INITIAL_CHAIN_ID = block.chainid;
        INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();
    }

    /*//////////////////////////////////////////////////////////////
                               ERC20 LOGIC
    //////////////////////////////////////////////////////////////*/

    function approve(address spender, uint256 amount) public virtual returns (bool) {
        allowance[msg.sender][spender] = amount;

        emit Approval(msg.sender, spender, amount);

        return true;
    }

    function transfer(address to, uint256 amount) public virtual returns (bool) {
        uint256 fromBalance = balanceOf[msg.sender];
        if (fromBalance < amount) revert InsufficientBalance(msg.sender, fromBalance, amount);

        balanceOf[msg.sender] = fromBalance - amount;

        // Cannot overflow because the sum of all user
        // balances can't exceed the max uint256 value.
        unchecked {
            balanceOf[to] += amount;
        }

        emit Transfer(msg.sender, to, amount);

        return true;
    }

    function transferFrom(address from, address to, uint256 amount) public virtual returns (bool) {
        uint256 allowed = allowance[from][msg.sender]; // Saves gas for limited approvals.
        uint256 fromBalance = balanceOf[from];

        if (allowed != type(uint256).max) {
            if (allowed < amount) revert InsufficientAllowance(from, msg.sender, allowed, amount);
            allowance[from][msg.sender] = allowed - amount;
        }

        if (fromBalance < amount) revert InsufficientBalance(from, fromBalance, amount);
        balanceOf[from] = fromBalance - amount;

        // Cannot overflow because the sum of all user
        // balances can't exceed the max uint256 value.
        unchecked {
            balanceOf[to] += amount;
        }

        emit Transfer(from, to, amount);

        return true;
    }

    /*//////////////////////////////////////////////////////////////
                             EIP-2612 LOGIC
    //////////////////////////////////////////////////////////////*/

    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s)
        public
        virtual
    {
        require(deadline >= block.timestamp, "PERMIT_DEADLINE_EXPIRED");

        // Unchecked because the only math done is incrementing
        // the owner's nonce which cannot realistically overflow.
        unchecked {
            address recoveredAddress = ecrecover(
                keccak256(
                    abi.encodePacked(
                        "\x19\x01",
                        DOMAIN_SEPARATOR(),
                        keccak256(
                            abi.encode(
                                keccak256(
                                    "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
                                ),
                                owner,
                                spender,
                                value,
                                nonces[owner]++,
                                deadline
                            )
                        )
                    )
                ),
                v,
                r,
                s
            );

            require(recoveredAddress != address(0) && recoveredAddress == owner, "INVALID_SIGNER");

            allowance[recoveredAddress][spender] = value;
        }

        emit Approval(owner, spender, value);
    }

    function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
        return block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator();
    }

    function computeDomainSeparator() internal view virtual returns (bytes32) {
        return keccak256(
            abi.encode(
                keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
                keccak256(bytes(name)),
                keccak256("1"),
                block.chainid,
                address(this)
            )
        );
    }

    /*//////////////////////////////////////////////////////////////
                        INTERNAL MINT/BURN LOGIC
    //////////////////////////////////////////////////////////////*/

    function _mint(address to, uint256 amount) internal virtual {
        uint256 newTotalSupply = totalSupply + amount;
        if (newTotalSupply < totalSupply) revert MintOverflow(totalSupply, amount);
        totalSupply = newTotalSupply;

        // Cannot overflow because the sum of all user
        // balances can't exceed the max uint256 value.
        unchecked {
            balanceOf[to] += amount;
        }

        emit Transfer(address(0), to, amount);
    }

    function _burn(address from, uint256 amount) internal virtual {
        uint256 fromBalance = balanceOf[from];
        if (fromBalance < amount) revert InsufficientBalance(from, fromBalance, amount);

        balanceOf[from] = fromBalance - amount;

        // Cannot underflow because a user's balance
        // will never be larger than the total supply.
        unchecked {
            totalSupply -= amount;
        }

        emit Transfer(from, address(0), amount);
    }
}

contract MockERC20 is ERC20 {
    constructor(string memory _name, string memory _symbol, uint8 _decimals) ERC20(_name, _symbol, _decimals) {}

    function mint(address to, uint256 value) public virtual {
        _mint(to, value);
    }

    function burn(address from, uint256 value) public virtual {
        _burn(from, value);
    }
}


0.0% lib/setup-helpers/src/Panic.sol

Lines covered: 0 / 1 (0.0%)

// SPDX-License-Identifier: GPL-2.0
pragma solidity ^0.8.0;

library Panic {
    // compiler panics
    string constant assertionPanic = "Panic(1)";
    string constant arithmeticPanic = "Panic(17)";
    string constant divisionPanic = "Panic(18)";
    string constant enumPanic = "Panic(33)";
    string constant arrayPanic = "Panic(34)";
    string constant emptyArrayPanic = "Panic(49)";
    string constant outOfBoundsPanic = "Panic(50)";
    string constant memoryPanic = "Panic(65)";
    string constant functionPanic = "Panic(81)";
}


62.0% lib/setup-helpers/src/Utils.sol

Lines covered: 34 / 54 (62.0%)

// SPDX-License-Identifier: GPL-2.0
pragma solidity ^0.8.0;

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

contract Utils {
    /// @dev check if the error returned from a call is the same as the expected error
    /// @param err the error returned from a call
    /// @param expected the expected error
    /// @return true if the error is the same as the expected error, false otherwise
    function checkError(bytes memory err, string memory expected) internal pure returns (bool) {
        (string memory revertMsg, bool customError) = _getRevertMsg(err);

        bytes32 errorBytes;
        bytes32 expectedBytes;

        if (customError) {
            // Custom error returns the keccak256 hash of the error, so don't need to hash it again
            errorBytes = bytes32(abi.encodePacked(revertMsg, bytes28(0)));
            expectedBytes = bytes4(keccak256(abi.encodePacked(expected)));
        } else {
            errorBytes = keccak256(abi.encodePacked(revertMsg));
            expectedBytes = keccak256(abi.encodePacked(expected));
        }

        // Check if error contains expected string
        return errorBytes == expectedBytes;
    }

    /// @dev get the revert message from a call
    /// @notice based on https://ethereum.stackexchange.com/a/83577
    /// @param returnData the return data from a call
    /// @return the revert message and a boolean indicating if it's a custom error
    function _getRevertMsg(bytes memory returnData) internal pure returns (string memory, bool) {
        // If the returnData length is 0, then the transaction failed silently (without a revert message)
        if (returnData.length == 0) return ("", false);

        // 1. Panic(uint256)
        // Check that the data has the right size: 4 bytes for signature + 32 bytes for panic code
        if (returnData.length == 4 + 32) {
            // Check that the data starts with the Panic signature
            bool panic = _checkIfPanic(returnData);

            if (panic) {
                return _getPanicCode(returnData);
            }
        }

        // Get the error selector from returnData
        bytes4 errorSelector = _getErrorSelector(returnData);

        // 2. Error(string) - If it's a standard revert string
        bytes4 errorStringSelector = bytes4(keccak256("Error(string)")); // Get the standard Error(string) selector

        if (errorSelector == errorStringSelector) {
            assembly {
                // slice the sighash of the error so we can decode the string
                returnData := add(returnData, 0x04)
            }
            return (abi.decode(returnData, (string)), false);
        }

        // 3. Custom error - Return the custom error selector as a string
        return (string(abi.encodePacked(errorSelector)), true);
    }

    function _checkIfPanic(bytes memory returnData) internal pure returns (bool) {
        bytes4 panicSignature = bytes4(keccak256(bytes("Panic(uint256)")));

        for (uint256 i = 0; i < 4; i++) {
            if (returnData[i] != panicSignature[i]) {
                return false;
            }
        }

        return true;
    }

    function _getPanicCode(bytes memory returnData) internal pure returns (string memory, bool) {
        uint256 panicCode;
        for (uint256 i = 4; i < 36; i++) {
            panicCode = panicCode << 8;
            panicCode |= uint8(returnData[i]);
        }

        // Convert the panic code into its string representation
        if (panicCode == 1) {
            // call assert with an argument that evaluates to false
            return (Panic.assertionPanic, false);
        } else if (panicCode == 17) {
            // arithmetic operation results in underflow or overflow
            return (Panic.arithmeticPanic, false);
        } else if (panicCode == 18) {
            // division or modulo by zero
            return (Panic.divisionPanic, false);
        } else if (panicCode == 33) {
            // converting a value that's too big or negative into an enum type
            return (Panic.enumPanic, false);
        } else if (panicCode == 34) {
            // access a storage byte array that is incorrectly encoded
            return (Panic.arrayPanic, false);
        } else if (panicCode == 49) {
            // call .pop() on an empty array
            return (Panic.emptyArrayPanic, false);
        } else if (panicCode == 50) {
            // array access out of bounds
            return (Panic.outOfBoundsPanic, false);
        } else if (panicCode == 65) {
            // allocate too much memory or create an array that is too large
            return (Panic.memoryPanic, false);
        } else if (panicCode == 81) {
            // call a zero-initialized variable of internal function type
            return (Panic.functionPanic, false);
        }

        return ("Undefined panic code", false);
    }

    function _getErrorSelector(bytes memory returnData) internal pure returns (bytes4 errorSelector) {
        assembly {
            errorSelector := mload(add(returnData, 0x20))
        }
        return errorSelector;
    }
}


0.0% lib/v2-core/lib/modulekit/src/accounts/common/interfaces/IERC7579Account.sol

Lines covered: 0 / 0 (0.0%)

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.23 <0.9.0;

/* solhint-disable no-unused-import */

// Types
import { CallType, ExecType, ModeCode } from "../lib/ModeLib.sol";

// Structs
struct Execution {
    address target;
    uint256 value;
    bytes callData;
}

interface IERC7579Account {
    event ModuleInstalled(uint256 moduleTypeId, address module);
    event ModuleUninstalled(uint256 moduleTypeId, address module);

    /**
     * @dev Executes a transaction on behalf of the account.
     *         This function is intended to be called by ERC-4337 EntryPoint.sol
     * @dev Ensure adequate authorization control: i.e. onlyEntryPointOrSelf
     *
     * @dev MSA MUST implement this function signature.
     * If a mode is requested that is not supported by the Account, it MUST revert
     * @param mode The encoded execution mode of the transaction. See ModeLib.sol for details
     * @param executionCalldata The encoded execution call data
     */
    function execute(ModeCode mode, bytes calldata executionCalldata) external payable;

    /**
     * @dev Executes a transaction on behalf of the account.
     *         This function is intended to be called by Executor Modules
     * @dev Ensure adequate authorization control: i.e. onlyExecutorModule
     *
     * @dev MSA MUST implement this function signature.
     * If a mode is requested that is not supported by the Account, it MUST revert
     * @param mode The encoded execution mode of the transaction. See ModeLib.sol for details
     * @param executionCalldata The encoded execution call data
     */
    function executeFromExecutor(
        ModeCode mode,
        bytes calldata executionCalldata
    )
        external
        payable
        returns (bytes[] memory returnData);

    /**
     * @dev ERC-1271 isValidSignature
     *         This function is intended to be used to validate a smart account signature
     * and may forward the call to a validator module
     *
     * @param hash The hash of the data that is signed
     * @param data The data that is signed
     */
    function isValidSignature(bytes32 hash, bytes calldata data) external view returns (bytes4);

    /**
     * @dev installs a Module of a certain type on the smart account
     * @dev Implement Authorization control of your chosing
     * @param moduleTypeId the module type ID according the ERC-7579 spec
     * @param module the module address
     * @param initData arbitrary data that may be required on the module during `onInstall`
     * initialization.
     */
    function installModule(
        uint256 moduleTypeId,
        address module,
        bytes calldata initData
    )
        external
        payable;

    /**
     * @dev uninstalls a Module of a certain type on the smart account
     * @dev Implement Authorization control of your chosing
     * @param moduleTypeId the module type ID according the ERC-7579 spec
     * @param module the module address
     * @param deInitData arbitrary data that may be required on the module during `onUninstall`
     * de-initialization.
     */
    function uninstallModule(
        uint256 moduleTypeId,
        address module,
        bytes calldata deInitData
    )
        external
        payable;

    /**
     * Function to check if the account supports a certain CallType or ExecType (see ModeLib.sol)
     * @param encodedMode the encoded mode
     */
    function supportsExecutionMode(ModeCode encodedMode) external view returns (bool);

    /**
     * Function to check if the account supports installation of a certain module type Id
     * @param moduleTypeId the module type ID according the ERC-7579 spec
     */
    function supportsModule(uint256 moduleTypeId) external view returns (bool);

    /**
     * Function to check if the account has a certain module installed
     * @param moduleTypeId the module type ID according the ERC-7579 spec
     *      Note: keep in mind that some contracts can be multiple module types at the same time. It
     *            thus may be necessary to query multiple module types
     * @param module the module address
     * @param additionalContext additional context data that the smart account may interpret to
     *                          identifiy conditions under which the module is installed.
     *                          usually this is not necessary, but for some special hooks that
     *                          are stored in mappings, this param might be needed
     */
    function isModuleInstalled(
        uint256 moduleTypeId,
        address module,
        bytes calldata additionalContext
    )
        external
        view
        returns (bool);

    /**
     * @dev Returns the account id of the smart account
     * @return accountImplementationId the account id of the smart account
     * the accountId should be structured like so:
     *        "vendorname.accountname.semver"
     */
    function accountId() external view returns (string memory accountImplementationId);
}


0.0% lib/v2-core/lib/modulekit/src/accounts/common/lib/ModeLib.sol

Lines covered: 0 / 1 (0.0%)

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.8.0 <0.9.0;

/**
 * @title ModeLib
 * @author rhinestone | zeroknots.eth, Konrad Kopp (@kopy-kat)
 * To allow smart accounts to be very simple, but allow for more complex execution, A custom mode
 * encoding is used.
 *    Function Signature of execute function:
 *           function execute(ModeCode mode, bytes calldata executionCalldata) external payable;
 * This allows for a single bytes32 to be used to encode the execution mode, calltype, execType and
 * context.
 * NOTE: Simple Account implementations only have to scope for the most significant byte. Account  that
 * implement
 * more complex execution modes may use the entire bytes32.
 *
 * |--------------------------------------------------------------------|
 * | CALLTYPE  | EXECTYPE  |   UNUSED   | ModeSelector  |  ModePayload  |
 * |--------------------------------------------------------------------|
 * | 1 byte    | 1 byte    |   4 bytes  | 4 bytes       |   22 bytes    |
 * |--------------------------------------------------------------------|
 *
 * CALLTYPE: 1 byte
 * CallType is used to determine how the executeCalldata paramter of the execute function has to be
 * decoded.
 * It can be either single, batch or delegatecall. In the future different calls could be added.
 * CALLTYPE can be used by a validation module to determine how to decode <userOp.callData[36:]>.
 *
 * EXECTYPE: 1 byte
 * ExecType is used to determine how the account should handle the execution.
 * It can indicate if the execution should revert on failure or continue execution.
 * In the future more execution modes may be added.
 * Default Behavior (EXECTYPE = 0x00) is to revert on a single failed execution. If one execution in
 * a batch fails, the entire batch is reverted
 *
 * UNUSED: 4 bytes
 * Unused bytes are reserved for future use.
 *
 * ModeSelector: bytes4
 * The "optional" mode selector can be used by account vendors, to implement custom behavior in
 * their accounts.
 * the way a ModeSelector is to be calculated is bytes4(keccak256("vendorname.featurename"))
 * this is to prevent collisions between different vendors, while allowing innovation and the
 * development of new features without coordination between ERC-7579 implementing accounts
 *
 * ModePayload: 22 bytes
 * Mode payload is used to pass additional data to the smart account execution, this may be
 * interpreted depending on the ModeSelector
 *
 * ExecutionCallData: n bytes
 * single, delegatecall or batch exec abi.encoded as bytes
 */

// Custom type for improved developer experience
type ModeCode is bytes32;

type CallType is bytes1;

type ExecType is bytes1;

type ModeSelector is bytes4;

type ModePayload is bytes22;

// Default CallType
CallType constant CALLTYPE_SINGLE = CallType.wrap(0x00);
// Batched CallType
CallType constant CALLTYPE_BATCH = CallType.wrap(0x01);
CallType constant CALLTYPE_STATIC = CallType.wrap(0xFE);
// @dev Implementing delegatecall is OPTIONAL!
// implement delegatecall with extreme care.
CallType constant CALLTYPE_DELEGATECALL = CallType.wrap(0xFF);

// @dev default behavior is to revert on failure
// To allow very simple accounts to use mode encoding, the default behavior is to revert on failure
// Since this is value 0x00, no additional encoding is required for simple accounts
ExecType constant EXECTYPE_DEFAULT = ExecType.wrap(0x00);
// @dev account may elect to change execution behavior. For example "try exec" / "allow fail"
ExecType constant EXECTYPE_TRY = ExecType.wrap(0x01);

ModeSelector constant MODE_DEFAULT = ModeSelector.wrap(bytes4(0x00000000));
// Example declaration of a custom mode selector
ModeSelector constant MODE_OFFSET = ModeSelector.wrap(bytes4(keccak256("default.mode.offset")));

/**
 * @dev ModeLib is a helper library to encode/decode ModeCodes
 */
library ModeLib {
    function decode(ModeCode mode)
        internal
        pure
        returns (
            CallType _calltype,
            ExecType _execType,
            ModeSelector _modeSelector,
            ModePayload _modePayload
        )
    {
        // solhint-disable-next-line no-inline-assembly
        assembly {
            _calltype := mode
            _execType := shl(8, mode)
            _modeSelector := shl(48, mode)
            _modePayload := shl(80, mode)
        }
    }

    function encode(
        CallType callType,
        ExecType execType,
        ModeSelector mode,
        ModePayload payload
    )
        internal
        pure
        returns (ModeCode)
    {
        return ModeCode.wrap(
            bytes32(
                abi.encodePacked(callType, execType, bytes4(0), ModeSelector.unwrap(mode), payload)
            )
        );
    }

    function encodeSimpleBatch() internal pure returns (ModeCode mode) {
        mode = encode(CALLTYPE_BATCH, EXECTYPE_DEFAULT, MODE_DEFAULT, ModePayload.wrap(0x00));
    }

    function encodeSimpleSingle() internal pure returns (ModeCode mode) {
        mode = encode(CALLTYPE_SINGLE, EXECTYPE_DEFAULT, MODE_DEFAULT, ModePayload.wrap(0x00));
    }

    function getCallType(ModeCode mode) internal pure returns (CallType calltype) {
        // solhint-disable-next-line no-inline-assembly
        assembly {
            calltype := mode
        }
    }
}

using { eqModeSelector as == } for ModeSelector global;
using { eqCallType as == } for CallType global;
using { neqCallType as != } for CallType global;
using { eqExecType as == } for ExecType global;

function eqCallType(CallType a, CallType b) pure returns (bool) {
    return CallType.unwrap(a) == CallType.unwrap(b);
}

function neqCallType(CallType a, CallType b) pure returns (bool) {
    return CallType.unwrap(a) == CallType.unwrap(b);
}

function eqExecType(ExecType a, ExecType b) pure returns (bool) {
    return ExecType.unwrap(a) == ExecType.unwrap(b);
}

function eqModeSelector(ModeSelector a, ModeSelector b) pure returns (bool) {
    return ModeSelector.unwrap(a) == ModeSelector.unwrap(b);
}


0.0% lib/v2-core/lib/modulekit/src/accounts/erc7579/lib/ExecutionLib.sol

Lines covered: 0 / 1 (0.0%)

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.23 <0.9.0;

// Types
import { Execution } from "../../common/interfaces/IERC7579Account.sol";

/**
 * Helper Library for decoding Execution calldata
 * malloc for memory allocation is bad for gas. use this assembly instead
 */
library ExecutionLib {
    error ERC7579DecodingError();

    /**
     * @notice Decode a batch of `Execution` executionBatch from a `bytes` calldata.
     * @dev code is copied from solady's LibERC7579.sol
     * https://github.com/Vectorized/solady/blob/740812cedc9a1fc11e17cb3d4569744367dedf19/src/accounts/LibERC7579.sol#L146
     *      Credits to Vectorized and the Solady Team
     */
    function decodeBatch(bytes calldata executionCalldata)
        internal
        pure
        returns (Execution[] calldata executionBatch)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let u := calldataload(executionCalldata.offset)
            let s := add(executionCalldata.offset, u)
            let e := sub(add(executionCalldata.offset, executionCalldata.length), 0x20)
            executionBatch.offset := add(s, 0x20)
            executionBatch.length := calldataload(s)
            if or(shr(64, u), gt(add(s, shl(5, executionBatch.length)), e)) {
                mstore(0x00, 0xba597e7e) // `DecodingError()`.
                revert(0x1c, 0x04)
            }
            if executionBatch.length {
                // Perform bounds checks on the decoded `executionBatch`.
                // Loop runs out-of-gas if `executionBatch.length` is big enough to cause overflows.
                for { let i := executionBatch.length } 1 { } {
                    i := sub(i, 1)
                    let p := calldataload(add(executionBatch.offset, shl(5, i)))
                    let c := add(executionBatch.offset, p)
                    let q := calldataload(add(c, 0x40))
                    let o := add(c, q)
                    // forgefmt: disable-next-item
                    if or(shr(64, or(calldataload(o), or(p, q))),
                        or(gt(add(c, 0x40), e), gt(add(o, calldataload(o)), e))) {
                        mstore(0x00, 0xba597e7e) // `DecodingError()`.
                        revert(0x1c, 0x04)
                    }
                    if iszero(i) { break }
                }
            }
        }
    }

    function encodeBatch(Execution[] memory executions)
        internal
        pure
        returns (bytes memory callData)
    {
        callData = abi.encode(executions);
    }

    function decodeSingle(bytes calldata executionCalldata)
        internal
        pure
        returns (address target, uint256 value, bytes calldata callData)
    {
        target = address(bytes20(executionCalldata[0:20]));
        value = uint256(bytes32(executionCalldata[20:52]));
        callData = executionCalldata[52:];
    }

    function encodeSingle(
        address target,
        uint256 value,
        bytes memory callData
    )
        internal
        pure
        returns (bytes memory userOpCalldata)
    {
        userOpCalldata = abi.encodePacked(target, value, callData);
    }
}


58.0% lib/v2-core/lib/openzeppelin-contracts/contracts/access/AccessControl.sol

Lines covered: 21 / 36 (58.0%)

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

pragma solidity ^0.8.20;

import {IAccessControl} from "./IAccessControl.sol";
import {Context} from "../utils/Context.sol";
import {IERC165, ERC165} from "../utils/introspection/ERC165.sol";

/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms. This is a lightweight version that doesn't allow enumerating role
 * members except through off-chain means by accessing the contract event logs. Some
 * applications may benefit from on-chain enumerability, for those cases see
 * {AccessControlEnumerable}.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```solidity
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```solidity
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}
 * to enforce additional security measures for this role.
 */
abstract contract AccessControl is Context, IAccessControl, ERC165 {
    struct RoleData {
        mapping(address account => bool) hasRole;
        bytes32 adminRole;
    }

    mapping(bytes32 role => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Modifier that checks that an account has a specific role. Reverts
     * with an {AccessControlUnauthorizedAccount} error including the required role.
     */
    modifier onlyRole(bytes32 role) {
        _checkRole(role);
        _;
    }

    /// @inheritdoc IERC165
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
    }

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view virtual returns (bool) {
        return _roles[role].hasRole[account];
    }

    /**
     * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `_msgSender()`
     * is missing `role`. Overriding this function changes the behavior of the {onlyRole} modifier.
     */
    function _checkRole(bytes32 role) internal view virtual {
        _checkRole(role, _msgSender());
    }

    /**
     * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `account`
     * is missing `role`.
     */
    function _checkRole(bytes32 role, address account) internal view virtual {
        if (!hasRole(role, account)) {
            revert AccessControlUnauthorizedAccount(account, role);
        }
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view virtual returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @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.
     *
     * May emit a {RoleGranted} event.
     */
    function grantRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {
        _grantRole(role, account);
    }

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

    /**
     * @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 revoked `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `callerConfirmation`.
     *
     * May emit a {RoleRevoked} event.
     */
    function renounceRole(bytes32 role, address callerConfirmation) public virtual {
        if (callerConfirmation != _msgSender()) {
            revert AccessControlBadConfirmation();
        }

        _revokeRole(role, callerConfirmation);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        bytes32 previousAdminRole = getRoleAdmin(role);
        _roles[role].adminRole = adminRole;
        emit RoleAdminChanged(role, previousAdminRole, adminRole);
    }

    /**
     * @dev Attempts to grant `role` to `account` and returns a boolean indicating if `role` was granted.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleGranted} event.
     */
    function _grantRole(bytes32 role, address account) internal virtual returns (bool) {
        if (!hasRole(role, account)) {
            _roles[role].hasRole[account] = true;
            emit RoleGranted(role, account, _msgSender());
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Attempts to revoke `role` from `account` and returns a boolean indicating if `role` was revoked.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleRevoked} event.
     */
    function _revokeRole(bytes32 role, address account) internal virtual returns (bool) {
        if (hasRole(role, account)) {
            _roles[role].hasRole[account] = false;
            emit RoleRevoked(role, account, _msgSender());
            return true;
        } else {
            return false;
        }
    }
}


0.0% lib/v2-core/lib/openzeppelin-contracts/contracts/access/IAccessControl.sol

Lines covered: 0 / 0 (0.0%)

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

pragma solidity >=0.8.4;

/**
 * @dev External interface of AccessControl declared to support ERC-165 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 to signal 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. This account bears the admin role (for the granted role).
     * Expected in cases where the role was granted using the internal {AccessControl-_grantRole}.
     */
    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;
}


0.0% lib/v2-core/lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol

Lines covered: 0 / 0 (0.0%)

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

pragma solidity >=0.6.2;

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

/**
 * @title IERC1363
 * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].
 *
 * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract
 * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.
 */
interface IERC1363 is IERC20, IERC165 {
    /*
     * Note: the ERC-165 identifier for this interface is 0xb0202a11.
     * 0xb0202a11 ===
     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^
     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^
     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^
     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
     */

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferAndCall(address to, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @param data Additional data with no specified format, sent in call to `to`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param from The address which you want to send tokens from.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param from The address which you want to send tokens from.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @param data Additional data with no specified format, sent in call to `to`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function approveAndCall(address spender, uint256 value) external returns (bool);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     * @param data Additional data with no specified format, sent in call to `spender`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
}


0.0% lib/v2-core/lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol

Lines covered: 0 / 0 (0.0%)

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

pragma solidity >=0.4.16;

import {IERC165} from "../utils/introspection/IERC165.sol";


0.0% lib/v2-core/lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol

Lines covered: 0 / 0 (0.0%)

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

pragma solidity >=0.4.16;

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


0.0% lib/v2-core/lib/openzeppelin-contracts/contracts/interfaces/IERC20Metadata.sol

Lines covered: 0 / 0 (0.0%)

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

pragma solidity >=0.6.2;

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


0.0% lib/v2-core/lib/openzeppelin-contracts/contracts/interfaces/IERC4626.sol

Lines covered: 0 / 0 (0.0%)

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

pragma solidity >=0.6.2;

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

/**
 * @dev Interface of the ERC-4626 "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 redemption 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);
}


0.0% lib/v2-core/lib/openzeppelin-contracts/contracts/interfaces/IERC5267.sol

Lines covered: 0 / 0 (0.0%)

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

pragma solidity >=0.4.16;

interface IERC5267 {
    /**
     * @dev MAY be emitted to signal that the domain could have changed.
     */
    event EIP712DomainChanged();

    /**
     * @dev returns the fields and values that describe the domain separator used by this contract for EIP-712
     * signature.
     */
    function eip712Domain()
        external
        view
        returns (
            bytes1 fields,
            string memory name,
            string memory version,
            uint256 chainId,
            address verifyingContract,
            bytes32 salt,
            uint256[] memory extensions
        );
}


0.0% lib/v2-core/lib/openzeppelin-contracts/contracts/interfaces/draft-IERC6093.sol

Lines covered: 0 / 0 (0.0%)

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/draft-IERC6093.sol)
pragma solidity >=0.8.4;

/**
 * @dev Standard ERC-20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 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 ERC-721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-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 ERC-1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 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);
}


75.0% lib/v2-core/lib/openzeppelin-contracts/contracts/proxy/Clones.sol

Lines covered: 9 / 12 (75.0%)

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.3.0) (proxy/Clones.sol)

pragma solidity ^0.8.20;

import {Create2} from "../utils/Create2.sol";
import {Errors} from "../utils/Errors.sol";

/**
 * @dev https://eips.ethereum.org/EIPS/eip-1167[ERC-1167] is a standard for
 * deploying minimal proxy contracts, also known as "clones".
 *
 * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies
 * > a minimal bytecode implementation that delegates all calls to a known, fixed address.
 *
 * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`
 * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the
 * deterministic method.
 */
library Clones {
    error CloneArgumentsTooLong();

    /**
     * @dev Deploys and returns the address of a clone that mimics the behavior of `implementation`.
     *
     * This function uses the create opcode, which should never revert.
     */
    function clone(address implementation) internal returns (address instance) {
        return clone(implementation, 0);
    }

    /**
     * @dev Same as {xref-Clones-clone-address-}[clone], but with a `value` parameter to send native currency
     * to the new contract.
     *
     * NOTE: Using a non-zero value at creation will require the contract using this function (e.g. a factory)
     * to always have enough balance for new deployments. Consider exposing this function under a payable method.
     */
    function clone(address implementation, uint256 value) internal returns (address instance) {
        if (address(this).balance < value) {
            revert Errors.InsufficientBalance(address(this).balance, value);
        }
        assembly ("memory-safe") {
            // Cleans the upper 96 bits of the `implementation` word, then packs the first 3 bytes
            // of the `implementation` address with the bytecode before the address.
            mstore(0x00, or(shr(0xe8, shl(0x60, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000))
            // Packs the remaining 17 bytes of `implementation` with the bytecode after the address.
            mstore(0x20, or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3))
            instance := create(value, 0x09, 0x37)
        }
        if (instance == address(0)) {
            revert Errors.FailedDeployment();
        }
    }

    /**
     * @dev Deploys and returns the address of a clone that mimics the behavior of `implementation`.
     *
     * This function uses the create2 opcode and a `salt` to deterministically deploy
     * the clone. Using the same `implementation` and `salt` multiple times will revert, since
     * the clones cannot be deployed twice at the same address.
     */
    function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {
        return cloneDeterministic(implementation, salt, 0);
    }

    /**
     * @dev Same as {xref-Clones-cloneDeterministic-address-bytes32-}[cloneDeterministic], but with
     * a `value` parameter to send native currency to the new contract.
     *
     * NOTE: Using a non-zero value at creation will require the contract using this function (e.g. a factory)
     * to always have enough balance for new deployments. Consider exposing this function under a payable method.
     */
    function cloneDeterministic(
        address implementation,
        bytes32 salt,
        uint256 value
    ) internal returns (address instance) {
        if (address(this).balance < value) {
            revert Errors.InsufficientBalance(address(this).balance, value);
        }
        assembly ("memory-safe") {
            // Cleans the upper 96 bits of the `implementation` word, then packs the first 3 bytes
            // of the `implementation` address with the bytecode before the address.
            mstore(0x00, or(shr(0xe8, shl(0x60, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000))
            // Packs the remaining 17 bytes of `implementation` with the bytecode after the address.
            mstore(0x20, or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3))
            instance := create2(value, 0x09, 0x37, salt)
        }
        if (instance == address(0)) {
            revert Errors.FailedDeployment();
        }
    }

    /**
     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.
     */
    function predictDeterministicAddress(
        address implementation,
        bytes32 salt,
        address deployer
    ) internal pure returns (address predicted) {
        assembly ("memory-safe") {
            let ptr := mload(0x40)
            mstore(add(ptr, 0x38), deployer)
            mstore(add(ptr, 0x24), 0x5af43d82803e903d91602b57fd5bf3ff)
            mstore(add(ptr, 0x14), implementation)
            mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73)
            mstore(add(ptr, 0x58), salt)
            mstore(add(ptr, 0x78), keccak256(add(ptr, 0x0c), 0x37))
            predicted := and(keccak256(add(ptr, 0x43), 0x55), 0xffffffffffffffffffffffffffffffffffffffff)
        }
    }

    /**
     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.
     */
    function predictDeterministicAddress(
        address implementation,
        bytes32 salt
    ) internal view returns (address predicted) {
        return predictDeterministicAddress(implementation, salt, address(this));
    }

    /**
     * @dev Deploys and returns the address of a clone that mimics the behavior of `implementation` with custom
     * immutable arguments. These are provided through `args` and cannot be changed after deployment. To
     * access the arguments within the implementation, use {fetchCloneArgs}.
     *
     * This function uses the create opcode, which should never revert.
     */
    function cloneWithImmutableArgs(address implementation, bytes memory args) internal returns (address instance) {
        return cloneWithImmutableArgs(implementation, args, 0);
    }

    /**
     * @dev Same as {xref-Clones-cloneWithImmutableArgs-address-bytes-}[cloneWithImmutableArgs], but with a `value`
     * parameter to send native currency to the new contract.
     *
     * NOTE: Using a non-zero value at creation will require the contract using this function (e.g. a factory)
     * to always have enough balance for new deployments. Consider exposing this function under a payable method.
     */
    function cloneWithImmutableArgs(
        address implementation,
        bytes memory args,
        uint256 value
    ) internal returns (address instance) {
        if (address(this).balance < value) {
            revert Errors.InsufficientBalance(address(this).balance, value);
        }
        bytes memory bytecode = _cloneCodeWithImmutableArgs(implementation, args);
        assembly ("memory-safe") {
            instance := create(value, add(bytecode, 0x20), mload(bytecode))
        }
        if (instance == address(0)) {
            revert Errors.FailedDeployment();
        }
    }

    /**
     * @dev Deploys and returns the address of a clone that mimics the behavior of `implementation` with custom
     * immutable arguments. These are provided through `args` and cannot be changed after deployment. To
     * access the arguments within the implementation, use {fetchCloneArgs}.
     *
     * This function uses the create2 opcode and a `salt` to deterministically deploy the clone. Using the same
     * `implementation`, `args` and `salt` multiple times will revert, since the clones cannot be deployed twice
     * at the same address.
     */
    function cloneDeterministicWithImmutableArgs(
        address implementation,
        bytes memory args,
        bytes32 salt
    ) internal returns (address instance) {
        return cloneDeterministicWithImmutableArgs(implementation, args, salt, 0);
    }

    /**
     * @dev Same as {xref-Clones-cloneDeterministicWithImmutableArgs-address-bytes-bytes32-}[cloneDeterministicWithImmutableArgs],
     * but with a `value` parameter to send native currency to the new contract.
     *
     * NOTE: Using a non-zero value at creation will require the contract using this function (e.g. a factory)
     * to always have enough balance for new deployments. Consider exposing this function under a payable method.
     */
    function cloneDeterministicWithImmutableArgs(
        address implementation,
        bytes memory args,
        bytes32 salt,
        uint256 value
    ) internal returns (address instance) {
        bytes memory bytecode = _cloneCodeWithImmutableArgs(implementation, args);
        return Create2.deploy(value, salt, bytecode);
    }

    /**
     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministicWithImmutableArgs}.
     */
    function predictDeterministicAddressWithImmutableArgs(
        address implementation,
        bytes memory args,
        bytes32 salt,
        address deployer
    ) internal pure returns (address predicted) {
        bytes memory bytecode = _cloneCodeWithImmutableArgs(implementation, args);
        return Create2.computeAddress(salt, keccak256(bytecode), deployer);
    }

    /**
     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministicWithImmutableArgs}.
     */
    function predictDeterministicAddressWithImmutableArgs(
        address implementation,
        bytes memory args,
        bytes32 salt
    ) internal view returns (address predicted) {
        return predictDeterministicAddressWithImmutableArgs(implementation, args, salt, address(this));
    }

    /**
     * @dev Get the immutable args attached to a clone.
     *
     * - If `instance` is a clone that was deployed using `clone` or `cloneDeterministic`, this
     *   function will return an empty array.
     * - If `instance` is a clone that was deployed using `cloneWithImmutableArgs` or
     *   `cloneDeterministicWithImmutableArgs`, this function will return the args array used at
     *   creation.
     * - If `instance` is NOT a clone deployed using this library, the behavior is undefined. This
     *   function should only be used to check addresses that are known to be clones.
     */
    function fetchCloneArgs(address instance) internal view returns (bytes memory) {
        bytes memory result = new bytes(instance.code.length - 45); // revert if length is too short
        assembly ("memory-safe") {
            extcodecopy(instance, add(result, 32), 45, mload(result))
        }
        return result;
    }

    /**
     * @dev Helper that prepares the initcode of the proxy with immutable args.
     *
     * An assembly variant of this function requires copying the `args` array, which can be efficiently done using
     * `mcopy`. Unfortunately, that opcode is not available before cancun. A pure solidity implementation using
     * abi.encodePacked is more expensive but also more portable and easier to review.
     *
     * NOTE: https://eips.ethereum.org/EIPS/eip-170[EIP-170] limits the length of the contract code to 24576 bytes.
     * With the proxy code taking 45 bytes, that limits the length of the immutable args to 24531 bytes.
     */
    function _cloneCodeWithImmutableArgs(
        address implementation,
        bytes memory args
    ) private pure returns (bytes memory) {
        if (args.length > 24531) revert CloneArgumentsTooLong();
        return
            abi.encodePacked(
                hex"61",
                uint16(args.length + 45),
                hex"3d81600a3d39f3363d3d373d3d3d363d73",
                implementation,
                hex"5af43d82803e903d91602b57fd5bf3",
                args
            );
    }
}


0.0% lib/v2-core/lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol

Lines covered: 0 / 0 (0.0%)

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

pragma solidity >=0.4.16;

/**
 * @dev Interface of the ERC-20 standard as defined in the ERC.
 */
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);
}


0.0% lib/v2-core/lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol

Lines covered: 0 / 0 (0.0%)

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

pragma solidity >=0.6.2;

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

/**
 * @dev Interface for the optional metadata functions from the ERC-20 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);
}


94.0% lib/v2-core/lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol

Lines covered: 16 / 17 (94.0%)

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

pragma solidity ^0.8.20;

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

/**
 * @title SafeERC20
 * @dev Wrappers around ERC-20 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 {
    /**
     * @dev An operation with an ERC-20 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 Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.
     */
    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {
        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.
     */
    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {
        return _callOptionalReturnBool(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.
     *
     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
     * smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
     */
    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.
     *
     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
     * smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
     */
    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.
     *
     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function
     * only sets the "standard" allowance. Any temporary allowance will remain active, in addition to the value being
     * set here.
     */
    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 Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no
     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * Reverts if the returned value is other than `true`.
     */
    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
        if (to.code.length == 0) {
            safeTransfer(token, to, value);
        } else if (!token.transferAndCall(to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target
     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * Reverts if the returned value is other than `true`.
     */
    function transferFromAndCallRelaxed(
        IERC1363 token,
        address from,
        address to,
        uint256 value,
        bytes memory data
    ) internal {
        if (to.code.length == 0) {
            safeTransferFrom(token, from, to, value);
        } else if (!token.transferFromAndCall(from, to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no
     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.
     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}
     * once without retrying, and relies on the returned value to be true.
     *
     * Reverts if the returned value is other than `true`.
     */
    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
        if (to.code.length == 0) {
            forceApprove(token, to, value);
        } else if (!token.approveAndCall(to, value, data)) {
            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 {_callOptionalReturnBool} that reverts if call fails to meet the requirements.
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        uint256 returnSize;
        uint256 returnValue;
        assembly ("memory-safe") {
            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
            // bubble errors
            if iszero(success) {
                let ptr := mload(0x40)
                returndatacopy(ptr, 0, returndatasize())
                revert(ptr, returndatasize())
            }
            returnSize := returndatasize()
            returnValue := mload(0)
        }

        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {
            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 silently catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        bool success;
        uint256 returnSize;
        uint256 returnValue;
        assembly ("memory-safe") {
            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
            returnSize := returndatasize()
            returnValue := mload(0)
        }
        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);
    }
}


0.0% lib/v2-core/lib/openzeppelin-contracts/contracts/utils/Arrays.sol

Lines covered: 0 / 1 (0.0%)

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

pragma solidity ^0.8.20;

import {Comparators} from "./Comparators.sol";
import {SlotDerivation} from "./SlotDerivation.sol";
import {StorageSlot} from "./StorageSlot.sol";
import {Math} from "./math/Math.sol";

/**
 * @dev Collection of functions related to array types.
 */
library Arrays {
    using SlotDerivation for bytes32;
    using StorageSlot for bytes32;

    /**
     * @dev Sort an array of uint256 (in memory) following the provided comparator function.
     *
     * This function does the sorting "in place", meaning that it overrides the input. The object is returned for
     * convenience, but that returned value can be discarded safely if the caller has a memory pointer to the array.
     *
     * NOTE: this function's cost is `O(n · log(n))` in average and `O(n²)` in the worst case, with n the length of the
     * array. Using it in view functions that are executed through `eth_call` is safe, but one should be very careful
     * when executing this as part of a transaction. If the array being sorted is too large, the sort operation may
     * consume more gas than is available in a block, leading to potential DoS.
     *
     * IMPORTANT: Consider memory side-effects when using custom comparator functions that access memory in an unsafe way.
     */
    function sort(
        uint256[] memory array,
        function(uint256, uint256) pure returns (bool) comp
    ) internal pure returns (uint256[] memory) {
        _quickSort(_begin(array), _end(array), comp);
        return array;
    }

    /**
     * @dev Variant of {sort} that sorts an array of uint256 in increasing order.
     */
    function sort(uint256[] memory array) internal pure returns (uint256[] memory) {
        sort(array, Comparators.lt);
        return array;
    }

    /**
     * @dev Sort an array of address (in memory) following the provided comparator function.
     *
     * This function does the sorting "in place", meaning that it overrides the input. The object is returned for
     * convenience, but that returned value can be discarded safely if the caller has a memory pointer to the array.
     *
     * NOTE: this function's cost is `O(n · log(n))` in average and `O(n²)` in the worst case, with n the length of the
     * array. Using it in view functions that are executed through `eth_call` is safe, but one should be very careful
     * when executing this as part of a transaction. If the array being sorted is too large, the sort operation may
     * consume more gas than is available in a block, leading to potential DoS.
     *
     * IMPORTANT: Consider memory side-effects when using custom comparator functions that access memory in an unsafe way.
     */
    function sort(
        address[] memory array,
        function(address, address) pure returns (bool) comp
    ) internal pure returns (address[] memory) {
        sort(_castToUint256Array(array), _castToUint256Comp(comp));
        return array;
    }

    /**
     * @dev Variant of {sort} that sorts an array of address in increasing order.
     */
    function sort(address[] memory array) internal pure returns (address[] memory) {
        sort(_castToUint256Array(array), Comparators.lt);
        return array;
    }

    /**
     * @dev Sort an array of bytes32 (in memory) following the provided comparator function.
     *
     * This function does the sorting "in place", meaning that it overrides the input. The object is returned for
     * convenience, but that returned value can be discarded safely if the caller has a memory pointer to the array.
     *
     * NOTE: this function's cost is `O(n · log(n))` in average and `O(n²)` in the worst case, with n the length of the
     * array. Using it in view functions that are executed through `eth_call` is safe, but one should be very careful
     * when executing this as part of a transaction. If the array being sorted is too large, the sort operation may
     * consume more gas than is available in a block, leading to potential DoS.
     *
     * IMPORTANT: Consider memory side-effects when using custom comparator functions that access memory in an unsafe way.
     */
    function sort(
        bytes32[] memory array,
        function(bytes32, bytes32) pure returns (bool) comp
    ) internal pure returns (bytes32[] memory) {
        sort(_castToUint256Array(array), _castToUint256Comp(comp));
        return array;
    }

    /**
     * @dev Variant of {sort} that sorts an array of bytes32 in increasing order.
     */
    function sort(bytes32[] memory array) internal pure returns (bytes32[] memory) {
        sort(_castToUint256Array(array), Comparators.lt);
        return array;
    }

    /**
     * @dev Performs a quick sort of a segment of memory. The segment sorted starts at `begin` (inclusive), and stops
     * at end (exclusive). Sorting follows the `comp` comparator.
     *
     * Invariant: `begin <= end`. This is the case when initially called by {sort} and is preserved in subcalls.
     *
     * IMPORTANT: Memory locations between `begin` and `end` are not validated/zeroed. This function should
     * be used only if the limits are within a memory array.
     */
    function _quickSort(uint256 begin, uint256 end, function(uint256, uint256) pure returns (bool) comp) private pure {
        unchecked {
            if (end - begin < 0x40) return;

            // Use first element as pivot
            uint256 pivot = _mload(begin);
            // Position where the pivot should be at the end of the loop
            uint256 pos = begin;

            for (uint256 it = begin + 0x20; it < end; it += 0x20) {
                if (comp(_mload(it), pivot)) {
                    // If the value stored at the iterator's position comes before the pivot, we increment the
                    // position of the pivot and move the value there.
                    pos += 0x20;
                    _swap(pos, it);
                }
            }

            _swap(begin, pos); // Swap pivot into place
            _quickSort(begin, pos, comp); // Sort the left side of the pivot
            _quickSort(pos + 0x20, end, comp); // Sort the right side of the pivot
        }
    }

    /**
     * @dev Pointer to the memory location of the first element of `array`.
     */
    function _begin(uint256[] memory array) private pure returns (uint256 ptr) {
        assembly ("memory-safe") {
            ptr := add(array, 0x20)
        }
    }

    /**
     * @dev Pointer to the memory location of the first memory word (32bytes) after `array`. This is the memory word
     * that comes just after the last element of the array.
     */
    function _end(uint256[] memory array) private pure returns (uint256 ptr) {
        unchecked {
            return _begin(array) + array.length * 0x20;
        }
    }

    /**
     * @dev Load memory word (as a uint256) at location `ptr`.
     */
    function _mload(uint256 ptr) private pure returns (uint256 value) {
        assembly {
            value := mload(ptr)
        }
    }

    /**
     * @dev Swaps the elements memory location `ptr1` and `ptr2`.
     */
    function _swap(uint256 ptr1, uint256 ptr2) private pure {
        assembly {
            let value1 := mload(ptr1)
            let value2 := mload(ptr2)
            mstore(ptr1, value2)
            mstore(ptr2, value1)
        }
    }

    /// @dev Helper: low level cast address memory array to uint256 memory array
    function _castToUint256Array(address[] memory input) private pure returns (uint256[] memory output) {
        assembly {
            output := input
        }
    }

    /// @dev Helper: low level cast bytes32 memory array to uint256 memory array
    function _castToUint256Array(bytes32[] memory input) private pure returns (uint256[] memory output) {
        assembly {
            output := input
        }
    }

    /// @dev Helper: low level cast address comp function to uint256 comp function
    function _castToUint256Comp(
        function(address, address) pure returns (bool) input
    ) private pure returns (function(uint256, uint256) pure returns (bool) output) {
        assembly {
            output := input
        }
    }

    /// @dev Helper: low level cast bytes32 comp function to uint256 comp function
    function _castToUint256Comp(
        function(bytes32, bytes32) pure returns (bool) input
    ) private pure returns (function(uint256, uint256) pure returns (bool) output) {
        assembly {
            output := input
        }
    }

    /**
     * @dev Searches a sorted `array` and returns the first index that contains
     * a value greater or equal to `element`. If no such index exists (i.e. all
     * values in the array are strictly less than `element`), the array length is
     * returned. Time complexity O(log n).
     *
     * NOTE: The `array` is expected to be sorted in ascending order, and to
     * contain no repeated elements.
     *
     * IMPORTANT: Deprecated. This implementation behaves as {lowerBound} but lacks
     * support for repeated elements in the array. The {lowerBound} function should
     * be used instead.
     */
    function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
        uint256 low = 0;
        uint256 high = array.length;

        if (high == 0) {
            return 0;
        }

        while (low < high) {
            uint256 mid = Math.average(low, high);

            // Note that mid will always be strictly less than high (i.e. it will be a valid array index)
            // because Math.average rounds towards zero (it does integer division with truncation).
            if (unsafeAccess(array, mid).value > element) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }

        // At this point `low` is the exclusive upper bound. We will return the inclusive upper bound.
        if (low > 0 && unsafeAccess(array, low - 1).value == element) {
            return low - 1;
        } else {
            return low;
        }
    }

    /**
     * @dev Searches an `array` sorted in ascending order and returns the first
     * index that contains a value greater or equal than `element`. If no such index
     * exists (i.e. all values in the array are strictly less than `element`), the array
     * length is returned. Time complexity O(log n).
     *
     * See C++'s https://en.cppreference.com/w/cpp/algorithm/lower_bound[lower_bound].
     */
    function lowerBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
        uint256 low = 0;
        uint256 high = array.length;

        if (high == 0) {
            return 0;
        }

        while (low < high) {
            uint256 mid = Math.average(low, high);

            // Note that mid will always be strictly less than high (i.e. it will be a valid array index)
            // because Math.average rounds towards zero (it does integer division with truncation).
            if (unsafeAccess(array, mid).value < element) {
                // this cannot overflow because mid < high
                unchecked {
                    low = mid + 1;
                }
            } else {
                high = mid;
            }
        }

        return low;
    }

    /**
     * @dev Searches an `array` sorted in ascending order and returns the first
     * index that contains a value strictly greater than `element`. If no such index
     * exists (i.e. all values in the array are strictly less than `element`), the array
     * length is returned. Time complexity O(log n).
     *
     * See C++'s https://en.cppreference.com/w/cpp/algorithm/upper_bound[upper_bound].
     */
    function upperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
        uint256 low = 0;
        uint256 high = array.length;

        if (high == 0) {
            return 0;
        }

        while (low < high) {
            uint256 mid = Math.average(low, high);

            // Note that mid will always be strictly less than high (i.e. it will be a valid array index)
            // because Math.average rounds towards zero (it does integer division with truncation).
            if (unsafeAccess(array, mid).value > element) {
                high = mid;
            } else {
                // this cannot overflow because mid < high
                unchecked {
                    low = mid + 1;
                }
            }
        }

        return low;
    }

    /**
     * @dev Same as {lowerBound}, but with an array in memory.
     */
    function lowerBoundMemory(uint256[] memory array, uint256 element) internal pure returns (uint256) {
        uint256 low = 0;
        uint256 high = array.length;

        if (high == 0) {
            return 0;
        }

        while (low < high) {
            uint256 mid = Math.average(low, high);

            // Note that mid will always be strictly less than high (i.e. it will be a valid array index)
            // because Math.average rounds towards zero (it does integer division with truncation).
            if (unsafeMemoryAccess(array, mid) < element) {
                // this cannot overflow because mid < high
                unchecked {
                    low = mid + 1;
                }
            } else {
                high = mid;
            }
        }

        return low;
    }

    /**
     * @dev Same as {upperBound}, but with an array in memory.
     */
    function upperBoundMemory(uint256[] memory array, uint256 element) internal pure returns (uint256) {
        uint256 low = 0;
        uint256 high = array.length;

        if (high == 0) {
            return 0;
        }

        while (low < high) {
            uint256 mid = Math.average(low, high);

            // Note that mid will always be strictly less than high (i.e. it will be a valid array index)
            // because Math.average rounds towards zero (it does integer division with truncation).
            if (unsafeMemoryAccess(array, mid) > element) {
                high = mid;
            } else {
                // this cannot overflow because mid < high
                unchecked {
                    low = mid + 1;
                }
            }
        }

        return low;
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(address[] storage arr, uint256 pos) internal pure returns (StorageSlot.AddressSlot storage) {
        bytes32 slot;
        assembly ("memory-safe") {
            slot := arr.slot
        }
        return slot.deriveArray().offset(pos).getAddressSlot();
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(bytes32[] storage arr, uint256 pos) internal pure returns (StorageSlot.Bytes32Slot storage) {
        bytes32 slot;
        assembly ("memory-safe") {
            slot := arr.slot
        }
        return slot.deriveArray().offset(pos).getBytes32Slot();
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(uint256[] storage arr, uint256 pos) internal pure returns (StorageSlot.Uint256Slot storage) {
        bytes32 slot;
        assembly ("memory-safe") {
            slot := arr.slot
        }
        return slot.deriveArray().offset(pos).getUint256Slot();
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(bytes[] storage arr, uint256 pos) internal pure returns (StorageSlot.BytesSlot storage) {
        bytes32 slot;
        assembly ("memory-safe") {
            slot := arr.slot
        }
        return slot.deriveArray().offset(pos).getBytesSlot();
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(string[] storage arr, uint256 pos) internal pure returns (StorageSlot.StringSlot storage) {
        bytes32 slot;
        assembly ("memory-safe") {
            slot := arr.slot
        }
        return slot.deriveArray().offset(pos).getStringSlot();
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeMemoryAccess(address[] memory arr, uint256 pos) internal pure returns (address res) {
        assembly {
            res := mload(add(add(arr, 0x20), mul(pos, 0x20)))
        }
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeMemoryAccess(bytes32[] memory arr, uint256 pos) internal pure returns (bytes32 res) {
        assembly {
            res := mload(add(add(arr, 0x20), mul(pos, 0x20)))
        }
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeMemoryAccess(uint256[] memory arr, uint256 pos) internal pure returns (uint256 res) {
        assembly {
            res := mload(add(add(arr, 0x20), mul(pos, 0x20)))
        }
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeMemoryAccess(bytes[] memory arr, uint256 pos) internal pure returns (bytes memory res) {
        assembly {
            res := mload(add(add(arr, 0x20), mul(pos, 0x20)))
        }
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeMemoryAccess(string[] memory arr, uint256 pos) internal pure returns (string memory res) {
        assembly {
            res := mload(add(add(arr, 0x20), mul(pos, 0x20)))
        }
    }

    /**
     * @dev Helper to set the length of a dynamic array. Directly writing to `.length` is forbidden.
     *
     * WARNING: this does not clear elements if length is reduced, of initialize elements if length is increased.
     */
    function unsafeSetLength(address[] storage array, uint256 len) internal {
        assembly ("memory-safe") {
            sstore(array.slot, len)
        }
    }

    /**
     * @dev Helper to set the length of a dynamic array. Directly writing to `.length` is forbidden.
     *
     * WARNING: this does not clear elements if length is reduced, of initialize elements if length is increased.
     */
    function unsafeSetLength(bytes32[] storage array, uint256 len) internal {
        assembly ("memory-safe") {
            sstore(array.slot, len)
        }
    }

    /**
     * @dev Helper to set the length of a dynamic array. Directly writing to `.length` is forbidden.
     *
     * WARNING: this does not clear elements if length is reduced, of initialize elements if length is increased.
     */
    function unsafeSetLength(uint256[] storage array, uint256 len) internal {
        assembly ("memory-safe") {
            sstore(array.slot, len)
        }
    }

    /**
     * @dev Helper to set the length of a dynamic array. Directly writing to `.length` is forbidden.
     *
     * WARNING: this does not clear elements if length is reduced, of initialize elements if length is increased.
     */
    function unsafeSetLength(bytes[] storage array, uint256 len) internal {
        assembly ("memory-safe") {
            sstore(array.slot, len)
        }
    }

    /**
     * @dev Helper to set the length of a dynamic array. Directly writing to `.length` is forbidden.
     *
     * WARNING: this does not clear elements if length is reduced, of initialize elements if length is increased.
     */
    function unsafeSetLength(string[] storage array, uint256 len) internal {
        assembly ("memory-safe") {
            sstore(array.slot, len)
        }
    }
}


0.0% lib/v2-core/lib/openzeppelin-contracts/contracts/utils/Comparators.sol

Lines covered: 0 / 1 (0.0%)

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

pragma solidity ^0.8.20;

/**
 * @dev Provides a set of functions to compare values.
 *
 * _Available since v5.1._
 */
library Comparators {
    function lt(uint256 a, uint256 b) internal pure returns (bool) {
        return a < b;
    }

    function gt(uint256 a, uint256 b) internal pure returns (bool) {
        return a > b;
    }
}


100.0% lib/v2-core/lib/openzeppelin-contracts/contracts/utils/Context.sol

Lines covered: 2 / 2 (100.0%)

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

pragma solidity ^0.8.20;

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

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

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


0.0% lib/v2-core/lib/openzeppelin-contracts/contracts/utils/Create2.sol

Lines covered: 0 / 1 (0.0%)

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

pragma solidity ^0.8.20;

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

/**
 * @dev Helper to make usage of the `CREATE2` EVM opcode easier and safer.
 * `CREATE2` can be used to compute in advance the address where a smart
 * contract will be deployed, which allows for interesting new mechanisms known
 * as 'counterfactual interactions'.
 *
 * See the https://eips.ethereum.org/EIPS/eip-1014#motivation[EIP] for more
 * information.
 */
library Create2 {
    /**
     * @dev There's no code to deploy.
     */
    error Create2EmptyBytecode();

    /**
     * @dev Deploys a contract using `CREATE2`. The address where the contract
     * will be deployed can be known in advance via {computeAddress}.
     *
     * The bytecode for a contract can be obtained from Solidity with
     * `type(contractName).creationCode`.
     *
     * Requirements:
     *
     * - `bytecode` must not be empty.
     * - `salt` must have not been used for `bytecode` already.
     * - the factory must have a balance of at least `amount`.
     * - if `amount` is non-zero, `bytecode` must have a `payable` constructor.
     */
    function deploy(uint256 amount, bytes32 salt, bytes memory bytecode) internal returns (address addr) {
        if (address(this).balance < amount) {
            revert Errors.InsufficientBalance(address(this).balance, amount);
        }
        if (bytecode.length == 0) {
            revert Create2EmptyBytecode();
        }
        assembly ("memory-safe") {
            addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt)
            // if no address was created, and returndata is not empty, bubble revert
            if and(iszero(addr), not(iszero(returndatasize()))) {
                let p := mload(0x40)
                returndatacopy(p, 0, returndatasize())
                revert(p, returndatasize())
            }
        }
        if (addr == address(0)) {
            revert Errors.FailedDeployment();
        }
    }

    /**
     * @dev Returns the address where a contract will be stored if deployed via {deploy}. Any change in the
     * `bytecodeHash` or `salt` will result in a new destination address.
     */
    function computeAddress(bytes32 salt, bytes32 bytecodeHash) internal view returns (address) {
        return computeAddress(salt, bytecodeHash, address(this));
    }

    /**
     * @dev Returns the address where a contract will be stored if deployed via {deploy} from a contract located at
     * `deployer`. If `deployer` is this contract's address, returns the same value as {computeAddress}.
     */
    function computeAddress(bytes32 salt, bytes32 bytecodeHash, address deployer) internal pure returns (address addr) {
        assembly ("memory-safe") {
            let ptr := mload(0x40) // Get free memory pointer

            // |                   | ↓ ptr ...  ↓ ptr + 0x0B (start) ...  ↓ ptr + 0x20 ...  ↓ ptr + 0x40 ...   |
            // |-------------------|---------------------------------------------------------------------------|
            // | bytecodeHash      |                                                        CCCCCCCCCCCCC...CC |
            // | salt              |                                      BBBBBBBBBBBBB...BB                   |
            // | deployer          | 000000...0000AAAAAAAAAAAAAAAAAAA...AA                                     |
            // | 0xFF              |            FF                                                             |
            // |-------------------|---------------------------------------------------------------------------|
            // | memory            | 000000...00FFAAAAAAAAAAAAAAAAAAA...AABBBBBBBBBBBBB...BBCCCCCCCCCCCCC...CC |
            // | keccak(start, 85) |            ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ |

            mstore(add(ptr, 0x40), bytecodeHash)
            mstore(add(ptr, 0x20), salt)
            mstore(ptr, deployer) // Right-aligned with 12 preceding garbage bytes
            let start := add(ptr, 0x0b) // The hashed data starts at the final garbage byte which we will set to 0xff
            mstore8(start, 0xff)
            addr := and(keccak256(start, 85), 0xffffffffffffffffffffffffffffffffffffffff)
        }
    }
}


0.0% lib/v2-core/lib/openzeppelin-contracts/contracts/utils/Errors.sol

Lines covered: 0 / 1 (0.0%)

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

pragma solidity ^0.8.20;

/**
 * @dev Collection of common custom errors used in multiple contracts
 *
 * IMPORTANT: Backwards compatibility is not guaranteed in future versions of the library.
 * It is recommended to avoid relying on the error API for critical functionality.
 *
 * _Available since v5.1._
 */
library Errors {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error InsufficientBalance(uint256 balance, uint256 needed);

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

    /**
     * @dev The deployment failed.
     */
    error FailedDeployment();

    /**
     * @dev A necessary precompile is missing.
     */
    error MissingPrecompile(address);
}


83.0% lib/v2-core/lib/openzeppelin-contracts/contracts/utils/Panic.sol

Lines covered: 5 / 6 (83.0%)

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

pragma solidity ^0.8.20;

/**
 * @dev Helper library for emitting standardized panic codes.
 *
 * ```solidity
 * contract Example {
 *      using Panic for uint256;
 *
 *      // Use any of the declared internal constants
 *      function foo() { Panic.GENERIC.panic(); }
 *
 *      // Alternatively
 *      function foo() { Panic.panic(Panic.GENERIC); }
 * }
 * ```
 *
 * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].
 *
 * _Available since v5.1._
 */
// slither-disable-next-line unused-state
library Panic {
    /// @dev generic / unspecified error
    uint256 internal constant GENERIC = 0x00;
    /// @dev used by the assert() builtin
    uint256 internal constant ASSERT = 0x01;
    /// @dev arithmetic underflow or overflow
    uint256 internal constant UNDER_OVERFLOW = 0x11;
    /// @dev division or modulo by zero
    uint256 internal constant DIVISION_BY_ZERO = 0x12;
    /// @dev enum conversion error
    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;
    /// @dev invalid encoding in storage
    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;
    /// @dev empty array pop
    uint256 internal constant EMPTY_ARRAY_POP = 0x31;
    /// @dev array out of bounds access
    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;
    /// @dev resource error (too large allocation or too large array)
    uint256 internal constant RESOURCE_ERROR = 0x41;
    /// @dev calling invalid internal function
    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;

    /// @dev Reverts with a panic code. Recommended to use with
    /// the internal constants with predefined codes.
    function panic(uint256 code) internal pure {
        assembly ("memory-safe") {
            mstore(0x00, 0x4e487b71)
            mstore(0x20, code)
            revert(0x1c, 0x24)
        }
    }
}


0.0% lib/v2-core/lib/openzeppelin-contracts/contracts/utils/SlotDerivation.sol

Lines covered: 0 / 1 (0.0%)

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

pragma solidity ^0.8.20;

/**
 * @dev Library for computing storage (and transient storage) locations from namespaces and deriving slots
 * corresponding to standard patterns. The derivation method for array and mapping matches the storage layout used by
 * the solidity language / compiler.
 *
 * See https://docs.soliditylang.org/en/v0.8.20/internals/layout_in_storage.html#mappings-and-dynamic-arrays[Solidity docs for mappings and dynamic arrays.].
 *
 * Example usage:
 * ```solidity
 * contract Example {
 *     // Add the library methods
 *     using StorageSlot for bytes32;
 *     using SlotDerivation for bytes32;
 *
 *     // Declare a namespace
 *     string private constant _NAMESPACE = "<namespace>"; // eg. OpenZeppelin.Slot
 *
 *     function setValueInNamespace(uint256 key, address newValue) internal {
 *         _NAMESPACE.erc7201Slot().deriveMapping(key).getAddressSlot().value = newValue;
 *     }
 *
 *     function getValueInNamespace(uint256 key) internal view returns (address) {
 *         return _NAMESPACE.erc7201Slot().deriveMapping(key).getAddressSlot().value;
 *     }
 * }
 * ```
 *
 * TIP: Consider using this library along with {StorageSlot}.
 *
 * NOTE: This library provides a way to manipulate storage locations in a non-standard way. Tooling for checking
 * upgrade safety will ignore the slots accessed through this library.
 *
 * _Available since v5.1._
 */
library SlotDerivation {
    /**
     * @dev Derive an ERC-7201 slot from a string (namespace).
     */
    function erc7201Slot(string memory namespace) internal pure returns (bytes32 slot) {
        assembly ("memory-safe") {
            mstore(0x00, sub(keccak256(add(namespace, 0x20), mload(namespace)), 1))
            slot := and(keccak256(0x00, 0x20), not(0xff))
        }
    }

    /**
     * @dev Add an offset to a slot to get the n-th element of a structure or an array.
     */
    function offset(bytes32 slot, uint256 pos) internal pure returns (bytes32 result) {
        unchecked {
            return bytes32(uint256(slot) + pos);
        }
    }

    /**
     * @dev Derive the location of the first element in an array from the slot where the length is stored.
     */
    function deriveArray(bytes32 slot) internal pure returns (bytes32 result) {
        assembly ("memory-safe") {
            mstore(0x00, slot)
            result := keccak256(0x00, 0x20)
        }
    }

    /**
     * @dev Derive the location of a mapping element from the key.
     */
    function deriveMapping(bytes32 slot, address key) internal pure returns (bytes32 result) {
        assembly ("memory-safe") {
            mstore(0x00, and(key, shr(96, not(0))))
            mstore(0x20, slot)
            result := keccak256(0x00, 0x40)
        }
    }

    /**
     * @dev Derive the location of a mapping element from the key.
     */
    function deriveMapping(bytes32 slot, bool key) internal pure returns (bytes32 result) {
        assembly ("memory-safe") {
            mstore(0x00, iszero(iszero(key)))
            mstore(0x20, slot)
            result := keccak256(0x00, 0x40)
        }
    }

    /**
     * @dev Derive the location of a mapping element from the key.
     */
    function deriveMapping(bytes32 slot, bytes32 key) internal pure returns (bytes32 result) {
        assembly ("memory-safe") {
            mstore(0x00, key)
            mstore(0x20, slot)
            result := keccak256(0x00, 0x40)
        }
    }

    /**
     * @dev Derive the location of a mapping element from the key.
     */
    function deriveMapping(bytes32 slot, uint256 key) internal pure returns (bytes32 result) {
        assembly ("memory-safe") {
            mstore(0x00, key)
            mstore(0x20, slot)
            result := keccak256(0x00, 0x40)
        }
    }

    /**
     * @dev Derive the location of a mapping element from the key.
     */
    function deriveMapping(bytes32 slot, int256 key) internal pure returns (bytes32 result) {
        assembly ("memory-safe") {
            mstore(0x00, key)
            mstore(0x20, slot)
            result := keccak256(0x00, 0x40)
        }
    }

    /**
     * @dev Derive the location of a mapping element from the key.
     */
    function deriveMapping(bytes32 slot, string memory key) internal pure returns (bytes32 result) {
        assembly ("memory-safe") {
            let length := mload(key)
            let begin := add(key, 0x20)
            let end := add(begin, length)
            let cache := mload(end)
            mstore(end, slot)
            result := keccak256(begin, add(length, 0x20))
            mstore(end, cache)
        }
    }

    /**
     * @dev Derive the location of a mapping element from the key.
     */
    function deriveMapping(bytes32 slot, bytes memory key) internal pure returns (bytes32 result) {
        assembly ("memory-safe") {
            let length := mload(key)
            let begin := add(key, 0x20)
            let end := add(begin, length)
            let cache := mload(end)
            mstore(end, slot)
            result := keccak256(begin, add(length, 0x20))
            mstore(end, cache)
        }
    }
}


0.0% lib/v2-core/lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol

Lines covered: 0 / 1 (0.0%)

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

pragma solidity ^0.8.20;

/**
 * @dev Library for reading and writing primitive types to specific storage slots.
 *
 * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
 * This library helps with reading and writing to such slots without the need for inline assembly.
 *
 * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
 *
 * Example usage to set ERC-1967 implementation slot:
 * ```solidity
 * contract ERC1967 {
 *     // Define the slot. Alternatively, use the SlotDerivation library to derive the slot.
 *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
 *
 *     function _getImplementation() internal view returns (address) {
 *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
 *     }
 *
 *     function _setImplementation(address newImplementation) internal {
 *         require(newImplementation.code.length > 0);
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 *
 * TIP: Consider using this library along with {SlotDerivation}.
 */
library StorageSlot {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    struct Int256Slot {
        int256 value;
    }

    struct StringSlot {
        string value;
    }

    struct BytesSlot {
        bytes value;
    }

    /**
     * @dev Returns an `AddressSlot` with member `value` located at `slot`.
     */
    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns a `BooleanSlot` with member `value` located at `slot`.
     */
    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns a `Bytes32Slot` with member `value` located at `slot`.
     */
    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns a `Uint256Slot` with member `value` located at `slot`.
     */
    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns a `Int256Slot` with member `value` located at `slot`.
     */
    function getInt256Slot(bytes32 slot) internal pure returns (Int256Slot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns a `StringSlot` with member `value` located at `slot`.
     */
    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.
     */
    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
        assembly ("memory-safe") {
            r.slot := store.slot
        }
    }

    /**
     * @dev Returns a `BytesSlot` with member `value` located at `slot`.
     */
    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
     */
    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
        assembly ("memory-safe") {
            r.slot := store.slot
        }
    }
}


0.0% lib/v2-core/lib/openzeppelin-contracts/contracts/utils/Strings.sol

Lines covered: 0 / 1 (0.0%)

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

pragma solidity ^0.8.20;

import {Math} from "./math/Math.sol";
import {SafeCast} from "./math/SafeCast.sol";
import {SignedMath} from "./math/SignedMath.sol";

/**
 * @dev String operations.
 */
library Strings {
    using SafeCast for *;

    bytes16 private constant HEX_DIGITS = "0123456789abcdef";
    uint8 private constant ADDRESS_LENGTH = 20;
    uint256 private constant SPECIAL_CHARS_LOOKUP =
        (1 << 0x08) | // backspace
            (1 << 0x09) | // tab
            (1 << 0x0a) | // newline
            (1 << 0x0c) | // form feed
            (1 << 0x0d) | // carriage return
            (1 << 0x22) | // double quote
            (1 << 0x5c); // backslash

    /**
     * @dev The `value` string doesn't fit in the specified `length`.
     */
    error StringsInsufficientHexLength(uint256 value, uint256 length);

    /**
     * @dev The string being parsed contains characters that are not in scope of the given base.
     */
    error StringsInvalidChar();

    /**
     * @dev The string being parsed is not a properly formatted address.
     */
    error StringsInvalidAddressFormat();

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            assembly ("memory-safe") {
                ptr := add(add(buffer, 0x20), length)
            }
            while (true) {
                ptr--;
                assembly ("memory-safe") {
                    mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toStringSigned(int256 value) internal pure returns (string memory) {
        return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        uint256 localValue = value;
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = HEX_DIGITS[localValue & 0xf];
            localValue >>= 4;
        }
        if (localValue != 0) {
            revert StringsInsufficientHexLength(value, length);
        }
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal
     * representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its checksummed ASCII `string` hexadecimal
     * representation, according to EIP-55.
     */
    function toChecksumHexString(address addr) internal pure returns (string memory) {
        bytes memory buffer = bytes(toHexString(addr));

        // hash the hex part of buffer (skip length + 2 bytes, length 40)
        uint256 hashValue;
        assembly ("memory-safe") {
            hashValue := shr(96, keccak256(add(buffer, 0x22), 40))
        }

        for (uint256 i = 41; i > 1; --i) {
            // possible values for buffer[i] are 48 (0) to 57 (9) and 97 (a) to 102 (f)
            if (hashValue & 0xf > 7 && uint8(buffer[i]) > 96) {
                // case shift by xoring with 0x20
                buffer[i] ^= 0x20;
            }
            hashValue >>= 4;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `bytes` buffer to its ASCII `string` hexadecimal representation.
     */
    function toHexString(bytes memory input) internal pure returns (string memory) {
        unchecked {
            bytes memory buffer = new bytes(2 * input.length + 2);
            buffer[0] = "0";
            buffer[1] = "x";
            for (uint256 i = 0; i < input.length; ++i) {
                uint8 v = uint8(input[i]);
                buffer[2 * i + 2] = HEX_DIGITS[v >> 4];
                buffer[2 * i + 3] = HEX_DIGITS[v & 0xf];
            }
            return string(buffer);
        }
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
    }

    /**
     * @dev Parse a decimal string and returns the value as a `uint256`.
     *
     * Requirements:
     * - The string must be formatted as `[0-9]*`
     * - The result must fit into an `uint256` type
     */
    function parseUint(string memory input) internal pure returns (uint256) {
        return parseUint(input, 0, bytes(input).length);
    }

    /**
     * @dev Variant of {parseUint-string} that parses a substring of `input` located between position `begin` (included) and
     * `end` (excluded).
     *
     * Requirements:
     * - The substring must be formatted as `[0-9]*`
     * - The result must fit into an `uint256` type
     */
    function parseUint(string memory input, uint256 begin, uint256 end) internal pure returns (uint256) {
        (bool success, uint256 value) = tryParseUint(input, begin, end);
        if (!success) revert StringsInvalidChar();
        return value;
    }

    /**
     * @dev Variant of {parseUint-string} that returns false if the parsing fails because of an invalid character.
     *
     * NOTE: This function will revert if the result does not fit in a `uint256`.
     */
    function tryParseUint(string memory input) internal pure returns (bool success, uint256 value) {
        return _tryParseUintUncheckedBounds(input, 0, bytes(input).length);
    }

    /**
     * @dev Variant of {parseUint-string-uint256-uint256} that returns false if the parsing fails because of an invalid
     * character.
     *
     * NOTE: This function will revert if the result does not fit in a `uint256`.
     */
    function tryParseUint(
        string memory input,
        uint256 begin,
        uint256 end
    ) internal pure returns (bool success, uint256 value) {
        if (end > bytes(input).length || begin > end) return (false, 0);
        return _tryParseUintUncheckedBounds(input, begin, end);
    }

    /**
     * @dev Implementation of {tryParseUint-string-uint256-uint256} that does not check bounds. Caller should make sure that
     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.
     */
    function _tryParseUintUncheckedBounds(
        string memory input,
        uint256 begin,
        uint256 end
    ) private pure returns (bool success, uint256 value) {
        bytes memory buffer = bytes(input);

        uint256 result = 0;
        for (uint256 i = begin; i < end; ++i) {
            uint8 chr = _tryParseChr(bytes1(_unsafeReadBytesOffset(buffer, i)));
            if (chr > 9) return (false, 0);
            result *= 10;
            result += chr;
        }
        return (true, result);
    }

    /**
     * @dev Parse a decimal string and returns the value as a `int256`.
     *
     * Requirements:
     * - The string must be formatted as `[-+]?[0-9]*`
     * - The result must fit in an `int256` type.
     */
    function parseInt(string memory input) internal pure returns (int256) {
        return parseInt(input, 0, bytes(input).length);
    }

    /**
     * @dev Variant of {parseInt-string} that parses a substring of `input` located between position `begin` (included) and
     * `end` (excluded).
     *
     * Requirements:
     * - The substring must be formatted as `[-+]?[0-9]*`
     * - The result must fit in an `int256` type.
     */
    function parseInt(string memory input, uint256 begin, uint256 end) internal pure returns (int256) {
        (bool success, int256 value) = tryParseInt(input, begin, end);
        if (!success) revert StringsInvalidChar();
        return value;
    }

    /**
     * @dev Variant of {parseInt-string} that returns false if the parsing fails because of an invalid character or if
     * the result does not fit in a `int256`.
     *
     * NOTE: This function will revert if the absolute value of the result does not fit in a `uint256`.
     */
    function tryParseInt(string memory input) internal pure returns (bool success, int256 value) {
        return _tryParseIntUncheckedBounds(input, 0, bytes(input).length);
    }

    uint256 private constant ABS_MIN_INT256 = 2 ** 255;

    /**
     * @dev Variant of {parseInt-string-uint256-uint256} that returns false if the parsing fails because of an invalid
     * character or if the result does not fit in a `int256`.
     *
     * NOTE: This function will revert if the absolute value of the result does not fit in a `uint256`.
     */
    function tryParseInt(
        string memory input,
        uint256 begin,
        uint256 end
    ) internal pure returns (bool success, int256 value) {
        if (end > bytes(input).length || begin > end) return (false, 0);
        return _tryParseIntUncheckedBounds(input, begin, end);
    }

    /**
     * @dev Implementation of {tryParseInt-string-uint256-uint256} that does not check bounds. Caller should make sure that
     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.
     */
    function _tryParseIntUncheckedBounds(
        string memory input,
        uint256 begin,
        uint256 end
    ) private pure returns (bool success, int256 value) {
        bytes memory buffer = bytes(input);

        // Check presence of a negative sign.
        bytes1 sign = begin == end ? bytes1(0) : bytes1(_unsafeReadBytesOffset(buffer, begin)); // don't do out-of-bound (possibly unsafe) read if sub-string is empty
        bool positiveSign = sign == bytes1("+");
        bool negativeSign = sign == bytes1("-");
        uint256 offset = (positiveSign || negativeSign).toUint();

        (bool absSuccess, uint256 absValue) = tryParseUint(input, begin + offset, end);

        if (absSuccess && absValue < ABS_MIN_INT256) {
            return (true, negativeSign ? -int256(absValue) : int256(absValue));
        } else if (absSuccess && negativeSign && absValue == ABS_MIN_INT256) {
            return (true, type(int256).min);
        } else return (false, 0);
    }

    /**
     * @dev Parse a hexadecimal string (with or without "0x" prefix), and returns the value as a `uint256`.
     *
     * Requirements:
     * - The string must be formatted as `(0x)?[0-9a-fA-F]*`
     * - The result must fit in an `uint256` type.
     */
    function parseHexUint(string memory input) internal pure returns (uint256) {
        return parseHexUint(input, 0, bytes(input).length);
    }

    /**
     * @dev Variant of {parseHexUint-string} that parses a substring of `input` located between position `begin` (included) and
     * `end` (excluded).
     *
     * Requirements:
     * - The substring must be formatted as `(0x)?[0-9a-fA-F]*`
     * - The result must fit in an `uint256` type.
     */
    function parseHexUint(string memory input, uint256 begin, uint256 end) internal pure returns (uint256) {
        (bool success, uint256 value) = tryParseHexUint(input, begin, end);
        if (!success) revert StringsInvalidChar();
        return value;
    }

    /**
     * @dev Variant of {parseHexUint-string} that returns false if the parsing fails because of an invalid character.
     *
     * NOTE: This function will revert if the result does not fit in a `uint256`.
     */
    function tryParseHexUint(string memory input) internal pure returns (bool success, uint256 value) {
        return _tryParseHexUintUncheckedBounds(input, 0, bytes(input).length);
    }

    /**
     * @dev Variant of {parseHexUint-string-uint256-uint256} that returns false if the parsing fails because of an
     * invalid character.
     *
     * NOTE: This function will revert if the result does not fit in a `uint256`.
     */
    function tryParseHexUint(
        string memory input,
        uint256 begin,
        uint256 end
    ) internal pure returns (bool success, uint256 value) {
        if (end > bytes(input).length || begin > end) return (false, 0);
        return _tryParseHexUintUncheckedBounds(input, begin, end);
    }

    /**
     * @dev Implementation of {tryParseHexUint-string-uint256-uint256} that does not check bounds. Caller should make sure that
     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.
     */
    function _tryParseHexUintUncheckedBounds(
        string memory input,
        uint256 begin,
        uint256 end
    ) private pure returns (bool success, uint256 value) {
        bytes memory buffer = bytes(input);

        // skip 0x prefix if present
        bool hasPrefix = (end > begin + 1) && bytes2(_unsafeReadBytesOffset(buffer, begin)) == bytes2("0x"); // don't do out-of-bound (possibly unsafe) read if sub-string is empty
        uint256 offset = hasPrefix.toUint() * 2;

        uint256 result = 0;
        for (uint256 i = begin + offset; i < end; ++i) {
            uint8 chr = _tryParseChr(bytes1(_unsafeReadBytesOffset(buffer, i)));
            if (chr > 15) return (false, 0);
            result *= 16;
            unchecked {
                // Multiplying by 16 is equivalent to a shift of 4 bits (with additional overflow check).
                // This guarantees that adding a value < 16 will not cause an overflow, hence the unchecked.
                result += chr;
            }
        }
        return (true, result);
    }

    /**
     * @dev Parse a hexadecimal string (with or without "0x" prefix), and returns the value as an `address`.
     *
     * Requirements:
     * - The string must be formatted as `(0x)?[0-9a-fA-F]{40}`
     */
    function parseAddress(string memory input) internal pure returns (address) {
        return parseAddress(input, 0, bytes(input).length);
    }

    /**
     * @dev Variant of {parseAddress-string} that parses a substring of `input` located between position `begin` (included) and
     * `end` (excluded).
     *
     * Requirements:
     * - The substring must be formatted as `(0x)?[0-9a-fA-F]{40}`
     */
    function parseAddress(string memory input, uint256 begin, uint256 end) internal pure returns (address) {
        (bool success, address value) = tryParseAddress(input, begin, end);
        if (!success) revert StringsInvalidAddressFormat();
        return value;
    }

    /**
     * @dev Variant of {parseAddress-string} that returns false if the parsing fails because the input is not a properly
     * formatted address. See {parseAddress-string} requirements.
     */
    function tryParseAddress(string memory input) internal pure returns (bool success, address value) {
        return tryParseAddress(input, 0, bytes(input).length);
    }

    /**
     * @dev Variant of {parseAddress-string-uint256-uint256} that returns false if the parsing fails because input is not a properly
     * formatted address. See {parseAddress-string-uint256-uint256} requirements.
     */
    function tryParseAddress(
        string memory input,
        uint256 begin,
        uint256 end
    ) internal pure returns (bool success, address value) {
        if (end > bytes(input).length || begin > end) return (false, address(0));

        bool hasPrefix = (end > begin + 1) && bytes2(_unsafeReadBytesOffset(bytes(input), begin)) == bytes2("0x"); // don't do out-of-bound (possibly unsafe) read if sub-string is empty
        uint256 expectedLength = 40 + hasPrefix.toUint() * 2;

        // check that input is the correct length
        if (end - begin == expectedLength) {
            // length guarantees that this does not overflow, and value is at most type(uint160).max
            (bool s, uint256 v) = _tryParseHexUintUncheckedBounds(input, begin, end);
            return (s, address(uint160(v)));
        } else {
            return (false, address(0));
        }
    }

    function _tryParseChr(bytes1 chr) private pure returns (uint8) {
        uint8 value = uint8(chr);

        // Try to parse `chr`:
        // - Case 1: [0-9]
        // - Case 2: [a-f]
        // - Case 3: [A-F]
        // - otherwise not supported
        unchecked {
            if (value > 47 && value < 58) value -= 48;
            else if (value > 96 && value < 103) value -= 87;
            else if (value > 64 && value < 71) value -= 55;
            else return type(uint8).max;
        }

        return value;
    }

    /**
     * @dev Escape special characters in JSON strings. This can be useful to prevent JSON injection in NFT metadata.
     *
     * WARNING: This function should only be used in double quoted JSON strings. Single quotes are not escaped.
     *
     * NOTE: This function escapes all unicode characters, and not just the ones in ranges defined in section 2.5 of
     * RFC-4627 (U+0000 to U+001F, U+0022 and U+005C). ECMAScript's `JSON.parse` does recover escaped unicode
     * characters that are not in this range, but other tooling may provide different results.
     */
    function escapeJSON(string memory input) internal pure returns (string memory) {
        bytes memory buffer = bytes(input);
        bytes memory output = new bytes(2 * buffer.length); // worst case scenario
        uint256 outputLength = 0;

        for (uint256 i; i < buffer.length; ++i) {
            bytes1 char = bytes1(_unsafeReadBytesOffset(buffer, i));
            if (((SPECIAL_CHARS_LOOKUP & (1 << uint8(char))) != 0)) {
                output[outputLength++] = "\\";
                if (char == 0x08) output[outputLength++] = "b";
                else if (char == 0x09) output[outputLength++] = "t";
                else if (char == 0x0a) output[outputLength++] = "n";
                else if (char == 0x0c) output[outputLength++] = "f";
                else if (char == 0x0d) output[outputLength++] = "r";
                else if (char == 0x5c) output[outputLength++] = "\\";
                else if (char == 0x22) {
                    // solhint-disable-next-line quotes
                    output[outputLength++] = '"';
                }
            } else {
                output[outputLength++] = char;
            }
        }
        // write the actual length and deallocate unused memory
        assembly ("memory-safe") {
            mstore(output, outputLength)
            mstore(0x40, add(output, shl(5, shr(5, add(outputLength, 63)))))
        }

        return string(output);
    }

    /**
     * @dev Reads a bytes32 from a bytes array without bounds checking.
     *
     * NOTE: making this function internal would mean it could be used with memory unsafe offset, and marking the
     * assembly block as such would prevent some optimizations.
     */
    function _unsafeReadBytesOffset(bytes memory buffer, uint256 offset) private pure returns (bytes32 value) {
        // This is not memory safe in the general case, but all calls to this private function are within bounds.
        assembly ("memory-safe") {
            value := mload(add(add(buffer, 0x20), offset))
        }
    }
}


0.0% lib/v2-core/lib/openzeppelin-contracts/contracts/utils/cryptography/ECDSA.sol

Lines covered: 0 / 30 (0.0%)

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.20;

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS
    }

    /**
     * @dev The signature derives the `address(0)`.
     */
    error ECDSAInvalidSignature();

    /**
     * @dev The signature has an invalid length.
     */
    error ECDSAInvalidSignatureLength(uint256 length);

    /**
     * @dev The signature has an S value that is in the upper half order.
     */
    error ECDSAInvalidSignatureS(bytes32 s);

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with `signature` or an error. This will not
     * return address(0) without also returning an error description. Errors are documented using an enum (error type)
     * and a bytes32 providing additional information about the error.
     *
     * If no error is returned, then the address can be used for verification purposes.
     *
     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     */
    function tryRecover(
        bytes32 hash,
        bytes memory signature
    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly ("memory-safe") {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[ERC-2098 short signatures]
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {
        unchecked {
            bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
            // We do not check for an overflow here since the shift operation results in 0 or 1.
            uint8 v = uint8((uint256(vs) >> 255) + 27);
            return tryRecover(hash, v, r, s);
        }
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     */
    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS, s);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature, bytes32(0));
        }

        return (signer, RecoverError.NoError, bytes32(0));
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.
     */
    function _throwError(RecoverError error, bytes32 errorArg) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert ECDSAInvalidSignature();
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert ECDSAInvalidSignatureLength(uint256(errorArg));
        } else if (error == RecoverError.InvalidSignatureS) {
            revert ECDSAInvalidSignatureS(errorArg);
        }
    }
}


0.0% lib/v2-core/lib/openzeppelin-contracts/contracts/utils/cryptography/Hashes.sol

Lines covered: 0 / 7 (0.0%)

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.3.0) (utils/cryptography/Hashes.sol)

pragma solidity ^0.8.20;

/**
 * @dev Library of standard hash functions.
 *
 * _Available since v5.1._
 */
library Hashes {
    /**
     * @dev Commutative Keccak256 hash of a sorted pair of bytes32. Frequently used when working with merkle proofs.
     *
     * NOTE: Equivalent to the `standardNodeHash` in our https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
     */
    function commutativeKeccak256(bytes32 a, bytes32 b) internal pure returns (bytes32) {
        return a < b ? efficientKeccak256(a, b) : efficientKeccak256(b, a);
    }

    /**
     * @dev Implementation of keccak256(abi.encode(a, b)) that doesn't allocate or expand memory.
     */
    function efficientKeccak256(bytes32 a, bytes32 b) internal pure returns (bytes32 value) {
        assembly ("memory-safe") {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}


0.0% lib/v2-core/lib/openzeppelin-contracts/contracts/utils/cryptography/MerkleProof.sol

Lines covered: 0 / 8 (0.0%)

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

pragma solidity ^0.8.20;

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

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The tree and the proofs can be generated using our
 * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
 * You will find a quickstart guide in the readme.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the Merkle tree could be reinterpreted as a leaf value.
 * OpenZeppelin's JavaScript library generates Merkle trees that are safe
 * against this attack out of the box.
 *
 * IMPORTANT: Consider memory side-effects when using custom hashing functions
 * that access memory in an unsafe way.
 *
 * NOTE: This library supports proof verification for merkle trees built using
 * custom _commutative_ hashing functions (i.e. `H(a, b) == H(b, a)`). Proving
 * leaf inclusion in trees built using non-commutative hashing functions requires
 * additional logic that is not supported by this library.
 */
library MerkleProof {
    /**
     *@dev The multiproof provided is not valid.
     */
    error MerkleProofInvalidMultiproof();

    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     *
     * This version handles proofs in memory with the default hashing function.
     */
    function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leaves & pre-images are assumed to be sorted.
     *
     * This version handles proofs in memory with the default hashing function.
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = Hashes.commutativeKeccak256(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     *
     * This version handles proofs in memory with a custom hashing function.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf,
        function(bytes32, bytes32) view returns (bytes32) hasher
    ) internal view returns (bool) {
        return processProof(proof, leaf, hasher) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leaves & pre-images are assumed to be sorted.
     *
     * This version handles proofs in memory with a custom hashing function.
     */
    function processProof(
        bytes32[] memory proof,
        bytes32 leaf,
        function(bytes32, bytes32) view returns (bytes32) hasher
    ) internal view returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = hasher(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     *
     * This version handles proofs in calldata with the default hashing function.
     */
    function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        return processProofCalldata(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leaves & pre-images are assumed to be sorted.
     *
     * This version handles proofs in calldata with the default hashing function.
     */
    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = Hashes.commutativeKeccak256(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     *
     * This version handles proofs in calldata with a custom hashing function.
     */
    function verifyCalldata(
        bytes32[] calldata proof,
        bytes32 root,
        bytes32 leaf,
        function(bytes32, bytes32) view returns (bytes32) hasher
    ) internal view returns (bool) {
        return processProofCalldata(proof, leaf, hasher) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leaves & pre-images are assumed to be sorted.
     *
     * This version handles proofs in calldata with a custom hashing function.
     */
    function processProofCalldata(
        bytes32[] calldata proof,
        bytes32 leaf,
        function(bytes32, bytes32) view returns (bytes32) hasher
    ) internal view returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = hasher(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a Merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * This version handles multiproofs in memory with the default hashing function.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * NOTE: Consider the case where `root == proof[0] && leaves.length == 0` as it will return `true`.
     * The `leaves` must be validated independently. See {processMultiProof}.
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
     * respectively.
     *
     * This version handles multiproofs in memory with the default hashing function.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
     *
     * NOTE: The _empty set_ (i.e. the case where `proof.length == 1 && leaves.length == 0`) is considered a no-op,
     * and therefore a valid multiproof (i.e. it returns `proof[0]`). Consider disallowing this case if you're not
     * validating the leaves elsewhere.
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the Merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofFlagsLen = proofFlags.length;

        // Check proof validity.
        if (leavesLen + proof.length != proofFlagsLen + 1) {
            revert MerkleProofInvalidMultiproof();
        }

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](proofFlagsLen);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < proofFlagsLen; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = Hashes.commutativeKeccak256(a, b);
        }

        if (proofFlagsLen > 0) {
            if (proofPos != proof.length) {
                revert MerkleProofInvalidMultiproof();
            }
            unchecked {
                return hashes[proofFlagsLen - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a Merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * This version handles multiproofs in memory with a custom hashing function.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * NOTE: Consider the case where `root == proof[0] && leaves.length == 0` as it will return `true`.
     * The `leaves` must be validated independently. See {processMultiProof}.
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves,
        function(bytes32, bytes32) view returns (bytes32) hasher
    ) internal view returns (bool) {
        return processMultiProof(proof, proofFlags, leaves, hasher) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
     * respectively.
     *
     * This version handles multiproofs in memory with a custom hashing function.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
     *
     * NOTE: The _empty set_ (i.e. the case where `proof.length == 1 && leaves.length == 0`) is considered a no-op,
     * and therefore a valid multiproof (i.e. it returns `proof[0]`). Consider disallowing this case if you're not
     * validating the leaves elsewhere.
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves,
        function(bytes32, bytes32) view returns (bytes32) hasher
    ) internal view returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the Merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofFlagsLen = proofFlags.length;

        // Check proof validity.
        if (leavesLen + proof.length != proofFlagsLen + 1) {
            revert MerkleProofInvalidMultiproof();
        }

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](proofFlagsLen);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < proofFlagsLen; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = hasher(a, b);
        }

        if (proofFlagsLen > 0) {
            if (proofPos != proof.length) {
                revert MerkleProofInvalidMultiproof();
            }
            unchecked {
                return hashes[proofFlagsLen - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a Merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * This version handles multiproofs in calldata with the default hashing function.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * NOTE: Consider the case where `root == proof[0] && leaves.length == 0` as it will return `true`.
     * The `leaves` must be validated independently. See {processMultiProofCalldata}.
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
     * respectively.
     *
     * This version handles multiproofs in calldata with the default hashing function.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
     *
     * NOTE: The _empty set_ (i.e. the case where `proof.length == 1 && leaves.length == 0`) is considered a no-op,
     * and therefore a valid multiproof (i.e. it returns `proof[0]`). Consider disallowing this case if you're not
     * validating the leaves elsewhere.
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the Merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofFlagsLen = proofFlags.length;

        // Check proof validity.
        if (leavesLen + proof.length != proofFlagsLen + 1) {
            revert MerkleProofInvalidMultiproof();
        }

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](proofFlagsLen);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < proofFlagsLen; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = Hashes.commutativeKeccak256(a, b);
        }

        if (proofFlagsLen > 0) {
            if (proofPos != proof.length) {
                revert MerkleProofInvalidMultiproof();
            }
            unchecked {
                return hashes[proofFlagsLen - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a Merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * This version handles multiproofs in calldata with a custom hashing function.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * NOTE: Consider the case where `root == proof[0] && leaves.length == 0` as it will return `true`.
     * The `leaves` must be validated independently. See {processMultiProofCalldata}.
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves,
        function(bytes32, bytes32) view returns (bytes32) hasher
    ) internal view returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves, hasher) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
     * respectively.
     *
     * This version handles multiproofs in calldata with a custom hashing function.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
     *
     * NOTE: The _empty set_ (i.e. the case where `proof.length == 1 && leaves.length == 0`) is considered a no-op,
     * and therefore a valid multiproof (i.e. it returns `proof[0]`). Consider disallowing this case if you're not
     * validating the leaves elsewhere.
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves,
        function(bytes32, bytes32) view returns (bytes32) hasher
    ) internal view returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the Merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofFlagsLen = proofFlags.length;

        // Check proof validity.
        if (leavesLen + proof.length != proofFlagsLen + 1) {
            revert MerkleProofInvalidMultiproof();
        }

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](proofFlagsLen);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < proofFlagsLen; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = hasher(a, b);
        }

        if (proofFlagsLen > 0) {
            if (proofPos != proof.length) {
                revert MerkleProofInvalidMultiproof();
            }
            unchecked {
                return hashes[proofFlagsLen - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }
}


0.0% lib/v2-core/lib/openzeppelin-contracts/contracts/utils/cryptography/MessageHashUtils.sol

Lines covered: 0 / 7 (0.0%)

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.3.0) (utils/cryptography/MessageHashUtils.sol)

pragma solidity ^0.8.20;

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

/**
 * @dev Signature message hash utilities for producing digests to be consumed by {ECDSA} recovery or signing.
 *
 * The library provides methods for generating a hash of a message that conforms to the
 * https://eips.ethereum.org/EIPS/eip-191[ERC-191] and https://eips.ethereum.org/EIPS/eip-712[EIP 712]
 * specifications.
 */
library MessageHashUtils {
    /**
     * @dev Returns the keccak256 digest of an ERC-191 signed data with version
     * `0x45` (`personal_sign` messages).
     *
     * The digest is calculated by prefixing a bytes32 `messageHash` with
     * `"\x19Ethereum Signed Message:\n32"` and hashing the result. It corresponds with the
     * hash signed when using the https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_sign[`eth_sign`] JSON-RPC method.
     *
     * NOTE: The `messageHash` parameter is intended to be the result of hashing a raw message with
     * keccak256, although any bytes32 value can be safely used because the final digest will
     * be re-hashed.
     *
     * See {ECDSA-recover}.
     */
    function toEthSignedMessageHash(bytes32 messageHash) internal pure returns (bytes32 digest) {
        assembly ("memory-safe") {
            mstore(0x00, "\x19Ethereum Signed Message:\n32") // 32 is the bytes-length of messageHash
            mstore(0x1c, messageHash) // 0x1c (28) is the length of the prefix
            digest := keccak256(0x00, 0x3c) // 0x3c is the length of the prefix (0x1c) + messageHash (0x20)
        }
    }

    /**
     * @dev Returns the keccak256 digest of an ERC-191 signed data with version
     * `0x45` (`personal_sign` messages).
     *
     * The digest is calculated by prefixing an arbitrary `message` with
     * `"\x19Ethereum Signed Message:\n" + len(message)` and hashing the result. It corresponds with the
     * hash signed when using the https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_sign[`eth_sign`] JSON-RPC method.
     *
     * See {ECDSA-recover}.
     */
    function toEthSignedMessageHash(bytes memory message) internal pure returns (bytes32) {
        return
            keccak256(bytes.concat("\x19Ethereum Signed Message:\n", bytes(Strings.toString(message.length)), message));
    }

    /**
     * @dev Returns the keccak256 digest of an ERC-191 signed data with version
     * `0x00` (data with intended validator).
     *
     * The digest is calculated by prefixing an arbitrary `data` with `"\x19\x00"` and the intended
     * `validator` address. Then hashing the result.
     *
     * See {ECDSA-recover}.
     */
    function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked(hex"19_00", validator, data));
    }

    /**
     * @dev Variant of {toDataWithIntendedValidatorHash-address-bytes} optimized for cases where `data` is a bytes32.
     */
    function toDataWithIntendedValidatorHash(
        address validator,
        bytes32 messageHash
    ) internal pure returns (bytes32 digest) {
        assembly ("memory-safe") {
            mstore(0x00, hex"19_00")
            mstore(0x02, shl(96, validator))
            mstore(0x16, messageHash)
            digest := keccak256(0x00, 0x36)
        }
    }

    /**
     * @dev Returns the keccak256 digest of an EIP-712 typed data (ERC-191 version `0x01`).
     *
     * The digest is calculated from a `domainSeparator` and a `structHash`, by prefixing them with
     * `\x19\x01` and hashing the result. It corresponds to the hash signed by the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] JSON-RPC method as part of EIP-712.
     *
     * See {ECDSA-recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 digest) {
        assembly ("memory-safe") {
            let ptr := mload(0x40)
            mstore(ptr, hex"19_01")
            mstore(add(ptr, 0x02), domainSeparator)
            mstore(add(ptr, 0x22), structHash)
            digest := keccak256(ptr, 0x42)
        }
    }
}


0.0% lib/v2-core/lib/openzeppelin-contracts/contracts/utils/introspection/ERC165.sol

Lines covered: 0 / 1 (0.0%)

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/ERC165.sol)

pragma solidity ^0.8.20;

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

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC-165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 */
abstract contract ERC165 is IERC165 {
    /// @inheritdoc IERC165
    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}


0.0% lib/v2-core/lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol

Lines covered: 0 / 0 (0.0%)

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)

pragma solidity >=0.4.16;

/**
 * @dev Interface of the ERC-165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[ERC].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}


96.0% lib/v2-core/lib/openzeppelin-contracts/contracts/utils/math/Math.sol

Lines covered: 32 / 33 (96.0%)

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

pragma solidity ^0.8.20;

import {Panic} from "../Panic.sol";
import {SafeCast} from "./SafeCast.sol";

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Return the 512-bit addition of two uint256.
     *
     * The result is stored in two 256 variables such that sum = high * 2²⁵⁶ + low.
     */
    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {
        assembly ("memory-safe") {
            low := add(a, b)
            high := lt(low, a)
        }
    }

    /**
     * @dev Return the 512-bit multiplication of two uint256.
     *
     * The result is stored in two 256 variables such that product = high * 2²⁵⁶ + low.
     */
    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {
        // 512-bit multiply [high low] = x * y. Compute the product mod 2²⁵⁶ and mod 2²⁵⁶ - 1, then use
        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
        // variables such that product = high * 2²⁵⁶ + low.
        assembly ("memory-safe") {
            let mm := mulmod(a, b, not(0))
            low := mul(a, b)
            high := sub(sub(mm, low), lt(mm, low))
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            uint256 c = a + b;
            success = c >= a;
            result = c * SafeCast.toUint(success);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            uint256 c = a - b;
            success = c <= a;
            result = c * SafeCast.toUint(success);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            uint256 c = a * b;
            assembly ("memory-safe") {
                // Only true when the multiplication doesn't overflow
                // (c / a == b) || (a == 0)
                success := or(eq(div(c, a), b), iszero(a))
            }
            // equivalent to: success ? c : 0
            result = c * SafeCast.toUint(success);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            success = b > 0;
            assembly ("memory-safe") {
                // The `DIV` opcode returns zero when the denominator is 0.
                result := div(a, b)
            }
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            success = b > 0;
            assembly ("memory-safe") {
                // The `MOD` opcode returns zero when the denominator is 0.
                result := mod(a, b)
            }
        }
    }

    /**
     * @dev Unsigned saturating addition, bounds to `2²⁵⁶ - 1` instead of overflowing.
     */
    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {
        (bool success, uint256 result) = tryAdd(a, b);
        return ternary(success, result, type(uint256).max);
    }

    /**
     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.
     */
    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {
        (, uint256 result) = trySub(a, b);
        return result;
    }

    /**
     * @dev Unsigned saturating multiplication, bounds to `2²⁵⁶ - 1` instead of overflowing.
     */
    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {
        (bool success, uint256 result) = tryMul(a, b);
        return ternary(success, result, type(uint256).max);
    }

    /**
     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.
     *
     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.
     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute
     * one branch when needed, making this function more expensive.
     */
    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {
        unchecked {
            // branchless ternary works because:
            // b ^ (a ^ b) == a
            // b ^ 0 == b
            return b ^ ((a ^ b) * SafeCast.toUint(condition));
        }
    }

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

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return ternary(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.
            Panic.panic(Panic.DIVISION_BY_ZERO);
        }

        // The following calculation ensures accurate ceiling division without overflow.
        // Since a is non-zero, (a - 1) / b will not overflow.
        // The largest possible result occurs when (a - 1) / b is type(uint256).max,
        // but the largest value we can obtain is type(uint256).max - 1, which happens
        // when a = type(uint256).max and b = 1.
        unchecked {
            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);
        }
    }

    /**
     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
     * denominator == 0.
     *
     * 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 {
            (uint256 high, uint256 low) = mul512(x, y);

            // Handle non-overflow cases, 256 by 256 division.
            if (high == 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 low / denominator;
            }

            // Make sure the result is less than 2²⁵⁶. Also prevents denominator == 0.
            if (denominator <= high) {
                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));
            }

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

            // Make division exact by subtracting the remainder from [high low].
            uint256 remainder;
            assembly ("memory-safe") {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                high := sub(high, gt(remainder, low))
                low := sub(low, 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 ("memory-safe") {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [high low] by twos.
                low := div(low, twos)

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

            // Shift in bits from high into low.
            low |= high * twos;

            // Invert denominator mod 2²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such
            // that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv ≡ 1 mod 2⁴.
            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⁸
            inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶
            inverse *= 2 - denominator * inverse; // inverse mod 2³²
            inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴
            inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸
            inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶

            // 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²⁵⁶. Since the preconditions guarantee that the outcome is
            // less than 2²⁵⁶, this is the final result. We don't need to compute the high bits of the result and high
            // is no longer required.
            result = low * inverse;
            return result;
        }
    }

    /**
     * @dev 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) {
        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);
    }

    /**
     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.
     */
    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {
        unchecked {
            (uint256 high, uint256 low) = mul512(x, y);
            if (high >= 1 << n) {
                Panic.panic(Panic.UNDER_OVERFLOW);
            }
            return (high << (256 - n)) | (low >> n);
        }
    }

    /**
     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.
     */
    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {
        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);
    }

    /**
     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.
     *
     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.
     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.
     *
     * If the input value is not inversible, 0 is returned.
     *
     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the
     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.
     */
    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {
        unchecked {
            if (n == 0) return 0;

            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)
            // Used to compute integers x and y such that: ax + ny = gcd(a, n).
            // When the gcd is 1, then the inverse of a modulo n exists and it's x.
            // ax + ny = 1
            // ax = 1 + (-y)n
            // ax ≡ 1 (mod n) # x is the inverse of a modulo n

            // If the remainder is 0 the gcd is n right away.
            uint256 remainder = a % n;
            uint256 gcd = n;

            // Therefore the initial coefficients are:
            // ax + ny = gcd(a, n) = n
            // 0a + 1n = n
            int256 x = 0;
            int256 y = 1;

            while (remainder != 0) {
                uint256 quotient = gcd / remainder;

                (gcd, remainder) = (
                    // The old remainder is the next gcd to try.
                    remainder,
                    // Compute the next remainder.
                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd
                    // where gcd is at most n (capped to type(uint256).max)
                    gcd - remainder * quotient
                );

                (x, y) = (
                    // Increment the coefficient of a.
                    y,
                    // Decrement the coefficient of n.
                    // Can overflow, but the result is casted to uint256 so that the
                    // next value of y is "wrapped around" to a value between 0 and n - 1.
                    x - y * int256(quotient)
                );
            }

            if (gcd != 1) return 0; // No inverse exists.
            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.
        }
    }

    /**
     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.
     *
     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is
     * prime, then `a**(p-1) ≡ 1 mod p`. As a consequence, we have `a * a**(p-2) ≡ 1 mod p`, which means that
     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.
     *
     * NOTE: this function does NOT check that `p` is a prime greater than `2`.
     */
    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {
        unchecked {
            return Math.modExp(a, p - 2, p);
        }
    }

    /**
     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)
     *
     * Requirements:
     * - modulus can't be zero
     * - underlying staticcall to precompile must succeed
     *
     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make
     * sure the chain you're using it on supports the precompiled contract for modular exponentiation
     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,
     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly
     * interpreted as 0.
     */
    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {
        (bool success, uint256 result) = tryModExp(b, e, m);
        if (!success) {
            Panic.panic(Panic.DIVISION_BY_ZERO);
        }
        return result;
    }

    /**
     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).
     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying
     * to operate modulo 0 or if the underlying precompile reverted.
     *
     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain
     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in
     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack
     * of a revert, but the result may be incorrectly interpreted as 0.
     */
    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {
        if (m == 0) return (false, 0);
        assembly ("memory-safe") {
            let ptr := mload(0x40)
            // | Offset    | Content    | Content (Hex)                                                      |
            // |-----------|------------|--------------------------------------------------------------------|
            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |
            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |
            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |
            // | 0x60:0x7f | value of b | 0x<.............................................................b> |
            // | 0x80:0x9f | value of e | 0x<.............................................................e> |
            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |
            mstore(ptr, 0x20)
            mstore(add(ptr, 0x20), 0x20)
            mstore(add(ptr, 0x40), 0x20)
            mstore(add(ptr, 0x60), b)
            mstore(add(ptr, 0x80), e)
            mstore(add(ptr, 0xa0), m)

            // Given the result < m, it's guaranteed to fit in 32 bytes,
            // so we can use the memory scratch space located at offset 0.
            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)
            result := mload(0x00)
        }
    }

    /**
     * @dev Variant of {modExp} that supports inputs of arbitrary length.
     */
    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {
        (bool success, bytes memory result) = tryModExp(b, e, m);
        if (!success) {
            Panic.panic(Panic.DIVISION_BY_ZERO);
        }
        return result;
    }

    /**
     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.
     */
    function tryModExp(
        bytes memory b,
        bytes memory e,
        bytes memory m
    ) internal view returns (bool success, bytes memory result) {
        if (_zeroBytes(m)) return (false, new bytes(0));

        uint256 mLen = m.length;

        // Encode call args in result and move the free memory pointer
        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);

        assembly ("memory-safe") {
            let dataPtr := add(result, 0x20)
            // Write result on top of args to avoid allocating extra memory.
            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)
            // Overwrite the length.
            // result.length > returndatasize() is guaranteed because returndatasize() == m.length
            mstore(result, mLen)
            // Set the memory pointer after the returned data.
            mstore(0x40, add(dataPtr, mLen))
        }
    }

    /**
     * @dev Returns whether the provided byte array is zero.
     */
    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {
        for (uint256 i = 0; i < byteArray.length; ++i) {
            if (byteArray[i] != 0) {
                return false;
            }
        }
        return true;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
     * towards zero.
     *
     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only
     * using integer operations.
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        unchecked {
            // Take care of easy edge cases when a == 0 or a == 1
            if (a <= 1) {
                return a;
            }

            // In this function, we use Newton's method to get a root of `f(x) := x² - a`. It involves building a
            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between
            // the current value as `ε_n = | x_n - sqrt(a) |`.
            //
            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root
            // of the target. (i.e. `2**(e-1) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is
            // bigger than any uint256.
            //
            // By noticing that
            // `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ a < 2**(2*e)`
            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar
            // to the msb function.
            uint256 aa = a;
            uint256 xn = 1;

            if (aa >= (1 << 128)) {
                aa >>= 128;
                xn <<= 64;
            }
            if (aa >= (1 << 64)) {
                aa >>= 64;
                xn <<= 32;
            }
            if (aa >= (1 << 32)) {
                aa >>= 32;
                xn <<= 16;
            }
            if (aa >= (1 << 16)) {
                aa >>= 16;
                xn <<= 8;
            }
            if (aa >= (1 << 8)) {
                aa >>= 8;
                xn <<= 4;
            }
            if (aa >= (1 << 4)) {
                aa >>= 4;
                xn <<= 2;
            }
            if (aa >= (1 << 2)) {
                xn <<= 1;
            }

            // We now have x_n such that `x_n = 2**(e-1) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 2**(e-1).
            //
            // We can refine our estimation by noticing that the middle of that interval minimizes the error.
            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to ε_n ≤ 2**(e-2).
            // This is going to be our x_0 (and ε_0)
            xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 2**(e-2)

            // From here, Newton's method give us:
            // x_{n+1} = (x_n + a / x_n) / 2
            //
            // One should note that:
            // x_{n+1}² - a = ((x_n + a / x_n) / 2)² - a
            //              = ((x_n² + a) / (2 * x_n))² - a
            //              = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a
            //              = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²)
            //              = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²)
            //              = (x_n² - a)² / (2 * x_n)²
            //              = ((x_n² - a) / (2 * x_n))²
            //              ≥ 0
            // Which proves that for all n ≥ 1, sqrt(a) ≤ x_n
            //
            // This gives us the proof of quadratic convergence of the sequence:
            // ε_{n+1} = | x_{n+1} - sqrt(a) |
            //         = | (x_n + a / x_n) / 2 - sqrt(a) |
            //         = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) |
            //         = | (x_n - sqrt(a))² / (2 * x_n) |
            //         = | ε_n² / (2 * x_n) |
            //         = ε_n² / | (2 * x_n) |
            //
            // For the first iteration, we have a special case where x_0 is known:
            // ε_1 = ε_0² / | (2 * x_0) |
            //     ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2)))
            //     ≤ 2**(2*e-4) / (3 * 2**(e-1))
            //     ≤ 2**(e-3) / 3
            //     ≤ 2**(e-3-log2(3))
            //     ≤ 2**(e-4.5)
            //
            // For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n:
            // ε_{n+1} = ε_n² / | (2 * x_n) |
            //         ≤ (2**(e-k))² / (2 * 2**(e-1))
            //         ≤ 2**(2*e-2*k) / 2**e
            //         ≤ 2**(e-2*k)
            xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5)  -- special case, see above
            xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9)    -- general case with k = 4.5
            xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18)   -- general case with k = 9
            xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36)   -- general case with k = 18
            xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72)   -- general case with k = 36
            xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144)  -- general case with k = 72

            // Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision
            // ε_6 ≤ 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either
            // sqrt(a) or sqrt(a) + 1.
            return xn - SafeCast.toUint(xn > a / xn);
        }
    }

    /**
     * @dev 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 + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);
        }
    }

    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log2(uint256 x) internal pure returns (uint256 r) {
        // If value has upper 128 bits set, log2 result is at least 128
        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;
        // If upper 64 bits of 128-bit half set, add 64 to result
        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;
        // If upper 32 bits of 64-bit half set, add 32 to result
        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;
        // If upper 16 bits of 32-bit half set, add 16 to result
        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;
        // If upper 8 bits of 16-bit half set, add 8 to result
        r |= SafeCast.toUint((x >> r) > 0xff) << 3;
        // If upper 4 bits of 8-bit half set, add 4 to result
        r |= SafeCast.toUint((x >> r) > 0xf) << 2;

        // Shifts value right by the current result and use it as an index into this lookup table:
        //
        // | x (4 bits) |  index  | table[index] = MSB position |
        // |------------|---------|-----------------------------|
        // |    0000    |    0    |        table[0] = 0         |
        // |    0001    |    1    |        table[1] = 0         |
        // |    0010    |    2    |        table[2] = 1         |
        // |    0011    |    3    |        table[3] = 1         |
        // |    0100    |    4    |        table[4] = 2         |
        // |    0101    |    5    |        table[5] = 2         |
        // |    0110    |    6    |        table[6] = 2         |
        // |    0111    |    7    |        table[7] = 2         |
        // |    1000    |    8    |        table[8] = 3         |
        // |    1001    |    9    |        table[9] = 3         |
        // |    1010    |   10    |        table[10] = 3        |
        // |    1011    |   11    |        table[11] = 3        |
        // |    1100    |   12    |        table[12] = 3        |
        // |    1101    |   13    |        table[13] = 3        |
        // |    1110    |   14    |        table[14] = 3        |
        // |    1111    |   15    |        table[15] = 3        |
        //
        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes.
        assembly ("memory-safe") {
            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))
        }
    }

    /**
     * @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 + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);
        }
    }

    /**
     * @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 + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);
        }
    }

    /**
     * @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 x) internal pure returns (uint256 r) {
        // If value has upper 128 bits set, log2 result is at least 128
        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;
        // If upper 64 bits of 128-bit half set, add 64 to result
        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;
        // If upper 32 bits of 64-bit half set, add 32 to result
        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;
        // If upper 16 bits of 32-bit half set, add 16 to result
        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;
        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8
        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);
    }

    /**
     * @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 + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);
        }
    }

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


66.0% lib/v2-core/lib/openzeppelin-contracts/contracts/utils/math/SafeCast.sol

Lines covered: 2 / 3 (66.0%)

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

pragma solidity ^0.8.20;

/**
 * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow
 * checks.
 *
 * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
 * easily result in undesired exploitation or bugs, since developers usually
 * assume that overflows raise errors. `SafeCast` restores this intuition by
 * reverting the transaction when such an operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeCast {
    /**
     * @dev Value doesn't fit in an uint of `bits` size.
     */
    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);

    /**
     * @dev An int value doesn't fit in an uint of `bits` size.
     */
    error SafeCastOverflowedIntToUint(int256 value);

    /**
     * @dev Value doesn't fit in an int of `bits` size.
     */
    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);

    /**
     * @dev An uint value doesn't fit in an int of `bits` size.
     */
    error SafeCastOverflowedUintToInt(uint256 value);

    /**
     * @dev Returns the downcasted uint248 from uint256, reverting on
     * overflow (when the input is greater than largest uint248).
     *
     * Counterpart to Solidity's `uint248` operator.
     *
     * Requirements:
     *
     * - input must fit into 248 bits
     */
    function toUint248(uint256 value) internal pure returns (uint248) {
        if (value > type(uint248).max) {
            revert SafeCastOverflowedUintDowncast(248, value);
        }
        return uint248(value);
    }

    /**
     * @dev Returns the downcasted uint240 from uint256, reverting on
     * overflow (when the input is greater than largest uint240).
     *
     * Counterpart to Solidity's `uint240` operator.
     *
     * Requirements:
     *
     * - input must fit into 240 bits
     */
    function toUint240(uint256 value) internal pure returns (uint240) {
        if (value > type(uint240).max) {
            revert SafeCastOverflowedUintDowncast(240, value);
        }
        return uint240(value);
    }

    /**
     * @dev Returns the downcasted uint232 from uint256, reverting on
     * overflow (when the input is greater than largest uint232).
     *
     * Counterpart to Solidity's `uint232` operator.
     *
     * Requirements:
     *
     * - input must fit into 232 bits
     */
    function toUint232(uint256 value) internal pure returns (uint232) {
        if (value > type(uint232).max) {
            revert SafeCastOverflowedUintDowncast(232, value);
        }
        return uint232(value);
    }

    /**
     * @dev Returns the downcasted uint224 from uint256, reverting on
     * overflow (when the input is greater than largest uint224).
     *
     * Counterpart to Solidity's `uint224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     */
    function toUint224(uint256 value) internal pure returns (uint224) {
        if (value > type(uint224).max) {
            revert SafeCastOverflowedUintDowncast(224, value);
        }
        return uint224(value);
    }

    /**
     * @dev Returns the downcasted uint216 from uint256, reverting on
     * overflow (when the input is greater than largest uint216).
     *
     * Counterpart to Solidity's `uint216` operator.
     *
     * Requirements:
     *
     * - input must fit into 216 bits
     */
    function toUint216(uint256 value) internal pure returns (uint216) {
        if (value > type(uint216).max) {
            revert SafeCastOverflowedUintDowncast(216, value);
        }
        return uint216(value);
    }

    /**
     * @dev Returns the downcasted uint208 from uint256, reverting on
     * overflow (when the input is greater than largest uint208).
     *
     * Counterpart to Solidity's `uint208` operator.
     *
     * Requirements:
     *
     * - input must fit into 208 bits
     */
    function toUint208(uint256 value) internal pure returns (uint208) {
        if (value > type(uint208).max) {
            revert SafeCastOverflowedUintDowncast(208, value);
        }
        return uint208(value);
    }

    /**
     * @dev Returns the downcasted uint200 from uint256, reverting on
     * overflow (when the input is greater than largest uint200).
     *
     * Counterpart to Solidity's `uint200` operator.
     *
     * Requirements:
     *
     * - input must fit into 200 bits
     */
    function toUint200(uint256 value) internal pure returns (uint200) {
        if (value > type(uint200).max) {
            revert SafeCastOverflowedUintDowncast(200, value);
        }
        return uint200(value);
    }

    /**
     * @dev Returns the downcasted uint192 from uint256, reverting on
     * overflow (when the input is greater than largest uint192).
     *
     * Counterpart to Solidity's `uint192` operator.
     *
     * Requirements:
     *
     * - input must fit into 192 bits
     */
    function toUint192(uint256 value) internal pure returns (uint192) {
        if (value > type(uint192).max) {
            revert SafeCastOverflowedUintDowncast(192, value);
        }
        return uint192(value);
    }

    /**
     * @dev Returns the downcasted uint184 from uint256, reverting on
     * overflow (when the input is greater than largest uint184).
     *
     * Counterpart to Solidity's `uint184` operator.
     *
     * Requirements:
     *
     * - input must fit into 184 bits
     */
    function toUint184(uint256 value) internal pure returns (uint184) {
        if (value > type(uint184).max) {
            revert SafeCastOverflowedUintDowncast(184, value);
        }
        return uint184(value);
    }

    /**
     * @dev Returns the downcasted uint176 from uint256, reverting on
     * overflow (when the input is greater than largest uint176).
     *
     * Counterpart to Solidity's `uint176` operator.
     *
     * Requirements:
     *
     * - input must fit into 176 bits
     */
    function toUint176(uint256 value) internal pure returns (uint176) {
        if (value > type(uint176).max) {
            revert SafeCastOverflowedUintDowncast(176, value);
        }
        return uint176(value);
    }

    /**
     * @dev Returns the downcasted uint168 from uint256, reverting on
     * overflow (when the input is greater than largest uint168).
     *
     * Counterpart to Solidity's `uint168` operator.
     *
     * Requirements:
     *
     * - input must fit into 168 bits
     */
    function toUint168(uint256 value) internal pure returns (uint168) {
        if (value > type(uint168).max) {
            revert SafeCastOverflowedUintDowncast(168, value);
        }
        return uint168(value);
    }

    /**
     * @dev Returns the downcasted uint160 from uint256, reverting on
     * overflow (when the input is greater than largest uint160).
     *
     * Counterpart to Solidity's `uint160` operator.
     *
     * Requirements:
     *
     * - input must fit into 160 bits
     */
    function toUint160(uint256 value) internal pure returns (uint160) {
        if (value > type(uint160).max) {
            revert SafeCastOverflowedUintDowncast(160, value);
        }
        return uint160(value);
    }

    /**
     * @dev Returns the downcasted uint152 from uint256, reverting on
     * overflow (when the input is greater than largest uint152).
     *
     * Counterpart to Solidity's `uint152` operator.
     *
     * Requirements:
     *
     * - input must fit into 152 bits
     */
    function toUint152(uint256 value) internal pure returns (uint152) {
        if (value > type(uint152).max) {
            revert SafeCastOverflowedUintDowncast(152, value);
        }
        return uint152(value);
    }

    /**
     * @dev Returns the downcasted uint144 from uint256, reverting on
     * overflow (when the input is greater than largest uint144).
     *
     * Counterpart to Solidity's `uint144` operator.
     *
     * Requirements:
     *
     * - input must fit into 144 bits
     */
    function toUint144(uint256 value) internal pure returns (uint144) {
        if (value > type(uint144).max) {
            revert SafeCastOverflowedUintDowncast(144, value);
        }
        return uint144(value);
    }

    /**
     * @dev Returns the downcasted uint136 from uint256, reverting on
     * overflow (when the input is greater than largest uint136).
     *
     * Counterpart to Solidity's `uint136` operator.
     *
     * Requirements:
     *
     * - input must fit into 136 bits
     */
    function toUint136(uint256 value) internal pure returns (uint136) {
        if (value > type(uint136).max) {
            revert SafeCastOverflowedUintDowncast(136, value);
        }
        return uint136(value);
    }

    /**
     * @dev Returns the downcasted uint128 from uint256, reverting on
     * overflow (when the input is greater than largest uint128).
     *
     * Counterpart to Solidity's `uint128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     */
    function toUint128(uint256 value) internal pure returns (uint128) {
        if (value > type(uint128).max) {
            revert SafeCastOverflowedUintDowncast(128, value);
        }
        return uint128(value);
    }

    /**
     * @dev Returns the downcasted uint120 from uint256, reverting on
     * overflow (when the input is greater than largest uint120).
     *
     * Counterpart to Solidity's `uint120` operator.
     *
     * Requirements:
     *
     * - input must fit into 120 bits
     */
    function toUint120(uint256 value) internal pure returns (uint120) {
        if (value > type(uint120).max) {
            revert SafeCastOverflowedUintDowncast(120, value);
        }
        return uint120(value);
    }

    /**
     * @dev Returns the downcasted uint112 from uint256, reverting on
     * overflow (when the input is greater than largest uint112).
     *
     * Counterpart to Solidity's `uint112` operator.
     *
     * Requirements:
     *
     * - input must fit into 112 bits
     */
    function toUint112(uint256 value) internal pure returns (uint112) {
        if (value > type(uint112).max) {
            revert SafeCastOverflowedUintDowncast(112, value);
        }
        return uint112(value);
    }

    /**
     * @dev Returns the downcasted uint104 from uint256, reverting on
     * overflow (when the input is greater than largest uint104).
     *
     * Counterpart to Solidity's `uint104` operator.
     *
     * Requirements:
     *
     * - input must fit into 104 bits
     */
    function toUint104(uint256 value) internal pure returns (uint104) {
        if (value > type(uint104).max) {
            revert SafeCastOverflowedUintDowncast(104, value);
        }
        return uint104(value);
    }

    /**
     * @dev Returns the downcasted uint96 from uint256, reverting on
     * overflow (when the input is greater than largest uint96).
     *
     * Counterpart to Solidity's `uint96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     */
    function toUint96(uint256 value) internal pure returns (uint96) {
        if (value > type(uint96).max) {
            revert SafeCastOverflowedUintDowncast(96, value);
        }
        return uint96(value);
    }

    /**
     * @dev Returns the downcasted uint88 from uint256, reverting on
     * overflow (when the input is greater than largest uint88).
     *
     * Counterpart to Solidity's `uint88` operator.
     *
     * Requirements:
     *
     * - input must fit into 88 bits
     */
    function toUint88(uint256 value) internal pure returns (uint88) {
        if (value > type(uint88).max) {
            revert SafeCastOverflowedUintDowncast(88, value);
        }
        return uint88(value);
    }

    /**
     * @dev Returns the downcasted uint80 from uint256, reverting on
     * overflow (when the input is greater than largest uint80).
     *
     * Counterpart to Solidity's `uint80` operator.
     *
     * Requirements:
     *
     * - input must fit into 80 bits
     */
    function toUint80(uint256 value) internal pure returns (uint80) {
        if (value > type(uint80).max) {
            revert SafeCastOverflowedUintDowncast(80, value);
        }
        return uint80(value);
    }

    /**
     * @dev Returns the downcasted uint72 from uint256, reverting on
     * overflow (when the input is greater than largest uint72).
     *
     * Counterpart to Solidity's `uint72` operator.
     *
     * Requirements:
     *
     * - input must fit into 72 bits
     */
    function toUint72(uint256 value) internal pure returns (uint72) {
        if (value > type(uint72).max) {
            revert SafeCastOverflowedUintDowncast(72, value);
        }
        return uint72(value);
    }

    /**
     * @dev Returns the downcasted uint64 from uint256, reverting on
     * overflow (when the input is greater than largest uint64).
     *
     * Counterpart to Solidity's `uint64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     */
    function toUint64(uint256 value) internal pure returns (uint64) {
        if (value > type(uint64).max) {
            revert SafeCastOverflowedUintDowncast(64, value);
        }
        return uint64(value);
    }

    /**
     * @dev Returns the downcasted uint56 from uint256, reverting on
     * overflow (when the input is greater than largest uint56).
     *
     * Counterpart to Solidity's `uint56` operator.
     *
     * Requirements:
     *
     * - input must fit into 56 bits
     */
    function toUint56(uint256 value) internal pure returns (uint56) {
        if (value > type(uint56).max) {
            revert SafeCastOverflowedUintDowncast(56, value);
        }
        return uint56(value);
    }

    /**
     * @dev Returns the downcasted uint48 from uint256, reverting on
     * overflow (when the input is greater than largest uint48).
     *
     * Counterpart to Solidity's `uint48` operator.
     *
     * Requirements:
     *
     * - input must fit into 48 bits
     */
    function toUint48(uint256 value) internal pure returns (uint48) {
        if (value > type(uint48).max) {
            revert SafeCastOverflowedUintDowncast(48, value);
        }
        return uint48(value);
    }

    /**
     * @dev Returns the downcasted uint40 from uint256, reverting on
     * overflow (when the input is greater than largest uint40).
     *
     * Counterpart to Solidity's `uint40` operator.
     *
     * Requirements:
     *
     * - input must fit into 40 bits
     */
    function toUint40(uint256 value) internal pure returns (uint40) {
        if (value > type(uint40).max) {
            revert SafeCastOverflowedUintDowncast(40, value);
        }
        return uint40(value);
    }

    /**
     * @dev Returns the downcasted uint32 from uint256, reverting on
     * overflow (when the input is greater than largest uint32).
     *
     * Counterpart to Solidity's `uint32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     */
    function toUint32(uint256 value) internal pure returns (uint32) {
        if (value > type(uint32).max) {
            revert SafeCastOverflowedUintDowncast(32, value);
        }
        return uint32(value);
    }

    /**
     * @dev Returns the downcasted uint24 from uint256, reverting on
     * overflow (when the input is greater than largest uint24).
     *
     * Counterpart to Solidity's `uint24` operator.
     *
     * Requirements:
     *
     * - input must fit into 24 bits
     */
    function toUint24(uint256 value) internal pure returns (uint24) {
        if (value > type(uint24).max) {
            revert SafeCastOverflowedUintDowncast(24, value);
        }
        return uint24(value);
    }

    /**
     * @dev Returns the downcasted uint16 from uint256, reverting on
     * overflow (when the input is greater than largest uint16).
     *
     * Counterpart to Solidity's `uint16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     */
    function toUint16(uint256 value) internal pure returns (uint16) {
        if (value > type(uint16).max) {
            revert SafeCastOverflowedUintDowncast(16, value);
        }
        return uint16(value);
    }

    /**
     * @dev Returns the downcasted uint8 from uint256, reverting on
     * overflow (when the input is greater than largest uint8).
     *
     * Counterpart to Solidity's `uint8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits
     */
    function toUint8(uint256 value) internal pure returns (uint8) {
        if (value > type(uint8).max) {
            revert SafeCastOverflowedUintDowncast(8, value);
        }
        return uint8(value);
    }

    /**
     * @dev Converts a signed int256 into an unsigned uint256.
     *
     * Requirements:
     *
     * - input must be greater than or equal to 0.
     */
    function toUint256(int256 value) internal pure returns (uint256) {
        if (value < 0) {
            revert SafeCastOverflowedIntToUint(value);
        }
        return uint256(value);
    }

    /**
     * @dev Returns the downcasted int248 from int256, reverting on
     * overflow (when the input is less than smallest int248 or
     * greater than largest int248).
     *
     * Counterpart to Solidity's `int248` operator.
     *
     * Requirements:
     *
     * - input must fit into 248 bits
     */
    function toInt248(int256 value) internal pure returns (int248 downcasted) {
        downcasted = int248(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(248, value);
        }
    }

    /**
     * @dev Returns the downcasted int240 from int256, reverting on
     * overflow (when the input is less than smallest int240 or
     * greater than largest int240).
     *
     * Counterpart to Solidity's `int240` operator.
     *
     * Requirements:
     *
     * - input must fit into 240 bits
     */
    function toInt240(int256 value) internal pure returns (int240 downcasted) {
        downcasted = int240(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(240, value);
        }
    }

    /**
     * @dev Returns the downcasted int232 from int256, reverting on
     * overflow (when the input is less than smallest int232 or
     * greater than largest int232).
     *
     * Counterpart to Solidity's `int232` operator.
     *
     * Requirements:
     *
     * - input must fit into 232 bits
     */
    function toInt232(int256 value) internal pure returns (int232 downcasted) {
        downcasted = int232(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(232, value);
        }
    }

    /**
     * @dev Returns the downcasted int224 from int256, reverting on
     * overflow (when the input is less than smallest int224 or
     * greater than largest int224).
     *
     * Counterpart to Solidity's `int224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     */
    function toInt224(int256 value) internal pure returns (int224 downcasted) {
        downcasted = int224(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(224, value);
        }
    }

    /**
     * @dev Returns the downcasted int216 from int256, reverting on
     * overflow (when the input is less than smallest int216 or
     * greater than largest int216).
     *
     * Counterpart to Solidity's `int216` operator.
     *
     * Requirements:
     *
     * - input must fit into 216 bits
     */
    function toInt216(int256 value) internal pure returns (int216 downcasted) {
        downcasted = int216(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(216, value);
        }
    }

    /**
     * @dev Returns the downcasted int208 from int256, reverting on
     * overflow (when the input is less than smallest int208 or
     * greater than largest int208).
     *
     * Counterpart to Solidity's `int208` operator.
     *
     * Requirements:
     *
     * - input must fit into 208 bits
     */
    function toInt208(int256 value) internal pure returns (int208 downcasted) {
        downcasted = int208(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(208, value);
        }
    }

    /**
     * @dev Returns the downcasted int200 from int256, reverting on
     * overflow (when the input is less than smallest int200 or
     * greater than largest int200).
     *
     * Counterpart to Solidity's `int200` operator.
     *
     * Requirements:
     *
     * - input must fit into 200 bits
     */
    function toInt200(int256 value) internal pure returns (int200 downcasted) {
        downcasted = int200(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(200, value);
        }
    }

    /**
     * @dev Returns the downcasted int192 from int256, reverting on
     * overflow (when the input is less than smallest int192 or
     * greater than largest int192).
     *
     * Counterpart to Solidity's `int192` operator.
     *
     * Requirements:
     *
     * - input must fit into 192 bits
     */
    function toInt192(int256 value) internal pure returns (int192 downcasted) {
        downcasted = int192(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(192, value);
        }
    }

    /**
     * @dev Returns the downcasted int184 from int256, reverting on
     * overflow (when the input is less than smallest int184 or
     * greater than largest int184).
     *
     * Counterpart to Solidity's `int184` operator.
     *
     * Requirements:
     *
     * - input must fit into 184 bits
     */
    function toInt184(int256 value) internal pure returns (int184 downcasted) {
        downcasted = int184(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(184, value);
        }
    }

    /**
     * @dev Returns the downcasted int176 from int256, reverting on
     * overflow (when the input is less than smallest int176 or
     * greater than largest int176).
     *
     * Counterpart to Solidity's `int176` operator.
     *
     * Requirements:
     *
     * - input must fit into 176 bits
     */
    function toInt176(int256 value) internal pure returns (int176 downcasted) {
        downcasted = int176(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(176, value);
        }
    }

    /**
     * @dev Returns the downcasted int168 from int256, reverting on
     * overflow (when the input is less than smallest int168 or
     * greater than largest int168).
     *
     * Counterpart to Solidity's `int168` operator.
     *
     * Requirements:
     *
     * - input must fit into 168 bits
     */
    function toInt168(int256 value) internal pure returns (int168 downcasted) {
        downcasted = int168(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(168, value);
        }
    }

    /**
     * @dev Returns the downcasted int160 from int256, reverting on
     * overflow (when the input is less than smallest int160 or
     * greater than largest int160).
     *
     * Counterpart to Solidity's `int160` operator.
     *
     * Requirements:
     *
     * - input must fit into 160 bits
     */
    function toInt160(int256 value) internal pure returns (int160 downcasted) {
        downcasted = int160(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(160, value);
        }
    }

    /**
     * @dev Returns the downcasted int152 from int256, reverting on
     * overflow (when the input is less than smallest int152 or
     * greater than largest int152).
     *
     * Counterpart to Solidity's `int152` operator.
     *
     * Requirements:
     *
     * - input must fit into 152 bits
     */
    function toInt152(int256 value) internal pure returns (int152 downcasted) {
        downcasted = int152(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(152, value);
        }
    }

    /**
     * @dev Returns the downcasted int144 from int256, reverting on
     * overflow (when the input is less than smallest int144 or
     * greater than largest int144).
     *
     * Counterpart to Solidity's `int144` operator.
     *
     * Requirements:
     *
     * - input must fit into 144 bits
     */
    function toInt144(int256 value) internal pure returns (int144 downcasted) {
        downcasted = int144(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(144, value);
        }
    }

    /**
     * @dev Returns the downcasted int136 from int256, reverting on
     * overflow (when the input is less than smallest int136 or
     * greater than largest int136).
     *
     * Counterpart to Solidity's `int136` operator.
     *
     * Requirements:
     *
     * - input must fit into 136 bits
     */
    function toInt136(int256 value) internal pure returns (int136 downcasted) {
        downcasted = int136(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(136, value);
        }
    }

    /**
     * @dev Returns the downcasted int128 from int256, reverting on
     * overflow (when the input is less than smallest int128 or
     * greater than largest int128).
     *
     * Counterpart to Solidity's `int128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     */
    function toInt128(int256 value) internal pure returns (int128 downcasted) {
        downcasted = int128(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(128, value);
        }
    }

    /**
     * @dev Returns the downcasted int120 from int256, reverting on
     * overflow (when the input is less than smallest int120 or
     * greater than largest int120).
     *
     * Counterpart to Solidity's `int120` operator.
     *
     * Requirements:
     *
     * - input must fit into 120 bits
     */
    function toInt120(int256 value) internal pure returns (int120 downcasted) {
        downcasted = int120(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(120, value);
        }
    }

    /**
     * @dev Returns the downcasted int112 from int256, reverting on
     * overflow (when the input is less than smallest int112 or
     * greater than largest int112).
     *
     * Counterpart to Solidity's `int112` operator.
     *
     * Requirements:
     *
     * - input must fit into 112 bits
     */
    function toInt112(int256 value) internal pure returns (int112 downcasted) {
        downcasted = int112(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(112, value);
        }
    }

    /**
     * @dev Returns the downcasted int104 from int256, reverting on
     * overflow (when the input is less than smallest int104 or
     * greater than largest int104).
     *
     * Counterpart to Solidity's `int104` operator.
     *
     * Requirements:
     *
     * - input must fit into 104 bits
     */
    function toInt104(int256 value) internal pure returns (int104 downcasted) {
        downcasted = int104(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(104, value);
        }
    }

    /**
     * @dev Returns the downcasted int96 from int256, reverting on
     * overflow (when the input is less than smallest int96 or
     * greater than largest int96).
     *
     * Counterpart to Solidity's `int96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     */
    function toInt96(int256 value) internal pure returns (int96 downcasted) {
        downcasted = int96(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(96, value);
        }
    }

    /**
     * @dev Returns the downcasted int88 from int256, reverting on
     * overflow (when the input is less than smallest int88 or
     * greater than largest int88).
     *
     * Counterpart to Solidity's `int88` operator.
     *
     * Requirements:
     *
     * - input must fit into 88 bits
     */
    function toInt88(int256 value) internal pure returns (int88 downcasted) {
        downcasted = int88(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(88, value);
        }
    }

    /**
     * @dev Returns the downcasted int80 from int256, reverting on
     * overflow (when the input is less than smallest int80 or
     * greater than largest int80).
     *
     * Counterpart to Solidity's `int80` operator.
     *
     * Requirements:
     *
     * - input must fit into 80 bits
     */
    function toInt80(int256 value) internal pure returns (int80 downcasted) {
        downcasted = int80(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(80, value);
        }
    }

    /**
     * @dev Returns the downcasted int72 from int256, reverting on
     * overflow (when the input is less than smallest int72 or
     * greater than largest int72).
     *
     * Counterpart to Solidity's `int72` operator.
     *
     * Requirements:
     *
     * - input must fit into 72 bits
     */
    function toInt72(int256 value) internal pure returns (int72 downcasted) {
        downcasted = int72(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(72, value);
        }
    }

    /**
     * @dev Returns the downcasted int64 from int256, reverting on
     * overflow (when the input is less than smallest int64 or
     * greater than largest int64).
     *
     * Counterpart to Solidity's `int64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     */
    function toInt64(int256 value) internal pure returns (int64 downcasted) {
        downcasted = int64(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(64, value);
        }
    }

    /**
     * @dev Returns the downcasted int56 from int256, reverting on
     * overflow (when the input is less than smallest int56 or
     * greater than largest int56).
     *
     * Counterpart to Solidity's `int56` operator.
     *
     * Requirements:
     *
     * - input must fit into 56 bits
     */
    function toInt56(int256 value) internal pure returns (int56 downcasted) {
        downcasted = int56(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(56, value);
        }
    }

    /**
     * @dev Returns the downcasted int48 from int256, reverting on
     * overflow (when the input is less than smallest int48 or
     * greater than largest int48).
     *
     * Counterpart to Solidity's `int48` operator.
     *
     * Requirements:
     *
     * - input must fit into 48 bits
     */
    function toInt48(int256 value) internal pure returns (int48 downcasted) {
        downcasted = int48(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(48, value);
        }
    }

    /**
     * @dev Returns the downcasted int40 from int256, reverting on
     * overflow (when the input is less than smallest int40 or
     * greater than largest int40).
     *
     * Counterpart to Solidity's `int40` operator.
     *
     * Requirements:
     *
     * - input must fit into 40 bits
     */
    function toInt40(int256 value) internal pure returns (int40 downcasted) {
        downcasted = int40(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(40, value);
        }
    }

    /**
     * @dev Returns the downcasted int32 from int256, reverting on
     * overflow (when the input is less than smallest int32 or
     * greater than largest int32).
     *
     * Counterpart to Solidity's `int32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     */
    function toInt32(int256 value) internal pure returns (int32 downcasted) {
        downcasted = int32(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(32, value);
        }
    }

    /**
     * @dev Returns the downcasted int24 from int256, reverting on
     * overflow (when the input is less than smallest int24 or
     * greater than largest int24).
     *
     * Counterpart to Solidity's `int24` operator.
     *
     * Requirements:
     *
     * - input must fit into 24 bits
     */
    function toInt24(int256 value) internal pure returns (int24 downcasted) {
        downcasted = int24(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(24, value);
        }
    }

    /**
     * @dev Returns the downcasted int16 from int256, reverting on
     * overflow (when the input is less than smallest int16 or
     * greater than largest int16).
     *
     * Counterpart to Solidity's `int16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     */
    function toInt16(int256 value) internal pure returns (int16 downcasted) {
        downcasted = int16(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(16, value);
        }
    }

    /**
     * @dev Returns the downcasted int8 from int256, reverting on
     * overflow (when the input is less than smallest int8 or
     * greater than largest int8).
     *
     * Counterpart to Solidity's `int8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits
     */
    function toInt8(int256 value) internal pure returns (int8 downcasted) {
        downcasted = int8(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(8, value);
        }
    }

    /**
     * @dev Converts an unsigned uint256 into a signed int256.
     *
     * Requirements:
     *
     * - input must be less than or equal to maxInt256.
     */
    function toInt256(uint256 value) internal pure returns (int256) {
        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
        if (value > uint256(type(int256).max)) {
            revert SafeCastOverflowedUintToInt(value);
        }
        return int256(value);
    }

    /**
     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.
     */
    function toUint(bool b) internal pure returns (uint256 u) {
        assembly ("memory-safe") {
            u := iszero(iszero(b))
        }
    }
}


0.0% lib/v2-core/lib/openzeppelin-contracts/contracts/utils/math/SignedMath.sol

Lines covered: 0 / 1 (0.0%)

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

pragma solidity ^0.8.20;

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

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.
     *
     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.
     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute
     * one branch when needed, making this function more expensive.
     */
    function ternary(bool condition, int256 a, int256 b) internal pure returns (int256) {
        unchecked {
            // branchless ternary works because:
            // b ^ (a ^ b) == a
            // b ^ 0 == b
            return b ^ ((a ^ b) * int256(SafeCast.toUint(condition)));
        }
    }

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

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

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // Formula from the "Bit Twiddling Hacks" by Sean Eron Anderson.
            // Since `n` is a signed integer, the generated bytecode will use the SAR opcode to perform the right shift,
            // taking advantage of the most significant (or "sign" bit) in two's complement representation.
            // This opcode adds new most significant bits set to the value of the previous most significant bit. As a result,
            // the mask will either be `bytes32(0)` (if n is positive) or `~bytes32(0)` (if n is negative).
            int256 mask = n >> 255;

            // A `bytes32(0)` mask leaves the input unchanged, while a `~bytes32(0)` mask complements it.
            return uint256((n + mask) ^ mask);
        }
    }
}


87.0% lib/v2-core/lib/openzeppelin-contracts/contracts/utils/structs/EnumerableSet.sol

Lines covered: 35 / 40 (87.0%)

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

pragma solidity ^0.8.20;

import {Arrays} from "../Arrays.sol";
import {Math} from "../math/Math.sol";

/**
 * @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.
 * - Set can be cleared (all elements removed) in O(n).
 *
 * ```solidity
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * The following types are supported:
 *
 * - `bytes32` (`Bytes32Set`) since v3.3.0
 * - `address` (`AddressSet`) since v3.3.0
 * - `uint256` (`UintSet`) since v3.3.0
 * - `string` (`StringSet`) since v5.4.0
 * - `bytes` (`BytesSet`) since v5.4.0
 *
 * [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 Removes all the values from a set. O(n).
     *
     * WARNING: This function has an unbounded cost that scales with set size. Developers should keep in mind that
     * using it may render the function uncallable if the set grows to the point where clearing it consumes too much
     * gas to fit in a block.
     */
    function _clear(Set storage set) private {
        uint256 len = _length(set);
        for (uint256 i = 0; i < len; ++i) {
            delete set._positions[set._values[i]];
        }
        Arrays.unsafeSetLength(set._values, 0);
    }

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

    /**
     * @dev Return a slice of the 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, uint256 start, uint256 end) private view returns (bytes32[] memory) {
        unchecked {
            end = Math.min(end, _length(set));
            start = Math.min(start, end);

            uint256 len = end - start;
            bytes32[] memory result = new bytes32[](len);
            for (uint256 i = 0; i < len; ++i) {
                result[i] = Arrays.unsafeAccess(set._values, start + i).value;
            }
            return result;
        }
    }

    // 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 Removes all the values from a set. O(n).
     *
     * WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the
     * function uncallable if the set grows to the point where clearing it consumes too much gas to fit in a block.
     */
    function clear(Bytes32Set storage set) internal {
        _clear(set._inner);
    }

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

        assembly ("memory-safe") {
            result := store
        }

        return result;
    }

    /**
     * @dev Return a slice of the 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, uint256 start, uint256 end) internal view returns (bytes32[] memory) {
        bytes32[] memory store = _values(set._inner, start, end);
        bytes32[] memory result;

        assembly ("memory-safe") {
            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 Removes all the values from a set. O(n).
     *
     * WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the
     * function uncallable if the set grows to the point where clearing it consumes too much gas to fit in a block.
     */
    function clear(AddressSet storage set) internal {
        _clear(set._inner);
    }

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

        assembly ("memory-safe") {
            result := store
        }

        return result;
    }

    /**
     * @dev Return a slice of the 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, uint256 start, uint256 end) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner, start, end);
        address[] memory result;

        assembly ("memory-safe") {
            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 Removes all the values from a set. O(n).
     *
     * WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the
     * function uncallable if the set grows to the point where clearing it consumes too much gas to fit in a block.
     */
    function clear(UintSet storage set) internal {
        _clear(set._inner);
    }

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

        assembly ("memory-safe") {
            result := store
        }

        return result;
    }

    /**
     * @dev Return a slice of the 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, uint256 start, uint256 end) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner, start, end);
        uint256[] memory result;

        assembly ("memory-safe") {
            result := store
        }

        return result;
    }

    struct StringSet {
        // Storage of set values
        string[] _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(string 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(StringSet storage set, string memory value) internal 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(StringSet storage set, string memory value) internal 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) {
                string memory 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 Removes all the values from a set. O(n).
     *
     * WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the
     * function uncallable if the set grows to the point where clearing it consumes too much gas to fit in a block.
     */
    function clear(StringSet storage set) internal {
        uint256 len = length(set);
        for (uint256 i = 0; i < len; ++i) {
            delete set._positions[set._values[i]];
        }
        Arrays.unsafeSetLength(set._values, 0);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(StringSet storage set, string memory value) internal view returns (bool) {
        return set._positions[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(StringSet storage set) internal 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(StringSet storage set, uint256 index) internal view returns (string memory) {
        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(StringSet storage set) internal view returns (string[] memory) {
        return set._values;
    }

    /**
     * @dev Return a slice of the 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(StringSet storage set, uint256 start, uint256 end) internal view returns (string[] memory) {
        unchecked {
            end = Math.min(end, length(set));
            start = Math.min(start, end);

            uint256 len = end - start;
            string[] memory result = new string[](len);
            for (uint256 i = 0; i < len; ++i) {
                result[i] = Arrays.unsafeAccess(set._values, start + i).value;
            }
            return result;
        }
    }

    struct BytesSet {
        // Storage of set values
        bytes[] _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(bytes 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(BytesSet storage set, bytes memory value) internal 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(BytesSet storage set, bytes memory value) internal 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) {
                bytes memory 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 Removes all the values from a set. O(n).
     *
     * WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the
     * function uncallable if the set grows to the point where clearing it consumes too much gas to fit in a block.
     */
    function clear(BytesSet storage set) internal {
        uint256 len = length(set);
        for (uint256 i = 0; i < len; ++i) {
            delete set._positions[set._values[i]];
        }
        Arrays.unsafeSetLength(set._values, 0);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(BytesSet storage set, bytes memory value) internal view returns (bool) {
        return set._positions[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(BytesSet storage set) internal 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(BytesSet storage set, uint256 index) internal view returns (bytes memory) {
        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(BytesSet storage set) internal view returns (bytes[] memory) {
        return set._values;
    }

    /**
     * @dev Return a slice of the 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(BytesSet storage set, uint256 start, uint256 end) internal view returns (bytes[] memory) {
        unchecked {
            end = Math.min(end, length(set));
            start = Math.min(start, end);

            uint256 len = end - start;
            bytes[] memory result = new bytes[](len);
            for (uint256 i = 0; i < len; ++i) {
                result[i] = Arrays.unsafeAccess(set._values, start + i).value;
            }
            return result;
        }
    }
}


89.0% lib/v2-core/src/hooks/BaseHook.sol

Lines covered: 89 / 100 (89.0%)

// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.30;

// External
import { Execution } from "modulekit/accounts/erc7579/lib/ExecutionLib.sol";

// Superform
import { HookDataDecoder } from "../libraries/HookDataDecoder.sol";
import { ISuperHook, ISuperHookSetter, ISuperHookResult, ISuperHookInspector } from "../interfaces/ISuperHook.sol";

/// @title BaseHook
/// @author Superform Labs
/// @notice Base implementation for all hooks in the Superform system
/// @dev Provides core security validation and execution flow management for hooks
///      All specialized hooks should inherit from this base contract
///      Implements the ISuperHook interface defined lifecycle methods
///      Uses a transient storage pattern for stateful execution context
abstract contract BaseHook is ISuperHook, ISuperHookSetter, ISuperHookResult, ISuperHookInspector {
    using HookDataDecoder for bytes;

    /*//////////////////////////////////////////////////////////////
                                 STORAGE
    //////////////////////////////////////////////////////////////*/

    /// @notice The number of shares used by this hook's operation
    /// @dev Used for accounting and tracking consumption of position shares
    uint256 public transient usedShares;

    /// @notice The special token address (if any) associated with this hook's operation
    /// @dev May be used to track token addresses for various operations
    address public transient spToken;

    /// @notice The primary asset address this hook operates on
    /// @dev Typically the base token or asset being processed
    address public transient asset;

    /// @notice Execution nonce for creating unique contexts
    uint256 public transient executionNonce;

    /// @notice Last execution context caller
    address public transient lastCaller;

    // Storage offsets for different state variables
    uint256 private constant OUT_AMOUNT_OFFSET = 1;
    uint256 private constant PRE_EXECUTE_MUTEX_OFFSET = 2;
    uint256 private constant POST_EXECUTE_MUTEX_OFFSET = 3;

    /// @notice Base storage key for hook execution state
    bytes32 private constant HOOK_EXECUTION_STORAGE = keccak256("hook.execution.state");

    /// @notice Storage key for account context mapping
    bytes32 private constant ACCOUNT_CONTEXT_STORAGE = keccak256("hook.account.context");

    /// @notice The specific subtype identifier for this hook
    /// @dev Used to identify specialized hook types beyond the basic HookType enum
    bytes32 public immutable SUB_TYPE;

    /// @notice The type of hook (NONACCOUNTING, INFLOW, OUTFLOW)
    /// @dev Determines how the hook impacts accounting in the system
    ISuperHook.HookType public hookType;

    /*//////////////////////////////////////////////////////////////
                                 ERRORS
    //////////////////////////////////////////////////////////////*/
    /// @notice Thrown when a caller attempts to execute hook methods without proper authorization
    /// @dev Used by security validation to prevent unauthorized hook execution
    error NOT_AUTHORIZED();

    /// @notice Thrown when an amount parameter is invalid (e.g., zero or overflow)
    /// @dev Used in validation checks for asset amounts and share values
    error AMOUNT_NOT_VALID();

    /// @notice Thrown when an address parameter is invalid (e.g., zero address)
    /// @dev Used in validation checks for tokens, accounts, and other addresses
    error ADDRESS_NOT_VALID();

    /// @notice Thrown when a caller is not authorized to execute hook methods
    /// @dev Used by security validation to prevent unauthorized hook execution
    error UNAUTHORIZED_CALLER();

    /// @notice Thrown when preExecute is called more than once
    /// @dev Used to prevent reentrancy attacks and ensure proper execution flow
    error PRE_EXECUTE_ALREADY_CALLED();

    /// @notice Thrown when postExecute is called more than once
    /// @dev Used to prevent reentrancy attacks and ensure proper execution flow
    error POST_EXECUTE_ALREADY_CALLED();

    /// @notice Thrown when a hook execution is incomplete
    /// @dev Used to prevent incomplete hook execution
    error INCOMPLETE_HOOK_EXECUTION();

    /// @notice Thrown when trying to set outAmount after preExecute or postExecute
    /// @dev Used to prevent setting outAmount after preExecute or postExecute
    error CANNOT_SET_OUT_AMOUNT();

    /// @notice Initializes the hook with its type and subtype
    /// @dev Sets immutable parameters that define the hook's behavior
    /// @param hookType_ The type classification for this hook (NONACCOUNTING, INFLOW, OUTFLOW)
    /// @param subType_ The specific subtype identifier for specialized hook functionality
    constructor(ISuperHook.HookType hookType_, bytes32 subType_) {
        hookType = hookType_;
        SUB_TYPE = subType_;
    }

    modifier onlyLastCaller() {
        if (msg.sender != lastCaller) revert UNAUTHORIZED_CALLER();
        _;
    }

    /*//////////////////////////////////////////////////////////////
                          EXECUTION SECURITY
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperHook
    function setExecutionContext(address caller) external {
        _createExecutionContext(caller);
        lastCaller = msg.sender;
    }

    /// @dev Standard build pattern - MUST include preExecute first, postExecute last
    /// @inheritdoc ISuperHook
    function build(
        address prevHook,
        address account,
        bytes calldata hookData
    )
        external
        view
        virtual
        returns (Execution[] memory executions)
    {
        // Get hook-specific executions
        Execution[] memory hookExecutions = _buildHookExecutions(prevHook, account, hookData);

        // Always include pre + hook + post
        executions = new Execution[](hookExecutions.length + 2);

        // FIRST: preExecute
        executions[0] = Execution({
            target: address(this),
            value: 0,
            callData: abi.encodeCall(this.preExecute, (prevHook, account, hookData))
        });

        // MIDDLE: hook-specific operations
        for (uint256 i = 0; i < hookExecutions.length; i++) {
            executions[i + 1] = hookExecutions[i];
        }

        // LAST: postExecute
        executions[executions.length - 1] = Execution({
            target: address(this),
            value: 0,
            callData: abi.encodeCall(this.postExecute, (prevHook, account, hookData))
        });
    }

    /// @inheritdoc ISuperHook
    function preExecute(address prevHook, address account, bytes calldata data) external {
        if (msg.sender != account) revert UNAUTHORIZED_CALLER();
        uint256 context = _getCurrentExecutionContext(account);
        if (_getPreExecuteMutex(context)) revert PRE_EXECUTE_ALREADY_CALLED();
        _setPreExecuteMutex(context, true);
        _preExecute(prevHook, account, data);
    }

    /// @inheritdoc ISuperHook
    function postExecute(address prevHook, address account, bytes calldata data) external {
        if (msg.sender != account) revert UNAUTHORIZED_CALLER();
        uint256 context = _getCurrentExecutionContext(account);
        if (_getPostExecuteMutex(context)) revert POST_EXECUTE_ALREADY_CALLED();
        _setPostExecuteMutex(context, true);
        _postExecute(prevHook, account, data);
    }

    /// @inheritdoc ISuperHookSetter
    function setOutAmount(uint256 _outAmount, address caller) external {
        uint256 context = _getCurrentExecutionContext(caller);
        if (_getPreExecuteMutex(context) || _getPostExecuteMutex(context)) {
            revert CANNOT_SET_OUT_AMOUNT();
        }

        bytes32 key = _makeKey(context, OUT_AMOUNT_OFFSET);
        assembly {
            tstore(key, _outAmount)
        }
    }

    function getOutAmount(address caller) public view returns (uint256) {
        return _getOutAmount(_getCurrentExecutionContext(caller));
    }

    /// @inheritdoc ISuperHook
    function resetExecutionState(address caller) external onlyLastCaller {
        uint256 context = _getCurrentExecutionContext(caller);
        if (!_getPreExecuteMutex(context) || !_getPostExecuteMutex(context)) {
            revert INCOMPLETE_HOOK_EXECUTION();
        }

        _clearExecutionState(context);
    }

    /*//////////////////////////////////////////////////////////////
                                 VIEW METHODS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperHook
    function subtype() external view returns (bytes32) {
        return SUB_TYPE;
    }

    /// @inheritdoc ISuperHookInspector
    function inspect(bytes calldata) external view virtual returns (bytes memory) { }

    /*//////////////////////////////////////////////////////////////
                                 INTERNAL METHODS
    //////////////////////////////////////////////////////////////*/
    /// @notice Internal implementation of build
    /// @dev Abstract function to be implemented by derived hooks
    ///      Called during build to generate hook-specific execution sequences
    /// @param prevHook The previous hook in the chain, or address(0) if first hook
    /// @param account The account that operations will be performed for
    /// @param data Hook-specific parameters and configuration data
    /// @return executions Array of execution objects containing target, value, and callData
    function _buildHookExecutions(
        address prevHook,
        address account,
        bytes calldata data
    )
        internal
        view
        virtual
        returns (Execution[] memory executions);

    /// @notice Internal implementation of preExecute
    /// @dev Abstract function to be implemented by derived hooks
    ///      Called before execution to validate inputs and prepare the hook's state
    ///      Typically sets up the hook context by parsing parameters from data
    ///      May check balances, permissions, or other preconditions
    /// @param prevHook The previous hook in the chain, or address(0) if first hook
    /// @param account The account that operations will be performed for
    /// @param data Hook-specific parameters and configuration data
    function _preExecute(address prevHook, address account, bytes calldata data) internal virtual { }

    /// @notice Internal implementation of postExecute
    /// @dev Abstract function to be implemented by derived hooks
    ///      Called after execution to finalize the hook's state and set output values
    ///      Typically calculates final results and sets outAmount, usedShares, etc.
    ///      May perform additional validations on execution results
    /// @param prevHook The previous hook in the chain, or address(0) if first hook
    /// @param account The account operations were performed for
    /// @param data Hook-specific parameters and configuration data
    function _postExecute(address prevHook, address account, bytes calldata data) internal virtual { }

    /// @notice Decodes a boolean value from a byte array at the specified offset
    /// @dev Helper function for extracting boolean values from packed data
    ///      Used when parsing hook-specific data parameters
    /// @param data The byte array containing the encoded data
    /// @param offset The position in the array to read from
    /// @return The decoded boolean value (true if byte is non-zero)
    function _decodeBool(bytes memory data, uint256 offset) internal pure returns (bool) {
        return data[offset] != 0;
    }

    /// @notice Replaces an amount value within a byte array at the specified offset
    /// @dev Used to modify hook calldata for amount adjustments without full re-encoding
    ///      Particularly useful for modifying amounts in multi-hook execution chains
    ///      Directly modifies the bytes in-place for gas efficiency
    /// @param data The original byte array containing encoded calldata
    /// @param amount The new amount value to insert
    /// @param offset The position in the array where the amount starts
    /// @return The modified byte array with the replaced amount
    function _replaceCalldataAmount(
        bytes memory data,
        uint256 amount,
        uint256 offset
    )
        internal
        pure
        returns (bytes memory)
    {
        bytes memory newAmountEncoded = abi.encodePacked(amount);
        for (uint256 i; i < 32; ++i) {
            data[offset + i] = newAmountEncoded[i];
        }
        return data;
    }

    function _makeAccountContextKey(address account) private pure returns (bytes32) {
        return keccak256(abi.encodePacked(ACCOUNT_CONTEXT_STORAGE, account));
    }

    function _createExecutionContext(address caller) private returns (uint256) {
        // Always increment nonce for new execution context
        executionNonce++;
        bytes32 key = _makeAccountContextKey(caller);

        // Store this context for the current caller
        uint256 currentNonce = executionNonce; // Load into local variable for assembly
        assembly {
            tstore(key, currentNonce)
        }

        return executionNonce;
    }

    function _getCurrentExecutionContext(address caller) private view returns (uint256 context) {
        bytes32 key = _makeAccountContextKey(caller);
        assembly {
            context := tload(key)
        }
    }

    function _makeKey(uint256 context, uint256 offset) private pure returns (bytes32) {
        return keccak256(abi.encodePacked(HOOK_EXECUTION_STORAGE, context, offset));
    }

    function _getOutAmount(uint256 context) private view returns (uint256 value) {
        bytes32 key = _makeKey(context, OUT_AMOUNT_OFFSET);
        assembly {
            value := tload(key)
        }
    }

    function _setOutAmount(uint256 value, address caller) internal {
        uint256 context = _getCurrentExecutionContext(caller);
        bytes32 key = _makeKey(context, OUT_AMOUNT_OFFSET);
        assembly {
            tstore(key, value)
        }
    }

    function _getPreExecuteMutex(uint256 context) private view returns (bool value) {
        bytes32 key = _makeKey(context, PRE_EXECUTE_MUTEX_OFFSET);
        assembly {
            value := tload(key)
        }
    }

    function _setPreExecuteMutex(uint256 context, bool value) private {
        bytes32 key = _makeKey(context, PRE_EXECUTE_MUTEX_OFFSET);
        assembly {
            tstore(key, value)
        }
    }

    function _getPostExecuteMutex(uint256 context) private view returns (bool value) {
        bytes32 key = _makeKey(context, POST_EXECUTE_MUTEX_OFFSET);
        assembly {
            value := tload(key)
        }
    }

    function _setPostExecuteMutex(uint256 context, bool value) private {
        bytes32 key = _makeKey(context, POST_EXECUTE_MUTEX_OFFSET);
        assembly {
            tstore(key, value)
        }
    }

    function _clearExecutionState(uint256 context) private {
        _setPreExecuteMutex(context, false);
        _setPostExecuteMutex(context, false);
    }
}


0.0% lib/v2-core/src/hooks/VaultBankLockableHook.sol

Lines covered: 0 / 2 (0.0%)

// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.30;

import { HookDataDecoder } from "../libraries/HookDataDecoder.sol";

/// @title VaultBankLockableHook
/// @author Superform Labs
/// @notice Base implementation for all vault bank lockable hooks in the Superform system
abstract contract VaultBankLockableHook {
    using HookDataDecoder for bytes;

    /// @notice The vault bank address (if applicable) for cross-chain operations
    /// @dev Used primarily in bridge hooks to track source/destination vault banks
    address public transient vaultBank;

    /// @notice The destination chain ID for cross-chain operations
    /// @dev Used primarily in bridge hooks to track target chain
    uint256 public transient dstChainId;
}


95.0% lib/v2-core/src/hooks/vaults/4626/ApproveAndDeposit4626VaultHook.sol

Lines covered: 39 / 41 (95.0%)

// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.30;

// external
import { BytesLib } from "../../../vendor/BytesLib.sol";
import { Execution } from "modulekit/accounts/erc7579/lib/ExecutionLib.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { IERC4626 } from "@openzeppelin/contracts/interfaces/IERC4626.sol";

// Superform
import { BaseHook } from "../../BaseHook.sol";
import { VaultBankLockableHook } from "../../VaultBankLockableHook.sol";
import { HookSubTypes } from "../../../libraries/HookSubTypes.sol";
import { HookDataDecoder } from "../../../libraries/HookDataDecoder.sol";
import {
    ISuperHookResult,
    ISuperHookInflowOutflow,
    ISuperHookContextAware,
    ISuperHookInspector
} from "../../../interfaces/ISuperHook.sol";

/// @title ApproveAndDeposit4626VaultHook
/// @author Superform Labs
/// @notice This hook does not support tokens reverting on 0 approval
/// @dev data has the following structure
/// @notice         bytes32 yieldSourceOracleId = bytes32(BytesLib.slice(data, 0, 32), 0);
/// @notice         address yieldSource = BytesLib.toAddress(data, 32);
/// @notice         address token = BytesLib.toAddress(data, 52);
/// @notice         uint256 amount = BytesLib.toUint256(data, 72);
/// @notice         bool usePrevHookAmount = _decodeBool(data, 104);
contract ApproveAndDeposit4626VaultHook is
    BaseHook,
    VaultBankLockableHook,
    ISuperHookInflowOutflow,
    ISuperHookContextAware
{
    using HookDataDecoder for bytes;

    uint256 private constant AMOUNT_POSITION = 72;
    uint256 private constant USE_PREV_HOOK_AMOUNT_POSITION = 104;

    constructor() BaseHook(HookType.INFLOW, HookSubTypes.ERC4626) { }

    /*//////////////////////////////////////////////////////////////
                                 VIEW METHODS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc BaseHook
    function _buildHookExecutions(
        address prevHook,
        address account,
        bytes calldata data
    )
        internal
        view
        override
        returns (Execution[] memory executions)
    {
        address yieldSource = data.extractYieldSource();
        address token = BytesLib.toAddress(data, 52);
        uint256 amount = _decodeAmount(data);
        bool usePrevHookAmount = _decodeBool(data, USE_PREV_HOOK_AMOUNT_POSITION);

        if (usePrevHookAmount) {
            amount = ISuperHookResult(prevHook).getOutAmount(account);
        }

        if (amount == 0) revert AMOUNT_NOT_VALID();
        if (yieldSource == address(0) || token == address(0)) revert ADDRESS_NOT_VALID();

        executions = new Execution[](4);
        executions[0] =
            Execution({ target: token, value: 0, callData: abi.encodeCall(IERC20.approve, (yieldSource, 0)) });
        executions[1] =
            Execution({ target: token, value: 0, callData: abi.encodeCall(IERC20.approve, (yieldSource, amount)) });
        executions[2] =
            Execution({ target: yieldSource, value: 0, callData: abi.encodeCall(IERC4626.deposit, (amount, account)) });
        executions[3] =
            Execution({ target: token, value: 0, callData: abi.encodeCall(IERC20.approve, (yieldSource, 0)) });
    }

    /*//////////////////////////////////////////////////////////////
                                 EXTERNAL METHODS
    //////////////////////////////////////////////////////////////*/

    /// @inheritdoc ISuperHookInflowOutflow
    function decodeAmount(bytes memory data) external pure returns (uint256) {
        return _decodeAmount(data);
    }

    /// @inheritdoc ISuperHookContextAware
    function decodeUsePrevHookAmount(bytes memory data) external pure returns (bool) {
        return _decodeBool(data, USE_PREV_HOOK_AMOUNT_POSITION);
    }

    /// @inheritdoc ISuperHookInspector
    function inspect(bytes calldata data) external pure override returns (bytes memory) {
        return abi.encodePacked(
            data.extractYieldSource(),
            BytesLib.toAddress(data, 52) //token
        );
    }

    /*//////////////////////////////////////////////////////////////
                                 INTERNAL METHODS
    //////////////////////////////////////////////////////////////*/
    function _preExecute(address, address account, bytes calldata data) internal override {
        // store current balance
        _setOutAmount(_getBalance(account, data), account);
        spToken = data.extractYieldSource();
    }

    function _postExecute(address, address account, bytes calldata data) internal override {
        _setOutAmount(_getBalance(account, data) - getOutAmount(account), account);
    }

    /*//////////////////////////////////////////////////////////////
                                 PRIVATE METHODS
    //////////////////////////////////////////////////////////////*/
    function _decodeAmount(bytes memory data) private pure returns (uint256) {
        return BytesLib.toUint256(data, AMOUNT_POSITION);
    }

    function _getBalance(address account, bytes memory data) private view returns (uint256) {
        return IERC4626(data.extractYieldSource()).balanceOf(account);
    }
}


62.0% lib/v2-core/src/hooks/vaults/4626/Deposit4626VaultHook.sol

Lines covered: 20 / 32 (62.0%)

// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.30;

// external
import { BytesLib } from "../../../vendor/BytesLib.sol";
import { Execution } from "modulekit/accounts/erc7579/lib/ExecutionLib.sol";
import { IERC4626 } from "@openzeppelin/contracts/interfaces/IERC4626.sol";

// Superform
import { BaseHook } from "../../BaseHook.sol";
import { HookSubTypes } from "../../../libraries/HookSubTypes.sol";
import { VaultBankLockableHook } from "../../VaultBankLockableHook.sol";
import { HookDataDecoder } from "../../../libraries/HookDataDecoder.sol";
import {
    ISuperHookResult,
    ISuperHookInflowOutflow,
    ISuperHookContextAware,
    ISuperHookInspector
} from "../../../interfaces/ISuperHook.sol";

/// @title Deposit4626VaultHook
/// @author Superform Labs
/// @dev data has the following structure
/// @notice         bytes32 yieldSourceOracleId = bytes32(BytesLib.slice(data, 0, 32), 0);
/// @notice         address yieldSource = BytesLib.toAddress(data, 32);
/// @notice         uint256 amount = BytesLib.toUint256(data, 52);
/// @notice         bool usePrevHookAmount = _decodeBool(data, 84);
contract Deposit4626VaultHook is BaseHook, VaultBankLockableHook, ISuperHookInflowOutflow, ISuperHookContextAware {
    using HookDataDecoder for bytes;

    uint256 private constant AMOUNT_POSITION = 52;
    uint256 private constant USE_PREV_HOOK_AMOUNT_POSITION = 84;

    constructor() BaseHook(HookType.INFLOW, HookSubTypes.ERC4626) { }
    /*//////////////////////////////////////////////////////////////
                                 VIEW METHODS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc BaseHook

    function _buildHookExecutions(
        address prevHook,
        address account,
        bytes calldata data
    )
        internal
        view
        override
        returns (Execution[] memory executions)
    {
        address yieldSource = data.extractYieldSource();
        uint256 amount = _decodeAmount(data);
        bool usePrevHookAmount = _decodeBool(data, USE_PREV_HOOK_AMOUNT_POSITION);

        if (usePrevHookAmount) {
            amount = ISuperHookResult(prevHook).getOutAmount(account);
        }

        if (amount == 0) revert AMOUNT_NOT_VALID();
        if (yieldSource == address(0)) revert ADDRESS_NOT_VALID();

        executions = new Execution[](1);
        executions[0] =
            Execution({ target: yieldSource, value: 0, callData: abi.encodeCall(IERC4626.deposit, (amount, account)) });
    }

    /*//////////////////////////////////////////////////////////////
                                 EXTERNAL METHODS
    //////////////////////////////////////////////////////////////*/

    /// @inheritdoc ISuperHookInflowOutflow
    function decodeAmount(bytes memory data) external pure returns (uint256) {
        return _decodeAmount(data);
    }

    /// @inheritdoc ISuperHookContextAware
    function decodeUsePrevHookAmount(bytes memory data) external pure returns (bool) {
        return _decodeBool(data, USE_PREV_HOOK_AMOUNT_POSITION);
    }

    /// @inheritdoc ISuperHookInspector
    function inspect(bytes calldata data) external pure override returns (bytes memory) {
        return abi.encodePacked(data.extractYieldSource());
    }

    /*//////////////////////////////////////////////////////////////
                                 INTERNAL METHODS
    //////////////////////////////////////////////////////////////*/
    function _preExecute(address, address account, bytes calldata data) internal override {
        // store current balance
        _setOutAmount(_getBalance(account, data), account);
        spToken = data.extractYieldSource();
    }

    function _postExecute(address, address account, bytes calldata data) internal override {
        _setOutAmount(_getBalance(account, data) - getOutAmount(account), account);
    }

    /*//////////////////////////////////////////////////////////////
                                 PRIVATE METHODS
    //////////////////////////////////////////////////////////////*/
    function _decodeAmount(bytes memory data) private pure returns (uint256) {
        return BytesLib.toUint256(data, AMOUNT_POSITION);
    }

    function _getBalance(address account, bytes memory data) private view returns (uint256) {
        return IERC4626(data.extractYieldSource()).balanceOf(account);
    }
}


97.0% lib/v2-core/src/hooks/vaults/4626/Redeem4626VaultHook.sol

Lines covered: 46 / 47 (97.0%)

// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.30;

// external
import { BytesLib } from "../../../vendor/BytesLib.sol";
import { Execution } from "modulekit/accounts/erc7579/lib/ExecutionLib.sol";
import { IERC4626 } from "@openzeppelin/contracts/interfaces/IERC4626.sol";
import { IERC20 } from "@openzeppelin/contracts/interfaces/IERC20.sol";

// Superform
import { BaseHook } from "../../BaseHook.sol";
import {
    ISuperHookResultOutflow,
    ISuperHookInflowOutflow,
    ISuperHookOutflow,
    ISuperHookContextAware,
    ISuperHookInspector
} from "../../../interfaces/ISuperHook.sol";
import { HookSubTypes } from "../../../libraries/HookSubTypes.sol";
import { HookDataDecoder } from "../../../libraries/HookDataDecoder.sol";

/// @title Redeem4626VaultHook
/// @author Superform Labs
/// @dev data has the following structure
/// @notice         bytes32 yieldSourceOracleId = bytes32(BytesLib.slice(data, 0, 32), 0);
/// @notice         address yieldSource = BytesLib.toAddress(data, 32);
/// @notice         address owner = BytesLib.toAddress(data, 52);
/// @notice         uint256 shares = BytesLib.toUint256(data, 72);
/// @notice         bool usePrevHookAmount = _decodeBool(data, 104);
contract Redeem4626VaultHook is BaseHook, ISuperHookInflowOutflow, ISuperHookOutflow, ISuperHookContextAware {
    using HookDataDecoder for bytes;

    uint256 private constant AMOUNT_POSITION = 72;
    uint256 private constant USE_PREV_HOOK_AMOUNT_POSITION = 104;

    constructor() BaseHook(HookType.OUTFLOW, HookSubTypes.ERC4626) { }

    /*//////////////////////////////////////////////////////////////
                                 VIEW METHODS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc BaseHook
    function _buildHookExecutions(
        address prevHook,
        address account,
        bytes calldata data
    )
        internal
        view
        override
        returns (Execution[] memory executions)
    {
        address yieldSource = data.extractYieldSource();
        address owner = BytesLib.toAddress(data, 52);
        uint256 shares = _decodeAmount(data);
        bool usePrevHookAmount = _decodeBool(data, USE_PREV_HOOK_AMOUNT_POSITION);

        if (usePrevHookAmount) {
            shares = ISuperHookResultOutflow(prevHook).getOutAmount(account);
        }

        if (shares == 0) revert AMOUNT_NOT_VALID();
        if (yieldSource == address(0)) revert ADDRESS_NOT_VALID();

        executions = new Execution[](1);
        executions[0] = Execution({
            target: yieldSource,
            value: 0,
            callData: abi.encodeCall(IERC4626.redeem, (shares, account, owner))
        });
    }

    /*//////////////////////////////////////////////////////////////
                                 EXTERNAL METHODS
    //////////////////////////////////////////////////////////////*/

    /// @inheritdoc ISuperHookInflowOutflow
    function decodeAmount(bytes memory data) external pure returns (uint256) {
        return _decodeAmount(data);
    }

    /// @inheritdoc ISuperHookContextAware
    function decodeUsePrevHookAmount(bytes memory data) external pure returns (bool) {
        return _decodeBool(data, USE_PREV_HOOK_AMOUNT_POSITION);
    }

    /// @inheritdoc ISuperHookOutflow
    function replaceCalldataAmount(bytes memory data, uint256 amount) external pure returns (bytes memory) {
        return _replaceCalldataAmount(data, amount, AMOUNT_POSITION);
    }

    /// @inheritdoc ISuperHookInspector
    function inspect(bytes calldata data) external pure override returns (bytes memory) {
        return abi.encodePacked(
            data.extractYieldSource(),
            BytesLib.toAddress(data, 52) // owner
        );
    }

    /*//////////////////////////////////////////////////////////////
                                 INTERNAL METHODS
    //////////////////////////////////////////////////////////////*/
    function _preExecute(address, address account, bytes calldata data) internal override {
        address yieldSource = data.extractYieldSource();
        asset = IERC4626(yieldSource).asset();
        _setOutAmount(_getBalance(account, data), account);
        usedShares = _getSharesBalance(account, data);
        spToken = yieldSource;
    }

    function _postExecute(address, address account, bytes calldata data) internal override {
        _setOutAmount(_getBalance(account, data) - getOutAmount(account), account);
        usedShares = usedShares - _getSharesBalance(account, data);
    }

    /*//////////////////////////////////////////////////////////////
                                 PRIVATE METHODS
    //////////////////////////////////////////////////////////////*/
    function _decodeAmount(bytes memory data) private pure returns (uint256) {
        return BytesLib.toUint256(data, AMOUNT_POSITION);
    }

    function _getBalance(address account, bytes memory) private view returns (uint256) {
        return IERC20(asset).balanceOf(account);
    }

    function _getSharesBalance(address account, bytes memory data) private view returns (uint256) {
        address yieldSource = data.extractYieldSource();
        address owner = BytesLib.toAddress(data, 52);
        if (owner == address(0)) {
            owner = account;
        }
        return IERC4626(yieldSource).balanceOf(owner);
    }
}


88.0% lib/v2-core/src/hooks/vaults/5115/ApproveAndDeposit5115VaultHook.sol

Lines covered: 40 / 45 (88.0%)

// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.30;

// external
import { BytesLib } from "../../../vendor/BytesLib.sol";
import { Execution } from "modulekit/accounts/erc7579/lib/ExecutionLib.sol";
import { IERC20 } from "@openzeppelin/contracts/interfaces/IERC20.sol";
import { IStandardizedYield } from "../../../vendor/pendle/IStandardizedYield.sol";

// Superform
import { BaseHook } from "../../BaseHook.sol";
import { VaultBankLockableHook } from "../../VaultBankLockableHook.sol";
import { HookSubTypes } from "../../../libraries/HookSubTypes.sol";
import { HookDataDecoder } from "../../../libraries/HookDataDecoder.sol";
import {
    ISuperHookResult,
    ISuperHookInflowOutflow,
    ISuperHookContextAware,
    ISuperHookInspector
} from "../../../interfaces/ISuperHook.sol";

/// @title ApproveAndDeposit5115VaultHook
/// @author Superform Labs
/// @notice This hook does not support tokens reverting on 0 approval
/// @dev data has the following structure
/// @notice         bytes32 yieldSourceOracleId = bytes32(BytesLib.slice(data, 0, 32), 0);
/// @notice         address yieldSource = BytesLib.toAddress(data, 32);
/// @notice         address tokenIn = BytesLib.toAddress(data, 52);
/// @notice         uint256 amount = BytesLib.toUint256(data, 72);
/// @notice         uint256 minSharesOut = BytesLib.toUint256(data, 104);
/// @notice         bool usePrevHookAmount = _decodeBool(data, 136);
contract ApproveAndDeposit5115VaultHook is
    BaseHook,
    VaultBankLockableHook,
    ISuperHookInflowOutflow,
    ISuperHookContextAware
{
    using HookDataDecoder for bytes;

    uint256 private constant AMOUNT_POSITION = 72;
    uint256 private constant USE_PREV_HOOK_AMOUNT_POSITION = 136;

    constructor() BaseHook(HookType.INFLOW, HookSubTypes.ERC5115) { }

    /*//////////////////////////////////////////////////////////////
                                 VIEW METHODS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc BaseHook
    function _buildHookExecutions(
        address prevHook,
        address account,
        bytes calldata data
    )
        internal
        view
        override
        returns (Execution[] memory executions)
    {
        address yieldSource = data.extractYieldSource();
        address tokenIn = BytesLib.toAddress(data, 52);
        uint256 amount = BytesLib.toUint256(data, AMOUNT_POSITION);
        uint256 minSharesOut = BytesLib.toUint256(data, 104);
        bool usePrevHookAmount = _decodeBool(data, USE_PREV_HOOK_AMOUNT_POSITION);

        if (usePrevHookAmount) {
            amount = ISuperHookResult(prevHook).getOutAmount(account);
        }

        if (amount == 0) revert AMOUNT_NOT_VALID();
        if (yieldSource == address(0) || account == address(0) || tokenIn == address(0)) revert ADDRESS_NOT_VALID();

        executions = new Execution[](4);
        executions[0] =
            Execution({ target: tokenIn, value: 0, callData: abi.encodeCall(IERC20.approve, (yieldSource, 0)) });
        executions[1] =
            Execution({ target: tokenIn, value: 0, callData: abi.encodeCall(IERC20.approve, (yieldSource, amount)) });
        executions[2] = Execution({
            target: yieldSource,
            value: 0,
            callData: abi.encodeCall(IStandardizedYield.deposit, (account, tokenIn, amount, minSharesOut))
        });
        executions[3] =
            Execution({ target: tokenIn, value: 0, callData: abi.encodeCall(IERC20.approve, (yieldSource, 0)) });
    }

    /*//////////////////////////////////////////////////////////////
                                 EXTERNAL METHODS
    //////////////////////////////////////////////////////////////*/

    /// @inheritdoc ISuperHookInflowOutflow
    function decodeAmount(bytes memory data) external pure returns (uint256) {
        return _decodeAmount(data);
    }

    /// @inheritdoc ISuperHookContextAware
    function decodeUsePrevHookAmount(bytes memory data) external pure returns (bool) {
        return _decodeBool(data, USE_PREV_HOOK_AMOUNT_POSITION);
    }

    /// @inheritdoc ISuperHookInspector
    function inspect(bytes calldata data) external pure override returns (bytes memory) {
        return abi.encodePacked(
            data.extractYieldSource(),
            BytesLib.toAddress(data, 52) // tokenIn
        );
    }

    /*//////////////////////////////////////////////////////////////
                                 INTERNAL METHODS
    //////////////////////////////////////////////////////////////*/
    function _preExecute(address, address account, bytes calldata data) internal override {
        _setOutAmount(_getBalance(account, data), account);
        spToken = data.extractYieldSource();
        asset = BytesLib.toAddress(data, 52);
    }

    function _postExecute(address, address account, bytes calldata data) internal override {
        _setOutAmount(_getBalance(account, data) - getOutAmount(account), account);
    }

    /*//////////////////////////////////////////////////////////////
                                 PRIVATE METHODS
    //////////////////////////////////////////////////////////////*/
    function _decodeAmount(bytes memory data) private pure returns (uint256) {
        return BytesLib.toUint256(data, AMOUNT_POSITION);
    }

    function _getBalance(address account, bytes memory data) private view returns (uint256) {
        return IStandardizedYield(data.extractYieldSource()).balanceOf(account);
    }
}


46.0% lib/v2-core/src/hooks/vaults/5115/Deposit5115VaultHook.sol

Lines covered: 18 / 39 (46.0%)

// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.30;

// external
import { BytesLib } from "../../../vendor/BytesLib.sol";
import { Execution } from "modulekit/accounts/erc7579/lib/ExecutionLib.sol";
import { IStandardizedYield } from "../../../vendor/pendle/IStandardizedYield.sol";

// Superform
import { BaseHook } from "../../BaseHook.sol";
import { VaultBankLockableHook } from "../../VaultBankLockableHook.sol";
import { HookSubTypes } from "../../../libraries/HookSubTypes.sol";
import { HookDataDecoder } from "../../../libraries/HookDataDecoder.sol";
import {
    ISuperHookResult,
    ISuperHookInflowOutflow,
    ISuperHookContextAware,
    ISuperHookInspector
} from "../../../interfaces/ISuperHook.sol";

/// @title Deposit5115VaultHook
/// @author Superform Labs
/// @dev data has the following structure
/// @notice         bytes32 yieldSourceOracleId = bytes32(BytesLib.slice(data, 0, 32), 0);
/// @notice         address yieldSource = BytesLib.toAddress(data, 32);
/// @notice         address tokenIn = BytesLib.toAddress(data, 52);
/// @notice         uint256 amount = BytesLib.toUint256(data, 72);
/// @notice         uint256 minSharesOut = BytesLib.toUint256(data, 104);
/// @notice         bool usePrevHookAmount = _decodeBool(data, 136);
contract Deposit5115VaultHook is BaseHook, VaultBankLockableHook, ISuperHookInflowOutflow, ISuperHookContextAware {
    using HookDataDecoder for bytes;

    uint256 private constant AMOUNT_POSITION = 72;
    uint256 private constant USE_PREV_HOOK_AMOUNT_POSITION = 136;

    constructor() BaseHook(HookType.INFLOW, HookSubTypes.ERC5115) { }

    /*//////////////////////////////////////////////////////////////
                                 VIEW METHODS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc BaseHook
    function _buildHookExecutions(
        address prevHook,
        address account,
        bytes calldata data
    )
        internal
        view
        override
        returns (Execution[] memory executions)
    {
        address yieldSource = data.extractYieldSource();
        address tokenIn = BytesLib.toAddress(data, 52);
        uint256 amount = BytesLib.toUint256(data, AMOUNT_POSITION);
        uint256 minSharesOut = BytesLib.toUint256(data, 104);
        bool usePrevHookAmount = _decodeBool(data, USE_PREV_HOOK_AMOUNT_POSITION);

        if (usePrevHookAmount) {
            amount = ISuperHookResult(prevHook).getOutAmount(account);
        }

        if (amount == 0) revert AMOUNT_NOT_VALID();
        if (yieldSource == address(0) || account == address(0)) revert ADDRESS_NOT_VALID();

        executions = new Execution[](1);
        executions[0] = Execution({
            target: yieldSource,
            value: tokenIn == address(0) ? amount : 0,
            callData: abi.encodeCall(IStandardizedYield.deposit, (account, tokenIn, amount, minSharesOut))
        });
    }

    /*//////////////////////////////////////////////////////////////
                                 EXTERNAL METHODS
    //////////////////////////////////////////////////////////////*/

    /// @inheritdoc ISuperHookInflowOutflow
    function decodeAmount(bytes memory data) external pure returns (uint256) {
        return _decodeAmount(data);
    }

    /// @inheritdoc ISuperHookContextAware
    function decodeUsePrevHookAmount(bytes memory data) external pure returns (bool) {
        return _decodeBool(data, USE_PREV_HOOK_AMOUNT_POSITION);
    }

    /// @inheritdoc ISuperHookInspector
    function inspect(bytes calldata data) external pure override returns (bytes memory) {
        return abi.encodePacked(
            data.extractYieldSource(),
            BytesLib.toAddress(data, 52) // tokenIn
        );
    }

    /*//////////////////////////////////////////////////////////////
                                 INTERNAL METHODS
    //////////////////////////////////////////////////////////////*/
    function _preExecute(address, address account, bytes calldata data) internal override {
        _setOutAmount(_getBalance(account, data), account);
        spToken = data.extractYieldSource();
        asset = BytesLib.toAddress(data, 52);
    }

    function _postExecute(address, address account, bytes calldata data) internal override {
        _setOutAmount(_getBalance(account, data) - getOutAmount(account), account);
    }

    /*//////////////////////////////////////////////////////////////
                                 PRIVATE METHODS
    //////////////////////////////////////////////////////////////*/
    function _decodeAmount(bytes memory data) private pure returns (uint256) {
        return BytesLib.toUint256(data, AMOUNT_POSITION);
    }

    function _getBalance(address account, bytes memory data) private view returns (uint256) {
        return IStandardizedYield(data.extractYieldSource()).balanceOf(account);
    }
}


61.0% lib/v2-core/src/hooks/vaults/5115/Redeem5115VaultHook.sol

Lines covered: 27 / 44 (61.0%)

// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.30;

// external
import { BytesLib } from "../../../vendor/BytesLib.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { Execution } from "modulekit/accounts/erc7579/lib/ExecutionLib.sol";
import { IStandardizedYield } from "../../../vendor/pendle/IStandardizedYield.sol";

// Superform
import { BaseHook } from "../../BaseHook.sol";
import {
    ISuperHookResultOutflow,
    ISuperHookInflowOutflow,
    ISuperHookOutflow,
    ISuperHookContextAware,
    ISuperHookInspector
} from "../../../interfaces/ISuperHook.sol";
import { HookSubTypes } from "../../../libraries/HookSubTypes.sol";
import { HookDataDecoder } from "../../../libraries/HookDataDecoder.sol";

/// @title Redeem5115VaultHook
/// @author Superform Labs
/// @dev data has the following structure
/// @notice         bytes32 yieldSourceOracleId = bytes32(BytesLib.slice(data, 0, 32), 0);
/// @notice         address yieldSource = BytesLib.toAddress(data, 32);
/// @notice         address tokenOut = BytesLib.toAddress(data, 52);
/// @notice         uint256 shares = BytesLib.toUint256(data, 72);
/// @notice         uint256 minTokenOut = BytesLib.toUint256(data, 104);
/// @notice         bool usePrevHookAmount = _decodeBool(data, 136);
contract Redeem5115VaultHook is BaseHook, ISuperHookInflowOutflow, ISuperHookOutflow, ISuperHookContextAware {
    using HookDataDecoder for bytes;

    uint256 private constant AMOUNT_POSITION = 72;
    uint256 private constant USE_PREV_HOOK_AMOUNT_POSITION = 136;

    constructor() BaseHook(HookType.OUTFLOW, HookSubTypes.ERC5115) { }

    /*//////////////////////////////////////////////////////////////
                                 VIEW METHODS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc BaseHook
    function _buildHookExecutions(
        address prevHook,
        address account,
        bytes calldata data
    )
        internal
        view
        override
        returns (Execution[] memory executions)
    {
        address yieldSource = data.extractYieldSource();
        address tokenOut = BytesLib.toAddress(data, 52);
        uint256 shares = _decodeAmount(data);
        uint256 minTokenOut = BytesLib.toUint256(data, 104);
        bool usePrevHookAmount = _decodeBool(data, USE_PREV_HOOK_AMOUNT_POSITION);

        if (usePrevHookAmount) {
            shares = ISuperHookResultOutflow(prevHook).getOutAmount(account);
        }

        if (shares == 0) revert AMOUNT_NOT_VALID();
        if (yieldSource == address(0) || tokenOut == address(0)) revert ADDRESS_NOT_VALID();

        executions = new Execution[](1);
        executions[0] = Execution({
            target: yieldSource,
            value: 0,
            callData: abi.encodeCall(IStandardizedYield.redeem, (account, shares, tokenOut, minTokenOut, false))
        });
    }

    /*//////////////////////////////////////////////////////////////
                                 EXTERNAL METHODS
    //////////////////////////////////////////////////////////////*/

    /// @inheritdoc ISuperHookInflowOutflow
    function decodeAmount(bytes memory data) external pure returns (uint256) {
        return _decodeAmount(data);
    }

    /// @inheritdoc ISuperHookContextAware
    function decodeUsePrevHookAmount(bytes memory data) external pure returns (bool) {
        return _decodeBool(data, USE_PREV_HOOK_AMOUNT_POSITION);
    }

    /// @inheritdoc ISuperHookOutflow
    function replaceCalldataAmount(bytes memory data, uint256 amount) external pure returns (bytes memory) {
        return _replaceCalldataAmount(data, amount, AMOUNT_POSITION);
    }

    /// @inheritdoc ISuperHookInspector
    function inspect(bytes calldata data) external pure override returns (bytes memory) {
        return abi.encodePacked(
            data.extractYieldSource(),
            BytesLib.toAddress(data, 52) // tokenOut
        );
    }

    /*//////////////////////////////////////////////////////////////
                                 INTERNAL METHODS
    //////////////////////////////////////////////////////////////*/
    function _preExecute(address, address account, bytes calldata data) internal override {
        asset = BytesLib.toAddress(data, 52); // tokenOut from data
        _setOutAmount(_getBalance(account, data), account);
        usedShares = _getSharesBalance(account, data);
        spToken = data.extractYieldSource();
    }

    function _postExecute(address, address account, bytes calldata data) internal override {
        _setOutAmount(_getBalance(account, data) - getOutAmount(account), account);
        usedShares = usedShares - _getSharesBalance(account, data);
    }

    /*//////////////////////////////////////////////////////////////
                                 PRIVATE METHODS
    //////////////////////////////////////////////////////////////*/
    function _decodeAmount(bytes memory data) private pure returns (uint256) {
        return BytesLib.toUint256(data, AMOUNT_POSITION);
    }

    function _getBalance(address account, bytes memory) private view returns (uint256) {
        return IERC20(asset).balanceOf(account);
    }

    function _getSharesBalance(address account, bytes memory data) private view returns (uint256) {
        address yieldSource = data.extractYieldSource();
        return IStandardizedYield(yieldSource).balanceOf(account);
    }
}


52.0% lib/v2-core/src/hooks/vaults/7540/ApproveAndRequestDeposit7540VaultHook.sol

Lines covered: 22 / 42 (52.0%)

// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.30;

// external
import { BytesLib } from "../../../vendor/BytesLib.sol";
import { IERC20 } from "@openzeppelin/contracts/interfaces/IERC20.sol";
import { Execution } from "modulekit/accounts/erc7579/lib/ExecutionLib.sol";
import { IERC7540 } from "../../../vendor/vaults/7540/IERC7540.sol";

// Superform
import {
    ISuperHookResult,
    ISuperHookInflowOutflow,
    ISuperHookContextAware,
    ISuperHookInspector
} from "../../../interfaces/ISuperHook.sol";
import { BaseHook } from "../../BaseHook.sol";
import { HookSubTypes } from "../../../libraries/HookSubTypes.sol";
import { HookDataDecoder } from "../../../libraries/HookDataDecoder.sol";

/// @title ApproveAndRequestDeposit7540VaultHook
/// @author Superform Labs
/// @notice This hook does not support tokens reverting on 0 approval
/// @dev data has the following structure
/// @notice         bytes32 placeholder = bytes32(BytesLib.slice(data, 0, 32), 0);
/// @notice         address yieldSource = BytesLib.toAddress(data, 32);
/// @notice         address token = BytesLib.toAddress(data, 52);
/// @notice         uint256 amount = BytesLib.toUint256(data, 72);
/// @notice         bool usePrevHookAmount = _decodeBool(data, 104);
contract ApproveAndRequestDeposit7540VaultHook is BaseHook, ISuperHookInflowOutflow, ISuperHookContextAware {
    using HookDataDecoder for bytes;

    uint256 private constant AMOUNT_POSITION = 72;
    uint256 private constant USE_PREV_HOOK_AMOUNT_POSITION = 104;

    constructor() BaseHook(HookType.NONACCOUNTING, HookSubTypes.ERC7540) { }

    /*//////////////////////////////////////////////////////////////
                                 VIEW METHODS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc BaseHook
    function _buildHookExecutions(
        address prevHook,
        address account,
        bytes calldata data
    )
        internal
        view
        override
        returns (Execution[] memory executions)
    {
        address yieldSource = data.extractYieldSource();
        address token = BytesLib.toAddress(data, 52);
        uint256 amount = _decodeAmount(data);
        bool usePrevHookAmount = _decodeBool(data, USE_PREV_HOOK_AMOUNT_POSITION);

        if (usePrevHookAmount) {
            amount = ISuperHookResult(prevHook).getOutAmount(account);
        }

        if (amount == 0) revert AMOUNT_NOT_VALID();
        if (yieldSource == address(0) || account == address(0) || token == address(0)) revert ADDRESS_NOT_VALID();

        executions = new Execution[](4);
        executions[0] =
            Execution({ target: token, value: 0, callData: abi.encodeCall(IERC20.approve, (yieldSource, 0)) });
        executions[1] =
            Execution({ target: token, value: 0, callData: abi.encodeCall(IERC20.approve, (yieldSource, amount)) });
        executions[2] = Execution({
            target: yieldSource,
            value: 0,
            callData: abi.encodeCall(IERC7540.requestDeposit, (amount, account, account))
        });
        executions[3] =
            Execution({ target: token, value: 0, callData: abi.encodeCall(IERC20.approve, (yieldSource, 0)) });
    }

    /*//////////////////////////////////////////////////////////////
                                 EXTERNAL METHODS
    //////////////////////////////////////////////////////////////*/

    /// @inheritdoc ISuperHookInflowOutflow
    function decodeAmount(bytes memory data) external pure returns (uint256) {
        return _decodeAmount(data);
    }

    /// @inheritdoc ISuperHookContextAware
    function decodeUsePrevHookAmount(bytes memory data) external pure returns (bool) {
        return _decodeBool(data, USE_PREV_HOOK_AMOUNT_POSITION);
    }

    /// @inheritdoc ISuperHookInspector
    function inspect(bytes calldata data) external pure override returns (bytes memory) {
        return abi.encodePacked(
            data.extractYieldSource(),
            BytesLib.toAddress(data, 52) //token
        );
    }

    /*//////////////////////////////////////////////////////////////    
                                 INTERNAL METHODS
    //////////////////////////////////////////////////////////////*/
    function _preExecute(address, address account, bytes calldata data) internal override {
        _setOutAmount(_getBalance(account, data), account);
    }

    function _postExecute(address, address account, bytes calldata data) internal override {
        _setOutAmount(getOutAmount(account) - _getBalance(account, data), account);
    }

    /*//////////////////////////////////////////////////////////////
                                 PRIVATE METHODS
    //////////////////////////////////////////////////////////////*/
    function _decodeAmount(bytes memory data) private pure returns (uint256) {
        return BytesLib.toUint256(data, AMOUNT_POSITION);
    }

    function _getBalance(address account, bytes memory data) private view returns (uint256) {
        return IERC20(IERC7540(data.extractYieldSource()).asset()).balanceOf(account);
    }
}


100.0% lib/v2-core/src/hooks/vaults/7540/CancelDepositRequest7540Hook.sol

Lines covered: 13 / 13 (100.0%)

// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.30;

// external
import { Execution } from "modulekit/accounts/erc7579/lib/ExecutionLib.sol";
import { IERC7540CancelDeposit } from "../../../vendor/standards/ERC7540/IERC7540Vault.sol";

// Superform
import { BaseHook } from "../../BaseHook.sol";
import { HookSubTypes } from "../../../libraries/HookSubTypes.sol";
import { HookDataDecoder } from "../../../libraries/HookDataDecoder.sol";
import { ISuperHookInspector } from "../../../interfaces/ISuperHook.sol";

/// @title CancelDepositRequest7540Hook
/// @author Superform Labs
/// @dev data has the following structure
/// @notice         bytes32 placeholder = bytes32(BytesLib.slice(data, 0, 32), 0);
/// @notice         address yieldSource = BytesLib.toAddress(data, 32);
contract CancelDepositRequest7540Hook is BaseHook {
    using HookDataDecoder for bytes;

    constructor() BaseHook(HookType.NONACCOUNTING, HookSubTypes.CANCEL_DEPOSIT_REQUEST) { }

    /*//////////////////////////////////////////////////////////////
                                 VIEW METHODS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc BaseHook
    function _buildHookExecutions(
        address,
        address account,
        bytes calldata data
    )
        internal
        pure
        override
        returns (Execution[] memory executions)
    {
        address yieldSource = data.extractYieldSource();

        if (yieldSource == address(0)) revert ADDRESS_NOT_VALID();

        executions = new Execution[](1);
        executions[0] = Execution({
            target: yieldSource,
            value: 0,
            callData: abi.encodeCall(IERC7540CancelDeposit.cancelDepositRequest, (0, account))
        });
    }

    /// @inheritdoc ISuperHookInspector
    function inspect(bytes calldata data) external pure override returns (bytes memory) {
        return abi.encodePacked(data.extractYieldSource());
    }
}


100.0% lib/v2-core/src/hooks/vaults/7540/CancelRedeemRequest7540Hook.sol

Lines covered: 13 / 13 (100.0%)

// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.30;

// external
import { Execution } from "modulekit/accounts/erc7579/lib/ExecutionLib.sol";
import { IERC7540CancelRedeem } from "../../../vendor/standards/ERC7540/IERC7540Vault.sol";

// Superform
import { BaseHook } from "../../BaseHook.sol";
import { HookSubTypes } from "../../../libraries/HookSubTypes.sol";
import { HookDataDecoder } from "../../../libraries/HookDataDecoder.sol";
import { ISuperHookInspector } from "../../../interfaces/ISuperHook.sol";

/// @title CancelRedeemRequest7540Hook
/// @author Superform Labs
/// @dev data has the following structure
/// @notice         bytes32 placeholder = bytes32(BytesLib.slice(data, 0, 32), 0);
/// @notice         address yieldSource = BytesLib.toAddress(data, 32);
contract CancelRedeemRequest7540Hook is BaseHook {
    using HookDataDecoder for bytes;

    constructor() BaseHook(HookType.NONACCOUNTING, HookSubTypes.CANCEL_REDEEM_REQUEST) { }

    /*//////////////////////////////////////////////////////////////
                                 VIEW METHODS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc BaseHook
    function _buildHookExecutions(
        address,
        address account,
        bytes calldata data
    )
        internal
        pure
        override
        returns (Execution[] memory executions)
    {
        address yieldSource = data.extractYieldSource();

        if (yieldSource == address(0)) revert ADDRESS_NOT_VALID();

        executions = new Execution[](1);
        executions[0] = Execution({
            target: yieldSource,
            value: 0,
            callData: abi.encodeCall(IERC7540CancelRedeem.cancelRedeemRequest, (0, account))
        });
    }

    /// @inheritdoc ISuperHookInspector
    function inspect(bytes calldata data) external pure override returns (bytes memory) {
        return abi.encodePacked(data.extractYieldSource());
    }
}


93.0% lib/v2-core/src/hooks/vaults/7540/ClaimCancelDepositRequest7540Hook.sol

Lines covered: 27 / 29 (93.0%)

// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.30;

// external
import { BytesLib } from "../../../vendor/BytesLib.sol";
import { Execution } from "modulekit/accounts/erc7579/lib/ExecutionLib.sol";
import { IERC7540CancelDeposit } from "../../../vendor/standards/ERC7540/IERC7540Vault.sol";
import { IERC7540 } from "../../../vendor/vaults/7540/IERC7540.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

// Superform
import { BaseHook } from "../../BaseHook.sol";
import { HookSubTypes } from "../../../libraries/HookSubTypes.sol";
import { HookDataDecoder } from "../../../libraries/HookDataDecoder.sol";
import { ISuperHookAsyncCancelations, ISuperHookInspector } from "../../../interfaces/ISuperHook.sol";

/// @title ClaimCancelDepositRequest7540Hook
/// @author Superform Labs
/// @dev data has the following structure
/// @notice         bytes32 placeholder = bytes32(BytesLib.slice(data, 0, 32), 0);
/// @notice         address yieldSource = BytesLib.toAddress(data, 32);
/// @notice         address receiver = BytesLib.toAddress(data, 52);
contract ClaimCancelDepositRequest7540Hook is BaseHook, ISuperHookAsyncCancelations {
    using HookDataDecoder for bytes;

    constructor() BaseHook(HookType.NONACCOUNTING, HookSubTypes.CLAIM_CANCEL_DEPOSIT_REQUEST) { }

    /*//////////////////////////////////////////////////////////////
                                 VIEW METHODS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc BaseHook
    function _buildHookExecutions(
        address,
        address account,
        bytes calldata data
    )
        internal
        pure
        override
        returns (Execution[] memory executions)
    {
        address yieldSource = data.extractYieldSource();
        address receiver = BytesLib.toAddress(data, 52);

        if (yieldSource == address(0) || receiver == address(0)) revert ADDRESS_NOT_VALID();

        executions = new Execution[](1);
        executions[0] = Execution({
            target: yieldSource,
            value: 0,
            callData: abi.encodeCall(IERC7540CancelDeposit.claimCancelDepositRequest, (0, receiver, account))
        });
    }

    /*//////////////////////////////////////////////////////////////
                                 EXTERNAL METHODS
    //////////////////////////////////////////////////////////////*/

    /// @inheritdoc ISuperHookAsyncCancelations
    function isAsyncCancelHook() external pure returns (CancelationType) {
        return CancelationType.INFLOW;
    }

    /// @inheritdoc ISuperHookInspector
    function inspect(bytes calldata data) external pure override returns (bytes memory) {
        return abi.encodePacked(
            data.extractYieldSource(),
            BytesLib.toAddress(data, 52) //receiver
        );
    }

    /*//////////////////////////////////////////////////////////////
                                 INTERNAL METHODS
    //////////////////////////////////////////////////////////////*/
    function _preExecute(address, address account, bytes calldata data) internal override {
        address yieldSource = data.extractYieldSource();
        address receiver = BytesLib.toAddress(data, 52);
        asset = IERC7540(yieldSource).asset();
        // store current balance
        _setOutAmount(_getBalance(receiver, data), account);
    }

    function _postExecute(address, address account, bytes calldata data) internal override {
        address receiver = BytesLib.toAddress(data, 52);

        _setOutAmount(_getBalance(receiver, data) - getOutAmount(account), account);
    }

    /*//////////////////////////////////////////////////////////////
                                 PRIVATE METHODS
    //////////////////////////////////////////////////////////////*/

    function _getBalance(address account, bytes memory) private view returns (uint256) {
        return IERC20(asset).balanceOf(account);
    }
}


92.0% lib/v2-core/src/hooks/vaults/7540/ClaimCancelRedeemRequest7540Hook.sol

Lines covered: 25 / 27 (92.0%)

// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.30;

// external
import { BytesLib } from "../../../vendor/BytesLib.sol";
import { IERC7540 } from "../../../vendor/vaults/7540/IERC7540.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { Execution } from "modulekit/accounts/erc7579/lib/ExecutionLib.sol";
import { IERC7540CancelRedeem } from "../../../vendor/standards/ERC7540/IERC7540Vault.sol";

// Superform
import { BaseHook } from "../../BaseHook.sol";
import { VaultBankLockableHook } from "../../VaultBankLockableHook.sol";
import { HookSubTypes } from "../../../libraries/HookSubTypes.sol";
import { HookDataDecoder } from "../../../libraries/HookDataDecoder.sol";
import { ISuperHookAsyncCancelations, ISuperHookInspector } from "../../../interfaces/ISuperHook.sol";

/// @title ClaimCancelRedeemRequest7540Hook
/// @author Superform Labs
/// @dev data has the following structure
/// @notice         bytes32 placeholder = bytes32(BytesLib.slice(data, 0, 32), 0);
/// @notice         address yieldSource = BytesLib.toAddress(data, 32);
/// @notice         address receiver = BytesLib.toAddress(data, 52);
contract ClaimCancelRedeemRequest7540Hook is BaseHook, VaultBankLockableHook, ISuperHookAsyncCancelations {
    using HookDataDecoder for bytes;

    constructor() BaseHook(HookType.NONACCOUNTING, HookSubTypes.CLAIM_CANCEL_REDEEM_REQUEST) { }

    /*//////////////////////////////////////////////////////////////
                                 VIEW METHODS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc BaseHook
    function _buildHookExecutions(
        address,
        address account,
        bytes calldata data
    )
        internal
        pure
        override
        returns (Execution[] memory executions)
    {
        address yieldSource = data.extractYieldSource();
        address receiver = BytesLib.toAddress(data, 52);

        if (yieldSource == address(0) || receiver == address(0)) revert ADDRESS_NOT_VALID();

        executions = new Execution[](1);
        executions[0] = Execution({
            target: yieldSource,
            value: 0,
            callData: abi.encodeCall(IERC7540CancelRedeem.claimCancelRedeemRequest, (0, receiver, account))
        });
    }

    /*//////////////////////////////////////////////////////////////
                                 EXTERNAL METHODS
    //////////////////////////////////////////////////////////////*/

    /// @inheritdoc ISuperHookAsyncCancelations
    function isAsyncCancelHook() external pure returns (CancelationType) {
        return CancelationType.OUTFLOW;
    }

    /// @inheritdoc ISuperHookInspector
    function inspect(bytes calldata data) external pure override returns (bytes memory) {
        return abi.encodePacked(
            data.extractYieldSource(),
            BytesLib.toAddress(data, 52) //receiver
        );
    }

    /*//////////////////////////////////////////////////////////////
                                 INTERNAL METHODS
    //////////////////////////////////////////////////////////////*/
    function _preExecute(address, address account, bytes calldata data) internal override {
        _setOutAmount(_getBalance(account, data), account);
        spToken = IERC7540(data.extractYieldSource()).share();
    }

    function _postExecute(address, address account, bytes calldata data) internal override {
        address receiver = BytesLib.toAddress(data, 52);
        _setOutAmount(_getBalance(receiver, data) - getOutAmount(account), account);
    }

    /*//////////////////////////////////////////////////////////////
                                 PRIVATE METHODS
    //////////////////////////////////////////////////////////////*/

    function _getBalance(address account, bytes memory data) private view returns (uint256) {
        return IERC20(IERC7540(data.extractYieldSource()).share()).balanceOf(account);
    }
}


59.0% lib/v2-core/src/hooks/vaults/7540/Deposit7540VaultHook.sol

Lines covered: 19 / 32 (59.0%)

// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.30;

// external
import { BytesLib } from "../../../vendor/BytesLib.sol";
import { Execution } from "modulekit/accounts/erc7579/lib/ExecutionLib.sol";
import { IERC7540 } from "../../../vendor/vaults/7540/IERC7540.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

// Superform
import { BaseHook } from "../../BaseHook.sol";
import { VaultBankLockableHook } from "../../VaultBankLockableHook.sol";
import { HookSubTypes } from "../../../libraries/HookSubTypes.sol";
import { HookDataDecoder } from "../../../libraries/HookDataDecoder.sol";
import {
    ISuperHookResult,
    ISuperHookInflowOutflow,
    ISuperHookContextAware,
    ISuperHookInspector
} from "../../../interfaces/ISuperHook.sol";

/// @title Deposit7540VaultHook
/// @author Superform Labs
/// @dev data has the following structure
/// @notice         bytes32 yieldSourceOracleId = bytes32(BytesLib.slice(data, 0, 32), 0);
/// @notice         address yieldSource = BytesLib.toAddress(data, 32);
/// @notice         uint256 amount = BytesLib.toUint256(data, 52);
/// @notice         bool usePrevHookAmount = _decodeBool(data, 84);
contract Deposit7540VaultHook is BaseHook, VaultBankLockableHook, ISuperHookInflowOutflow, ISuperHookContextAware {
    using HookDataDecoder for bytes;

    uint256 private constant AMOUNT_POSITION = 52;
    uint256 private constant USE_PREV_HOOK_AMOUNT_POSITION = 84;

    constructor() BaseHook(HookType.INFLOW, HookSubTypes.ERC7540) { }

    /*//////////////////////////////////////////////////////////////
                                 VIEW METHODS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc BaseHook
    function _buildHookExecutions(
        address prevHook,
        address account,
        bytes calldata data
    )
        internal
        view
        override
        returns (Execution[] memory executions)
    {
        address yieldSource = data.extractYieldSource();
        uint256 amount = _decodeAmount(data);
        bool usePrevHookAmount = _decodeBool(data, USE_PREV_HOOK_AMOUNT_POSITION);

        if (usePrevHookAmount) {
            amount = ISuperHookResult(prevHook).getOutAmount(account);
        }

        if (amount == 0) revert AMOUNT_NOT_VALID();
        if (yieldSource == address(0) || account == address(0)) revert ADDRESS_NOT_VALID();

        executions = new Execution[](1);
        executions[0] = Execution({
            target: yieldSource,
            value: 0,
            callData: abi.encodeCall(IERC7540.deposit, (amount, account, account))
        });
    }

    /*//////////////////////////////////////////////////////////////
                                 EXTERNAL METHODS
    //////////////////////////////////////////////////////////////*/

    /// @inheritdoc ISuperHookInflowOutflow
    function decodeAmount(bytes memory data) external pure returns (uint256) {
        return _decodeAmount(data);
    }

    /// @inheritdoc ISuperHookContextAware
    function decodeUsePrevHookAmount(bytes memory data) external pure returns (bool) {
        return _decodeBool(data, USE_PREV_HOOK_AMOUNT_POSITION);
    }

    /// @inheritdoc ISuperHookInspector
    function inspect(bytes calldata data) external pure override returns (bytes memory) {
        return abi.encodePacked(data.extractYieldSource());
    }

    /*//////////////////////////////////////////////////////////////
                                 INTERNAL METHODS
    //////////////////////////////////////////////////////////////*/
    function _preExecute(address, address account, bytes calldata data) internal override {
        // store current balance
        _setOutAmount(_getBalance(account, data), account);
        spToken = IERC7540(data.extractYieldSource()).share();
    }

    function _postExecute(address, address account, bytes calldata data) internal override {
        _setOutAmount(_getBalance(account, data) - getOutAmount(account), account);
    }

    /*//////////////////////////////////////////////////////////////
                                 PRIVATE METHODS
    //////////////////////////////////////////////////////////////*/
    function _decodeAmount(bytes memory data) private pure returns (uint256) {
        return BytesLib.toUint256(data, AMOUNT_POSITION);
    }

    function _getBalance(address account, bytes memory data) private view returns (uint256) {
        return IERC20(IERC7540(data.extractYieldSource()).share()).balanceOf(account);
    }
}


100.0% lib/v2-core/src/hooks/vaults/7540/Redeem7540VaultHook.sol

Lines covered: 41 / 41 (100.0%)

// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.30;

// external
import { BytesLib } from "../../../vendor/BytesLib.sol";
import { Execution } from "modulekit/accounts/erc7579/lib/ExecutionLib.sol";
import { IERC20 } from "@openzeppelin/contracts/interfaces/IERC20.sol";
import { IERC7540 } from "../../../vendor/vaults/7540/IERC7540.sol";

// Superform
import { BaseHook } from "../../BaseHook.sol";
import {
    ISuperHookResultOutflow,
    ISuperHookInflowOutflow,
    ISuperHookOutflow,
    ISuperHookContextAware,
    ISuperHookInspector
} from "../../../interfaces/ISuperHook.sol";
import { HookSubTypes } from "../../../libraries/HookSubTypes.sol";
import { HookDataDecoder } from "../../../libraries/HookDataDecoder.sol";

/// @title Redeem7540VaultHook
/// @author Superform Labs
/// @notice This hook does not support tokens reverting on 0 approval
/// @dev data has the following structure
/// @notice         bytes32 yieldSourceOracleId = bytes32(BytesLib.slice(data, 0, 32), 0);
/// @notice         address yieldSource = BytesLib.toAddress(data, 32);
/// @notice         uint256 shares = BytesLib.toUint256(data, 52);
/// @notice         bool usePrevHookAmount = _decodeBool(data, 84);
contract Redeem7540VaultHook is BaseHook, ISuperHookInflowOutflow, ISuperHookOutflow, ISuperHookContextAware {
    using HookDataDecoder for bytes;

    uint256 private constant AMOUNT_POSITION = 52;
    uint256 private constant USE_PREV_HOOK_AMOUNT_POSITION = 84;

    constructor() BaseHook(HookType.OUTFLOW, HookSubTypes.ERC7540) { }

    /*//////////////////////////////////////////////////////////////
                                 VIEW METHODS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc BaseHook
    function _buildHookExecutions(
        address prevHook,
        address account,
        bytes calldata data
    )
        internal
        view
        override
        returns (Execution[] memory executions)
    {
        address yieldSource = data.extractYieldSource();
        uint256 shares = _decodeAmount(data);
        bool usePrevHookAmount = _decodeBool(data, USE_PREV_HOOK_AMOUNT_POSITION);

        if (usePrevHookAmount) {
            shares = ISuperHookResultOutflow(prevHook).getOutAmount(account);
        }

        if (shares == 0) revert AMOUNT_NOT_VALID();
        if (yieldSource == address(0) || account == address(0)) revert ADDRESS_NOT_VALID();

        executions = new Execution[](1);
        executions[0] = Execution({
            target: yieldSource,
            value: 0,
            callData: abi.encodeCall(IERC7540.redeem, (shares, account, account))
        });
    }

    /*//////////////////////////////////////////////////////////////
                                 EXTERNAL METHODS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperHookInflowOutflow
    function decodeAmount(bytes memory data) external pure returns (uint256) {
        return _decodeAmount(data);
    }

    /// @inheritdoc ISuperHookContextAware
    function decodeUsePrevHookAmount(bytes memory data) external pure returns (bool) {
        return _decodeBool(data, USE_PREV_HOOK_AMOUNT_POSITION);
    }

    /// @inheritdoc ISuperHookOutflow
    function replaceCalldataAmount(bytes memory data, uint256 amount) external pure returns (bytes memory) {
        return _replaceCalldataAmount(data, amount, AMOUNT_POSITION);
    }

    /// @inheritdoc ISuperHookInspector
    function inspect(bytes calldata data) external pure override returns (bytes memory) {
        return abi.encodePacked(data.extractYieldSource());
    }

    /*//////////////////////////////////////////////////////////////    
                                 INTERNAL METHODS
    //////////////////////////////////////////////////////////////*/
    function _preExecute(address, address account, bytes calldata data) internal override {
        address yieldSource = data.extractYieldSource();
        asset = IERC7540(yieldSource).asset();
        _setOutAmount(_getBalance(account, data), account);
        usedShares = _getSharesBalance(account, data);
        spToken = IERC7540(yieldSource).share();
    }

    function _postExecute(address, address account, bytes calldata data) internal override {
        _setOutAmount(_getBalance(account, data) - getOutAmount(account), account);
        usedShares = usedShares - _getSharesBalance(account, data);
    }

    /*//////////////////////////////////////////////////////////////
                                 PRIVATE METHODS
    //////////////////////////////////////////////////////////////*/
    function _decodeAmount(bytes memory data) private pure returns (uint256) {
        return BytesLib.toUint256(data, AMOUNT_POSITION);
    }

    function _getBalance(address account, bytes memory) private view returns (uint256) {
        return IERC20(asset).balanceOf(account);
    }

    function _getSharesBalance(address account, bytes memory data) private view returns (uint256) {
        address yieldSource = data.extractYieldSource();
        return IERC7540(yieldSource).claimableRedeemRequest(0, account);
    }
}


59.0% lib/v2-core/src/hooks/vaults/7540/RequestDeposit7540VaultHook.sol

Lines covered: 19 / 32 (59.0%)

// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.30;

// external
import { BytesLib } from "../../../vendor/BytesLib.sol";
import { Execution } from "modulekit/accounts/erc7579/lib/ExecutionLib.sol";
import { IERC7540 } from "../../../vendor/vaults/7540/IERC7540.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

// Superform
import { BaseHook } from "../../BaseHook.sol";
import {
    ISuperHookResult,
    ISuperHookInflowOutflow,
    ISuperHookAsyncCancelations,
    ISuperHookContextAware,
    ISuperHookInspector
} from "../../../interfaces/ISuperHook.sol";
import { HookSubTypes } from "../../../libraries/HookSubTypes.sol";
import { HookDataDecoder } from "../../../libraries/HookDataDecoder.sol";

/// @title RequestDeposit7540VaultHook
/// @author Superform Labs
/// @dev data has the following structure
/// @notice         bytes32 placeholder = bytes32(BytesLib.slice(data, 0, 32), 0);
/// @notice         address yieldSource = BytesLib.toAddress(data, 32);
/// @notice         uint256 amount = BytesLib.toUint256(data, 52);
/// @notice         bool usePrevHookAmount = _decodeBool(data, 84);
contract RequestDeposit7540VaultHook is
    BaseHook,
    ISuperHookInflowOutflow,
    ISuperHookAsyncCancelations,
    ISuperHookContextAware
{
    using HookDataDecoder for bytes;

    uint256 private constant AMOUNT_POSITION = 52;
    uint256 private constant USE_PREV_HOOK_AMOUNT_POSITION = 84;

    constructor() BaseHook(HookType.NONACCOUNTING, HookSubTypes.ERC7540) { }

    /*//////////////////////////////////////////////////////////////
                                 VIEW METHODS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc BaseHook
    function _buildHookExecutions(
        address prevHook,
        address account,
        bytes calldata data
    )
        internal
        view
        override
        returns (Execution[] memory executions)
    {
        address yieldSource = data.extractYieldSource();
        uint256 amount = _decodeAmount(data);
        bool usePrevHookAmount = _decodeBool(data, USE_PREV_HOOK_AMOUNT_POSITION);

        if (usePrevHookAmount) {
            amount = ISuperHookResult(prevHook).getOutAmount(account);
        }

        if (amount == 0) revert AMOUNT_NOT_VALID();
        if (yieldSource == address(0) || account == address(0)) revert ADDRESS_NOT_VALID();

        executions = new Execution[](1);
        executions[0] = Execution({
            target: yieldSource,
            value: 0,
            callData: abi.encodeCall(IERC7540.requestDeposit, (amount, account, account))
        });
    }

    /// @inheritdoc ISuperHookAsyncCancelations
    function isAsyncCancelHook() external pure returns (CancelationType) {
        return CancelationType.NONE;
    }

    /*//////////////////////////////////////////////////////////////
                                 EXTERNAL METHODS
    //////////////////////////////////////////////////////////////*/

    /// @inheritdoc ISuperHookInflowOutflow
    function decodeAmount(bytes memory data) external pure returns (uint256) {
        return _decodeAmount(data);
    }

    /// @inheritdoc ISuperHookContextAware
    function decodeUsePrevHookAmount(bytes memory data) external pure returns (bool) {
        return _decodeBool(data, USE_PREV_HOOK_AMOUNT_POSITION);
    }

    /// @inheritdoc ISuperHookInspector
    function inspect(bytes calldata data) external pure override returns (bytes memory) {
        return abi.encodePacked(data.extractYieldSource());
    }

    /*//////////////////////////////////////////////////////////////
                                 INTERNAL METHODS
    //////////////////////////////////////////////////////////////*/
    function _preExecute(address, address account, bytes calldata data) internal override {
        _setOutAmount(_getBalance(account, data), account);
    }

    function _postExecute(address, address account, bytes calldata data) internal override {
        _setOutAmount(getOutAmount(account) - _getBalance(account, data), account);
    }

    /*//////////////////////////////////////////////////////////////
                                 PRIVATE METHODS
    //////////////////////////////////////////////////////////////*/
    function _decodeAmount(bytes memory data) private pure returns (uint256) {
        return BytesLib.toUint256(data, AMOUNT_POSITION);
    }

    function _getBalance(address account, bytes memory data) private view returns (uint256) {
        return IERC20(IERC7540(data.extractYieldSource()).asset()).balanceOf(account);
    }
}


59.0% lib/v2-core/src/hooks/vaults/7540/RequestRedeem7540VaultHook.sol

Lines covered: 19 / 32 (59.0%)

// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.30;

// external
import { BytesLib } from "../../../vendor/BytesLib.sol";
import { Execution } from "modulekit/accounts/erc7579/lib/ExecutionLib.sol";
import { IERC7540 } from "../../../vendor/vaults/7540/IERC7540.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

// Superform
import { BaseHook } from "../../BaseHook.sol";
import {
    ISuperHookResult,
    ISuperHookInflowOutflow,
    ISuperHookAsyncCancelations,
    ISuperHookContextAware,
    ISuperHookInspector
} from "../../../interfaces/ISuperHook.sol";
import { HookSubTypes } from "../../../libraries/HookSubTypes.sol";
import { HookDataDecoder } from "../../../libraries/HookDataDecoder.sol";

/// @title RequestRedeem7540VaultHook
/// @author Superform Labs
/// @dev data has the following structure
/// @notice         bytes32 placeholder = bytes32(BytesLib.slice(data, 0, 32), 0);
/// @notice         address yieldSource = BytesLib.toAddress(data, 32);
/// @notice         uint256 shares = BytesLib.toUint256(data, 52);
/// @notice         bool usePrevHookAmount = _decodeBool(data, 84);
contract RequestRedeem7540VaultHook is
    BaseHook,
    ISuperHookInflowOutflow,
    ISuperHookAsyncCancelations,
    ISuperHookContextAware
{
    using HookDataDecoder for bytes;

    uint256 private constant AMOUNT_POSITION = 52;
    uint256 private constant USE_PREV_HOOK_AMOUNT_POSITION = 84;

    constructor() BaseHook(HookType.NONACCOUNTING, HookSubTypes.ERC7540) { }

    /*//////////////////////////////////////////////////////////////
                                 VIEW METHODS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc BaseHook
    function _buildHookExecutions(
        address prevHook,
        address account,
        bytes calldata data
    )
        internal
        view
        override
        returns (Execution[] memory executions)
    {
        address yieldSource = data.extractYieldSource();
        uint256 shares = _decodeAmount(data);
        bool usePrevHookAmount = _decodeBool(data, USE_PREV_HOOK_AMOUNT_POSITION);

        if (usePrevHookAmount) {
            shares = ISuperHookResult(prevHook).getOutAmount(account);
        }

        if (shares == 0) revert AMOUNT_NOT_VALID();
        if (yieldSource == address(0) || account == address(0)) revert ADDRESS_NOT_VALID();

        executions = new Execution[](1);
        executions[0] = Execution({
            target: yieldSource,
            value: 0,
            callData: abi.encodeCall(IERC7540.requestRedeem, (shares, account, account))
        });
    }

    /// @inheritdoc ISuperHookAsyncCancelations
    function isAsyncCancelHook() external pure returns (CancelationType) {
        return CancelationType.NONE;
    }

    /*//////////////////////////////////////////////////////////////
                                 EXTERNAL METHODS
    //////////////////////////////////////////////////////////////*/

    /// @inheritdoc ISuperHookInflowOutflow
    function decodeAmount(bytes memory data) external pure returns (uint256) {
        return _decodeAmount(data);
    }

    /// @inheritdoc ISuperHookContextAware
    function decodeUsePrevHookAmount(bytes memory data) external pure returns (bool) {
        return _decodeBool(data, USE_PREV_HOOK_AMOUNT_POSITION);
    }

    /// @inheritdoc ISuperHookInspector
    function inspect(bytes calldata data) external pure override returns (bytes memory) {
        return abi.encodePacked(data.extractYieldSource());
    }

    /*//////////////////////////////////////////////////////////////
                                 INTERNAL METHODS
    //////////////////////////////////////////////////////////////*/

    function _preExecute(address, address account, bytes calldata data) internal override {
        _setOutAmount(_getBalance(account, data), account);
    }

    function _postExecute(address, address account, bytes calldata data) internal override {
        _setOutAmount(getOutAmount(account) - _getBalance(account, data), account);
    }

    /*//////////////////////////////////////////////////////////////
                                 PRIVATE METHODS
    //////////////////////////////////////////////////////////////*/

    function _decodeAmount(bytes memory data) private pure returns (uint256) {
        return BytesLib.toUint256(data, AMOUNT_POSITION);
    }

    function _getBalance(address account, bytes memory data) private view returns (uint256) {
        return IERC20(IERC7540(data.extractYieldSource()).share()).balanceOf(account);
    }
}


4.0% lib/v2-core/src/hooks/vaults/7540/Withdraw7540VaultHook.sol

Lines covered: 2 / 41 (4.0%)

// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.30;

// external
import { BytesLib } from "../../../vendor/BytesLib.sol";
import { Execution } from "modulekit/accounts/erc7579/lib/ExecutionLib.sol";
import { IERC20 } from "@openzeppelin/contracts/interfaces/IERC20.sol";
import { IERC7540 } from "../../../vendor/vaults/7540/IERC7540.sol";

// Superform
import { BaseHook } from "../../BaseHook.sol";
import {
    ISuperHookResultOutflow,
    ISuperHookInflowOutflow,
    ISuperHookOutflow,
    ISuperHookContextAware,
    ISuperHookInspector
} from "../../../interfaces/ISuperHook.sol";
import { HookSubTypes } from "../../../libraries/HookSubTypes.sol";
import { HookDataDecoder } from "../../../libraries/HookDataDecoder.sol";

/// @title Withdraw7540VaultHook
/// @author Superform Labs
/// @notice Compatible only with ERC-7540 vaults where `requestId` is non-fungible
/// @dev data has the following structure
/// @notice         bytes32 yieldSourceOracleId = bytes32(BytesLib.slice(data, 0, 32), 0);
/// @notice         address yieldSource = BytesLib.toAddress(data, 32);
/// @notice         uint256 amount = BytesLib.toUint256(data, 52);
/// @notice         bool usePrevHookAmount = _decodeBool(data, 84);
contract Withdraw7540VaultHook is BaseHook, ISuperHookInflowOutflow, ISuperHookOutflow, ISuperHookContextAware {
    using HookDataDecoder for bytes;

    uint256 private constant AMOUNT_POSITION = 52;
    uint256 private constant USE_PREV_HOOK_AMOUNT_POSITION = 84;

    constructor() BaseHook(HookType.OUTFLOW, HookSubTypes.ERC7540) { }

    /*//////////////////////////////////////////////////////////////
                                 VIEW METHODS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc BaseHook
    function _buildHookExecutions(
        address prevHook,
        address account,
        bytes calldata data
    )
        internal
        view
        override
        returns (Execution[] memory executions)
    {
        address yieldSource = data.extractYieldSource();
        uint256 amount = _decodeAmount(data);
        bool usePrevHookAmount = _decodeBool(data, USE_PREV_HOOK_AMOUNT_POSITION);

        if (usePrevHookAmount) {
            amount = ISuperHookResultOutflow(prevHook).getOutAmount(account);
        }

        if (amount == 0) revert AMOUNT_NOT_VALID();
        if (yieldSource == address(0) || account == address(0)) revert ADDRESS_NOT_VALID();

        executions = new Execution[](1);
        executions[0] = Execution({
            target: yieldSource,
            value: 0,
            callData: abi.encodeCall(IERC7540.withdraw, (amount, account, account))
        });
    }

    /*//////////////////////////////////////////////////////////////
                                 EXTERNAL METHODS
    //////////////////////////////////////////////////////////////*/

    /// @inheritdoc ISuperHookInflowOutflow
    function decodeAmount(bytes memory data) external pure returns (uint256) {
        return _decodeAmount(data);
    }

    /// @inheritdoc ISuperHookContextAware
    function decodeUsePrevHookAmount(bytes memory data) external pure returns (bool) {
        return _decodeBool(data, USE_PREV_HOOK_AMOUNT_POSITION);
    }

    /// @inheritdoc ISuperHookOutflow
    function replaceCalldataAmount(bytes memory data, uint256 amount) external pure returns (bytes memory) {
        return _replaceCalldataAmount(data, amount, AMOUNT_POSITION);
    }

    /// @inheritdoc ISuperHookInspector
    function inspect(bytes calldata data) external pure override returns (bytes memory) {
        return abi.encodePacked(data.extractYieldSource());
    }

    /*//////////////////////////////////////////////////////////////
                                 INTERNAL METHODS
    //////////////////////////////////////////////////////////////*/
    function _preExecute(address, address account, bytes calldata data) internal override {
        address yieldSource = data.extractYieldSource();
        asset = IERC7540(yieldSource).asset();
        _setOutAmount(_getBalance(account, data), account);
        usedShares = _getSharesBalance(account, data);
        spToken = IERC7540(yieldSource).share();
    }

    function _postExecute(address, address account, bytes calldata data) internal override {
        _setOutAmount(_getBalance(account, data) - getOutAmount(account), account);
        usedShares = usedShares - _getSharesBalance(account, data);
    }

    /*//////////////////////////////////////////////////////////////
                                 PRIVATE METHODS
    //////////////////////////////////////////////////////////////*/
    function _decodeAmount(bytes memory data) private pure returns (uint256) {
        return BytesLib.toUint256(data, AMOUNT_POSITION);
    }

    function _getBalance(address account, bytes memory) private view returns (uint256) {
        return IERC20(asset).balanceOf(account);
    }

    function _getSharesBalance(address account, bytes memory data) private view returns (uint256) {
        address yieldSource = data.extractYieldSource();
        return IERC7540(yieldSource).claimableRedeemRequest(0, account);
    }
}


85.0% lib/v2-core/src/hooks/vaults/super-vault/CancelRedeemHook.sol

Lines covered: 17 / 20 (85.0%)

// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.30;

// external
import { Execution } from "modulekit/accounts/erc7579/lib/ExecutionLib.sol";
import { IERC7540 } from "../../../vendor/vaults/7540/IERC7540.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

// Superform
import { BaseHook } from "../../BaseHook.sol";
import { VaultBankLockableHook } from "../../VaultBankLockableHook.sol";
import { HookSubTypes } from "../../../libraries/HookSubTypes.sol";
import { HookDataDecoder } from "../../../libraries/HookDataDecoder.sol";
import { ISuperVault } from "../../../vendor/superform/ISuperVault.sol";
import { ISuperHookAsyncCancelations, ISuperHookInspector } from "../../../interfaces/ISuperHook.sol";

/// @title CancelRedeemHook
/// @author Superform Labs
/// @dev data has the following structure
/// @notice         bytes32 placeholder = bytes32(BytesLib.slice(data, 0, 32), 0);
/// @notice         address yieldSource = BytesLib.toAddress(data, 32);
contract CancelRedeemHook is BaseHook, VaultBankLockableHook, ISuperHookAsyncCancelations {
    using HookDataDecoder for bytes;

    constructor() BaseHook(HookType.NONACCOUNTING, HookSubTypes.CANCEL_REDEEM) { }

    /*//////////////////////////////////////////////////////////////
                                 VIEW METHODS
    //////////////////////////////////////////////////////////////*/
    function _buildHookExecutions(
        address,
        address account,
        bytes calldata data
    )
        internal
        pure
        override
        returns (Execution[] memory executions)
    {
        address yieldSource = data.extractYieldSource();

        if (yieldSource == address(0) || account == address(0)) revert ADDRESS_NOT_VALID();

        executions = new Execution[](1);
        executions[0] =
            Execution({ target: yieldSource, value: 0, callData: abi.encodeCall(ISuperVault.cancelRedeem, (account)) });
    }

    /*//////////////////////////////////////////////////////////////
                                 EX`TERNAL METHODS
    //////////////////////////////////////////////////////////////*/

    /// @inheritdoc ISuperHookAsyncCancelations
    function isAsyncCancelHook() external pure returns (CancelationType) {
        return CancelationType.OUTFLOW;
    }

    /// @inheritdoc ISuperHookInspector
    function inspect(bytes calldata data) external pure override returns (bytes memory) {
        return abi.encodePacked(data.extractYieldSource());
    }

    /*//////////////////////////////////////////////////////////////
                                 INTERNAL METHODS
    //////////////////////////////////////////////////////////////*/
    function _preExecute(address, address account, bytes calldata data) internal override {
        _setOutAmount(_getBalance(account, data), account);
        spToken = data.extractYieldSource();
    }

    function _postExecute(address, address account, bytes calldata data) internal override {
        _setOutAmount(_getBalance(account, data) - getOutAmount(account), account);
    }
    /*//////////////////////////////////////////////////////////////
                                 PRIVATE METHODS
    //////////////////////////////////////////////////////////////*/

    function _getBalance(address account, bytes memory data) private view returns (uint256) {
        return IERC20(IERC7540(data.extractYieldSource()).share()).balanceOf(account);
    }
}


4.0% lib/v2-core/src/hooks/vaults/super-vault/Withdraw7540VaultHook.sol

Lines covered: 2 / 41 (4.0%)

// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.30;

// external
import { BytesLib } from "../../../vendor/BytesLib.sol";
import { Execution } from "modulekit/accounts/erc7579/lib/ExecutionLib.sol";
import { IERC20 } from "@openzeppelin/contracts/interfaces/IERC20.sol";
import { IERC7540 } from "../../../vendor/vaults/7540/IERC7540.sol";

// Superform
import { BaseHook } from "../../BaseHook.sol";
import {
    ISuperHookResultOutflow,
    ISuperHookInflowOutflow,
    ISuperHookOutflow,
    ISuperHookContextAware,
    ISuperHookInspector
} from "../../../interfaces/ISuperHook.sol";
import { HookSubTypes } from "../../../libraries/HookSubTypes.sol";
import { HookDataDecoder } from "../../../libraries/HookDataDecoder.sol";

/// @title Withdraw7540VaultHook
/// @author Superform Labs
/// @notice Compatible only with ERC-7540 vaults where `requestId` is non-fungible
/// @dev data has the following structure
/// @notice         bytes32 yieldSourceOracleId = bytes32(BytesLib.slice(data, 0, 32), 0);
/// @notice         address yieldSource = BytesLib.toAddress(data, 32);
/// @notice         uint256 amount = BytesLib.toUint256(data, 52);
/// @notice         bool usePrevHookAmount = _decodeBool(data, 84);
contract Withdraw7540VaultHook is BaseHook, ISuperHookInflowOutflow, ISuperHookOutflow, ISuperHookContextAware {
    using HookDataDecoder for bytes;

    uint256 private constant AMOUNT_POSITION = 52;
    uint256 private constant USE_PREV_HOOK_AMOUNT_POSITION = 84;

    constructor() BaseHook(HookType.OUTFLOW, HookSubTypes.ERC7540) { }

    /*//////////////////////////////////////////////////////////////
                                 VIEW METHODS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc BaseHook
    function _buildHookExecutions(
        address prevHook,
        address account,
        bytes calldata data
    )
        internal
        view
        override
        returns (Execution[] memory executions)
    {
        address yieldSource = data.extractYieldSource();
        uint256 amount = _decodeAmount(data);
        bool usePrevHookAmount = _decodeBool(data, USE_PREV_HOOK_AMOUNT_POSITION);

        if (usePrevHookAmount) {
            amount = ISuperHookResultOutflow(prevHook).getOutAmount(account);
        }

        if (amount == 0) revert AMOUNT_NOT_VALID();
        if (yieldSource == address(0) || account == address(0)) revert ADDRESS_NOT_VALID();

        executions = new Execution[](1);
        executions[0] = Execution({
            target: yieldSource,
            value: 0,
            callData: abi.encodeCall(IERC7540.withdraw, (amount, account, account))
        });
    }

    /*//////////////////////////////////////////////////////////////
                                 EXTERNAL METHODS
    //////////////////////////////////////////////////////////////*/

    /// @inheritdoc ISuperHookInflowOutflow
    function decodeAmount(bytes memory data) external pure returns (uint256) {
        return _decodeAmount(data);
    }

    /// @inheritdoc ISuperHookContextAware
    function decodeUsePrevHookAmount(bytes memory data) external pure returns (bool) {
        return _decodeBool(data, USE_PREV_HOOK_AMOUNT_POSITION);
    }

    /// @inheritdoc ISuperHookOutflow
    function replaceCalldataAmount(bytes memory data, uint256 amount) external pure returns (bytes memory) {
        return _replaceCalldataAmount(data, amount, AMOUNT_POSITION);
    }

    /// @inheritdoc ISuperHookInspector
    function inspect(bytes calldata data) external pure override returns (bytes memory) {
        return abi.encodePacked(data.extractYieldSource());
    }

    /*//////////////////////////////////////////////////////////////
                                 INTERNAL METHODS
    //////////////////////////////////////////////////////////////*/
    function _preExecute(address, address account, bytes calldata data) internal override {
        address yieldSource = data.extractYieldSource();
        asset = IERC7540(yieldSource).asset();
        _setOutAmount(_getBalance(account, data), account);
        usedShares = _getSharesBalance(account, data);
        spToken = IERC7540(yieldSource).share();
    }

    function _postExecute(address, address account, bytes calldata data) internal override {
        _setOutAmount(_getBalance(account, data) - getOutAmount(account), account);
        usedShares = usedShares - _getSharesBalance(account, data);
    }

    /*//////////////////////////////////////////////////////////////
                                 PRIVATE METHODS
    //////////////////////////////////////////////////////////////*/
    function _decodeAmount(bytes memory data) private pure returns (uint256) {
        return BytesLib.toUint256(data, AMOUNT_POSITION);
    }

    function _getBalance(address account, bytes memory) private view returns (uint256) {
        return IERC20(asset).balanceOf(account);
    }

    function _getSharesBalance(address account, bytes memory data) private view returns (uint256) {
        address yieldSource = data.extractYieldSource();
        return IERC7540(yieldSource).claimableRedeemRequest(0, account);
    }
}


0.0% lib/v2-core/src/interfaces/ISuperHook.sol

Lines covered: 0 / 0 (0.0%)

// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.30;

// external
import { Execution } from "modulekit/accounts/erc7579/lib/ExecutionLib.sol";

/**
 * @title SuperHook System
 * @author Superform Labs
 * @notice The hook system provides a modular and composable way to execute operations on assets
 * @dev The hook system architecture consists of several interfaces that work together:
 *      - ISuperHook: The base interface all hooks implement, with lifecycle methods
 *      - ISuperHookResult: Provides execution results and output information
 *      - Specialized interfaces (ISuperHookOutflow, ISuperHookLoans, etc.) for specific behaviors
 *
 * Hooks are executed in sequence, where each hook can access the results from previous hooks.
 * The three main types of hooks are:
 *      - NONACCOUNTING: Utility hooks that don't update the accounting system
 *      - INFLOW: Hooks that process deposits or additions to positions
 *      - OUTFLOW: Hooks that process withdrawals or reductions to positions
 */
interface ISuperLockableHook {
    /// @notice The vault bank address used to lock SuperPositions
    /// @dev Only relevant for cross-chain operations where positions are locked
    /// @return The vault bank address, or address(0) if not applicable
    function vaultBank() external view returns (address);

    /// @notice The destination chain ID for cross-chain operations
    /// @dev Used to identify the target chain for cross-chain position transfers
    /// @return The destination chain ID, or 0 if not a cross-chain operation
    function dstChainId() external view returns (uint256);
}

interface ISuperHookSetter {
    /// @notice Sets the output amount for the hook
    /// @dev Used for updating `outAmount` when fees were deducted
    /// @param outAmount The amount of tokens processed by the hook
    /// @param caller The caller address for context identification
    function setOutAmount(uint256 outAmount, address caller) external;
}
/// @title ISuperHookInspector
/// @author Superform Labs
/// @notice Interface for the SuperHookInspector contract that manages hook inspection

interface ISuperHookInspector {
    /// @notice Inspect the hook
    /// @param data The hook data to inspect
    /// @return argsEncoded The arguments of the hook encoded
    function inspect(bytes calldata data) external view returns (bytes memory argsEncoded);
}

/// @title ISuperHookResult
/// @author Superform Labs
/// @notice Interface that exposes the result of a hook execution
/// @dev All hooks must implement this interface to provide standardized access to execution results.
///      These results are used by subsequent hooks in the execution chain and by the executor.
interface ISuperHookResult {
    /*//////////////////////////////////////////////////////////////
                                 VIEW METHODS
    //////////////////////////////////////////////////////////////*/

    /// @notice The type of hook
    /// @dev Used to determine how accounting should process this hook's results
    /// @return The hook type (NONACCOUNTING, INFLOW, or OUTFLOW)
    function hookType() external view returns (ISuperHook.HookType);

    /// @notice The SuperPosition (SP) token associated with this hook
    /// @dev For vault hooks, this would be the tokenized position representing shares
    /// @return The address of the SP token, or address(0) if not applicable
    function spToken() external view returns (address);

    /// @notice The underlying asset token being processed
    /// @dev For most hooks, this is the actual token being deposited or withdrawn
    /// @return The address of the asset token, or address(0) for native assets
    function asset() external view returns (address);

    /// @notice The amount of tokens processed by the hook in a given caller context, subject to fees after update
    /// @dev This is the primary output value used by subsequent hooks
    /// @param caller The caller address for context identification
    /// @return The amount of tokens (assets or shares) processed
    function getOutAmount(address caller) external view returns (uint256);
}

/// @title ISuperHookContextAware
/// @author Superform Labs
/// @notice Interface for hooks that can use previous hook results in their execution
/// @dev Enables contextual awareness and data flow between hooks in a chain
interface ISuperHookContextAware {
    /// @notice Determines if this hook should use the amount from the previous hook
    /// @dev Used to create hook chains where output from one hook becomes input to the next
    /// @param data The hook-specific data containing configuration
    /// @return True if the hook should use the previous hook's output amount
    function decodeUsePrevHookAmount(bytes memory data) external pure returns (bool);
}

/// @title ISuperHookInflowOutflow
/// @author Superform Labs
/// @notice Interface for hooks that handle both inflows and outflows
/// @dev Provides standardized amount extraction for both deposit and withdrawal operations
interface ISuperHookInflowOutflow {
    /// @notice Extracts the amount from the hook's calldata
    /// @dev Used to determine the quantity of assets or shares being processed
    /// @param data The hook-specific calldata containing the amount
    /// @return The amount of tokens to process
    function decodeAmount(bytes memory data) external pure returns (uint256);
}

/// @title ISuperHookOutflow
/// @author Superform Labs
/// @notice Interface for hooks that specifically handle outflows (withdrawals)
/// @dev Provides additional functionality needed only for outflow operations
interface ISuperHookOutflow {
    /// @notice Replace the amount in the calldata
    /// @param data The data to replace the amount in
    /// @param amount The amount to replace
    /// @return data The data with the replaced amount
    function replaceCalldataAmount(bytes memory data, uint256 amount) external pure returns (bytes memory);
}

/// @title ISuperHookResultOutflow
/// @author Superform Labs
/// @notice Extended result interface for outflow hook operations
/// @dev Extends the base result interface with outflow-specific information
interface ISuperHookResultOutflow is ISuperHookResult {
    /// @notice The amount of shares consumed during outflow processing
    /// @dev Used for cost basis calculation in the accounting system
    /// @return The amount of shares consumed from the user's position
    function usedShares() external view returns (uint256);
}

/// @title ISuperHookLoans
/// @author Superform Labs
/// @notice Interface for hooks that interact with lending protocols
/// @dev Extends context awareness to enable loan operations within hook chains
interface ISuperHookLoans is ISuperHookContextAware {
    /// @notice Gets the address of the token being borrowed
    /// @dev Used to identify which asset is being borrowed from the lending protocol
    /// @param data The hook-specific data containing loan information
    /// @return The address of the borrowed token
    function getLoanTokenAddress(bytes memory data) external pure returns (address);

    /// @notice Gets the address of the token used as collateral
    /// @dev Used to identify which asset is being used to secure the loan
    /// @param data The hook-specific data containing collateral information
    /// @return The address of the collateral token
    function getCollateralTokenAddress(bytes memory data) external view returns (address);

    /// @notice Gets the current loan token balance for an account
    /// @dev Used to track outstanding loan amounts
    /// @param account The account to check the loan balance for
    /// @param data The hook-specific data containing loan parameters
    /// @return The amount of tokens currently borrowed
    function getLoanTokenBalance(address account, bytes memory data) external view returns (uint256);

    /// @notice Gets the current collateral token balance for an account
    /// @dev Used to track collateral positions
    /// @param account The account to check the collateral balance for
    /// @param data The hook-specific data containing collateral parameters
    /// @return The amount of tokens currently used as collateral
    function getCollateralTokenBalance(address account, bytes memory data) external view returns (uint256);
}

/// @title ISuperHookAsyncCancelations
/// @author Superform Labs
/// @notice Interface for hooks that can cancel asynchronous operations
/// @dev Used to handle cancellation of pending operations that haven't completed
interface ISuperHookAsyncCancelations {
    /// @notice Types of cancellations that can be performed
    /// @dev Distinguishes between different operation types that can be canceled
    enum CancelationType {
        NONE, // Not a cancelation hook
        INFLOW, // Cancels a pending deposit operation
        OUTFLOW // Cancels a pending withdrawal operation

    }

    /// @notice Identifies the type of async operation this hook can cancel
    /// @dev Used to verify the hook is appropriate for the operation being canceled
    /// @return asyncType The type of cancellation this hook performs
    function isAsyncCancelHook() external pure returns (CancelationType asyncType);
}

/// @title ISuperHook
/// @author Superform Labs
/// @notice The core hook interface that all hooks must implement
/// @dev Defines the lifecycle methods and execution flow for the hook system
///      Hooks are executed in sequence with results passed between them
interface ISuperHook {
    /*//////////////////////////////////////////////////////////////

                                 ENUMS
    //////////////////////////////////////////////////////////////*/
    /// @notice Defines the possible types of hooks in the system
    /// @dev Used to determine how the hook affects accounting and what operations it performs
    enum HookType {
        NONACCOUNTING, // Hook doesn't affect accounting (e.g., a swap or bridge)
        INFLOW, // Hook processes deposits or positions being added
        OUTFLOW // Hook processes withdrawals or positions being removed

    }

    /*//////////////////////////////////////////////////////////////
                                 VIEW METHODS
    //////////////////////////////////////////////////////////////*/
    /// @notice Builds the execution array for the hook operation
    /// @dev This is the core method where hooks define their on-chain interactions
    ///      The returned executions are a sequence of contract calls to perform
    ///      No state changes should occur in this method
    /// @param prevHook The address of the previous hook in the chain, or address(0) if first
    /// @param account The account to perform executions for (usually an ERC7579 account)
    /// @param data The hook-specific parameters and configuration data
    /// @return executions Array of Execution structs defining calls to make
    function build(
        address prevHook,
        address account,
        bytes calldata data
    )
        external
        view
        returns (Execution[] memory executions);

    /*//////////////////////////////////////////////////////////////
                                 PUBLIC METHODS
    //////////////////////////////////////////////////////////////*/
    /// @notice Prepares the hook for execution
    /// @dev Called before the main execution, used to validate inputs and set execution context
    ///      This method may perform state changes to set up the hook's execution state
    /// @param prevHook The address of the previous hook in the chain, or address(0) if first
    /// @param account The account to perform operations for
    /// @param data The hook-specific parameters and configuration data
    function preExecute(address prevHook, address account, bytes memory data) external;

    /// @notice Finalizes the hook after execution
    /// @dev Called after the main execution, used to update hook state and calculate results
    ///      Sets output values (outAmount, usedShares, etc.) for subsequent hooks
    /// @param prevHook The address of the previous hook in the chain, or address(0) if first
    /// @param account The account operations were performed for
    /// @param data The hook-specific parameters and configuration data
    function postExecute(address prevHook, address account, bytes memory data) external;

    /// @notice Returns the specific subtype identification for this hook
    /// @dev Used to categorize hooks beyond the basic HookType
    ///      For example, a hook might be of type INFLOW but subtype VAULT_DEPOSIT
    /// @return A bytes32 identifier for the specific hook functionality
    function subtype() external view returns (bytes32);

    /// @notice Resets hook mutexes
    /// @param caller The caller address for context identification
    function resetExecutionState(address caller) external;

    /// @notice Sets the caller address that initiated the execution
    /// @dev Used for security validation between preExecute and postExecute calls
    /// @param caller The caller address for context identification
    function setExecutionContext(address caller) external;

    /// @notice Returns the execution nonce for the current execution context
    /// @dev Used to ensure unique execution contexts and prevent replay attacks
    /// @return The execution nonce
    function executionNonce() external view returns (uint256);

    /// @notice Returns the last caller registered by `setExecutionContext`
    /// @return The last caller address
    function lastCaller() external view returns (address);
}


0.0% lib/v2-core/src/interfaces/accounting/IYieldSourceOracle.sol

Lines covered: 0 / 0 (0.0%)

// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.30;

// Superform
import { IOracle } from "../../vendor/awesome-oracles/IOracle.sol";

/// @title IYieldSourceOracle
/// @author Superform Labs
/// @notice Interface for oracles that provide price and TVL data for yield-bearing assets
interface IYieldSourceOracle {
    /*//////////////////////////////////////////////////////////////
                                ERRORS
    //////////////////////////////////////////////////////////////*/

    /// @notice Error when array lengths do not match in batch operations
    /// @dev Thrown when the lengths of input arrays in multi-asset operations don't match
    error ARRAY_LENGTH_MISMATCH();

    /// @notice Error when base asset is not valid for the yield source
    /// @dev Thrown when attempting to use an asset that isn't supported by the yield source
    error INVALID_BASE_ASSET();

    /*//////////////////////////////////////////////////////////////
                                STRUCTS
    //////////////////////////////////////////////////////////////*/

    /// @notice Struct to hold local variables for getTVLMultipleUSD
    /// @dev Used to manage complex computation state without stack-too-deep errors
    ///      These variables support the calculation of USD-denominated TVL values
    ///      across multiple yield sources and owners
    struct TVLMultipleUSDVars {
        /// @notice Number of yield sources being processed
        uint256 length;
        /// @notice Number of share owners being processed
        uint256 ownersLength;
        /// @notice Base amount in the underlying asset's native units
        uint256 baseAmount;
        /// @notice Accumulated TVL in USD for a specific user
        uint256 userTvlUSD;
        /// @notice Accumulated total TVL in USD across all sources
        uint256 totalTvlUSD;
        /// @notice Current yield source being processed
        address yieldSource;
        /// @notice Array of addresses that own shares in the yield source
        address[] owners;
        /// @notice Oracle registry used for price conversions
        IOracle registry;
    }

    /*//////////////////////////////////////////////////////////////
                            VIEW METHODS
    //////////////////////////////////////////////////////////////*/

    /// @notice Returns the number of decimals of the yield source shares
    /// @dev Critical for accurately interpreting share amounts and calculating prices
    ///      Different yield sources may have different decimal precision
    /// @param yieldSourceAddress The address of the yield-bearing token contract
    /// @return decimals The number of decimals used by the yield source's share token
    function decimals(address yieldSourceAddress) external view returns (uint8);

    /// @notice Calculates the number of shares that would be received for a given amount of assets
    /// @dev Used for deposit simulations and to calculate current exchange rates
    /// @param yieldSourceAddress The yield-bearing token address (e.g., aUSDC, cDAI)
    /// @param assetIn The underlying asset being deposited (e.g., USDC, DAI)
    /// @param assetsIn The amount of underlying assets to deposit, in the asset's native units
    /// @return shares The number of yield-bearing shares that would be received
    function getShareOutput(
        address yieldSourceAddress,
        address assetIn,
        uint256 assetsIn
    )
        external
        view
        returns (uint256);

    /// @notice Calculates the number of underlying assets that would be received for a given amount of shares
    /// @dev Used for withdrawal simulations and to calculate current yield
    /// @param yieldSourceAddress The yield-bearing token address (e.g., aUSDC, cDAI)
    /// @param assetIn The underlying asset to receive (e.g., USDC, DAI)
    /// @param sharesIn The amount of yield-bearing shares to redeem
    /// @return assets The number of underlying assets that would be received
    function getAssetOutput(
        address yieldSourceAddress,
        address assetIn,
        uint256 sharesIn
    )
        external
        view
        returns (uint256);

    /// @notice Retrieves the current price per share in terms of the underlying asset
    /// @dev Core function for calculating yields and determining returns
    /// @param yieldSourceAddress The yield-bearing token address to get the price for
    /// @return pricePerShare The current price per share in underlying asset terms, scaled by decimals
    function getPricePerShare(address yieldSourceAddress) external view returns (uint256);

    /// @notice Calculates the total value locked in a yield source by a specific owner
    /// @dev Used to track individual position sizes within the system
    /// @param yieldSourceAddress The yield-bearing token address to check
    /// @param ownerOfShares The address owning the yield-bearing tokens
    /// @return tvl The total value locked by the owner, in underlying asset terms
    function getTVLByOwnerOfShares(address yieldSourceAddress, address ownerOfShares) external view returns (uint256);

    /// @notice Gets the share balance of a specific owner in a yield source
    /// @dev Returns raw share balance without converting to underlying assets
    ///      Used to track participation in the system and for accounting
    /// @param yieldSourceAddress The yield-bearing token address
    /// @param ownerOfShares The address to check the balance for
    /// @return balance The number of yield-bearing tokens owned by the address
    function getBalanceOfOwner(address yieldSourceAddress, address ownerOfShares) external view returns (uint256);

    /// @notice Calculates the total value locked across all users in a yield source
    /// @dev Critical for monitoring the size of each yield source in the system
    /// @param yieldSourceAddress The yield-bearing token address to check
    /// @return tvl The total value locked in the yield source, in underlying asset terms
    function getTVL(address yieldSourceAddress) external view returns (uint256);

    /// @notice Batch version of getPricePerShare for multiple yield sources
    /// @dev Efficiently retrieves current prices for multiple yield sources
    /// @param yieldSourceAddresses Array of yield-bearing token addresses
    /// @return pricesPerShare Array of current prices for each yield source
    function getPricePerShareMultiple(address[] memory yieldSourceAddresses)
        external
        view
        returns (uint256[] memory pricesPerShare);

    /// @notice Batch version of getTVLByOwnerOfShares for multiple yield sources and owners
    /// @dev Efficiently calculates TVL for multiple owners across multiple yield sources
    /// @param yieldSourceAddresses Array of yield-bearing token addresses
    /// @param ownersOfShares 2D array where each sub-array contains owner addresses for a yield source
    /// @return userTvls 2D array of TVL values for each owner in each yield source
    function getTVLByOwnerOfSharesMultiple(
        address[] memory yieldSourceAddresses,
        address[][] memory ownersOfShares
    )
        external
        view
        returns (uint256[][] memory userTvls);

    /// @notice Batch version of getTVL for multiple yield sources
    /// @dev Efficiently calculates total TVL across multiple yield sources
    /// @param yieldSourceAddresses Array of yield-bearing token addresses
    /// @return tvls Array containing the total TVL for each yield source
    function getTVLMultiple(address[] memory yieldSourceAddresses) external view returns (uint256[] memory tvls);

    /// @notice Calculates the asset output with fees added for an outflow operation
    /// @dev Gets the asset output from the oracle and adds any applicable fees
    ///      Uses try/catch to handle cases where oracle configuration doesn't exist
    /// @param yieldSourceOracleId Identifier for the yield source oracle configuration
    /// @param yieldSourceAddress Address of the yield-bearing asset
    /// @param assetOut Address of the output asset
    /// @param user Address of the user performing the outflow
    /// @param usedShares Amount of shares being withdrawn
    /// @return Total asset amount including fees
    function getAssetOutputWithFees(
        bytes32 yieldSourceOracleId,
        address yieldSourceAddress,
        address assetOut,
        address user,
        uint256 usedShares
    )
        external
        view
        returns (uint256);
}


66.0% lib/v2-core/src/libraries/HookDataDecoder.sol

Lines covered: 2 / 3 (66.0%)

// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.30;

import { BytesLib } from "../vendor/BytesLib.sol";

/// @title HookDataDecoder
/// @author Superform Labs
/// @notice Library for decoding hook data
library HookDataDecoder {
    function extractYieldSourceOracleId(bytes memory data) internal pure returns (bytes32) {
        return bytes32(BytesLib.slice(data, 0, 32));
    }

    function extractYieldSource(bytes memory data) internal pure returns (address) {
        return BytesLib.toAddress(data, 32);
    }
}


34.0% lib/v2-core/src/libraries/HookSubTypes.sol

Lines covered: 8 / 23 (34.0%)

// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.30;

/// @title HookSubTypes
/// @author Superform Labs
/// @notice Library for hook subtypes
library HookSubTypes {
    bytes32 public constant BRIDGE = keccak256(bytes("Bridge"));
    bytes32 public constant CANCEL_DEPOSIT = keccak256(bytes("CancelDeposit"));
    bytes32 public constant CANCEL_DEPOSIT_REQUEST = keccak256(bytes("CancelDepositRequest"));
    bytes32 public constant CANCEL_REDEEM = keccak256(bytes("CancelRedeem"));
    bytes32 public constant CANCEL_REDEEM_REQUEST = keccak256(bytes("CancelRedeemRequest"));
    bytes32 public constant CLAIM = keccak256(bytes("Claim"));
    bytes32 public constant CLAIM_CANCEL_DEPOSIT_REQUEST = keccak256(bytes("ClaimCancelDepositRequest"));
    bytes32 public constant CLAIM_CANCEL_REDEEM_REQUEST = keccak256(bytes("ClaimCancelRedeemRequest"));
    bytes32 public constant COOLDOWN = keccak256(bytes("Cooldown"));
    bytes32 public constant ETHENA = keccak256(bytes("Ethena"));
    bytes32 public constant ERC4626 = keccak256(bytes("ERC4626"));
    bytes32 public constant ERC5115 = keccak256(bytes("ERC5115"));
    bytes32 public constant ERC7540 = keccak256(bytes("ERC7540"));
    bytes32 public constant LOAN = keccak256(bytes("Loan"));
    bytes32 public constant LOAN_REPAY = keccak256(bytes("LoanRepay"));
    bytes32 public constant MISC = keccak256(bytes("Misc"));
    bytes32 public constant STAKE = keccak256(bytes("Stake"));
    bytes32 public constant SWAP = keccak256(bytes("Swap"));
    bytes32 public constant TOKEN = keccak256(bytes("Token"));
    bytes32 public constant UNSTAKE = keccak256(bytes("Unstake"));
    bytes32 public constant PTYT = keccak256(bytes("PTYT"));
    bytes32 public constant VAULT_BANK = keccak256(bytes("VaultBank"));

    function getHookSubType(string memory hookSubtype) internal pure returns (bytes32) {
        return keccak256(bytes(hookSubtype));
    }
}


85.0% lib/v2-core/src/vendor/BytesLib.sol

Lines covered: 6 / 7 (85.0%)

// SPDX-License-Identifier: Unlicense
/*
 * @title Solidity Bytes Arrays Utils
 * @author Gonçalo Sá <goncalo.sa@consensys.net>
 *
 * @dev Bytes tightly packed arrays utility library for ethereum contracts written in Solidity.
 *      The library lets you concatenate, slice and type cast bytes arrays both in memory and storage.
 */
pragma solidity 0.8.30;

library BytesLib {
    function concat(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bytes memory) {
        bytes memory tempBytes;

        assembly {
            // Get a location of some free memory and store it in tempBytes as
            // Solidity does for memory variables.
            tempBytes := mload(0x40)

            // Store the length of the first bytes array at the beginning of
            // the memory for tempBytes.
            let length := mload(_preBytes)
            mstore(tempBytes, length)

            // Maintain a memory counter for the current write location in the
            // temp bytes array by adding the 32 bytes for the array length to
            // the starting location.
            let mc := add(tempBytes, 0x20)
            // Stop copying when the memory counter reaches the length of the
            // first bytes array.
            let end := add(mc, length)

            for {
                // Initialize a copy counter to the start of the _preBytes data,
                // 32 bytes into its memory.
                let cc := add(_preBytes, 0x20)
            } lt(mc, end) {
                // Increase both counters by 32 bytes each iteration.
                mc := add(mc, 0x20)
                cc := add(cc, 0x20)
            } {
                // Write the _preBytes data into the tempBytes memory 32 bytes
                // at a time.
                mstore(mc, mload(cc))
            }

            // Add the length of _postBytes to the current length of tempBytes
            // and store it as the new length in the first 32 bytes of the
            // tempBytes memory.
            length := mload(_postBytes)
            mstore(tempBytes, add(length, mload(tempBytes)))

            // Move the memory counter back from a multiple of 0x20 to the
            // actual end of the _preBytes data.
            mc := end
            // Stop copying when the memory counter reaches the new combined
            // length of the arrays.
            end := add(mc, length)

            for { let cc := add(_postBytes, 0x20) } lt(mc, end) {
                mc := add(mc, 0x20)
                cc := add(cc, 0x20)
            } { mstore(mc, mload(cc)) }

            // Update the free-memory pointer by padding our last write location
            // to 32 bytes: add 31 bytes to the end of tempBytes to move to the
            // next 32 byte block, then round down to the nearest multiple of
            // 32. If the sum of the length of the two arrays is zero then add
            // one before rounding down to leave a blank 32 bytes (the length block with 0).
            mstore(
                0x40,
                and(
                    add(add(end, iszero(add(length, mload(_preBytes)))), 31),
                    not(31) // Round down to the nearest 32 bytes.
                )
            )
        }

        return tempBytes;
    }

    function concatStorage(bytes storage _preBytes, bytes memory _postBytes) internal {
        assembly {
            // Read the first 32 bytes of _preBytes storage, which is the length
            // of the array. (We don't need to use the offset into the slot
            // because arrays use the entire slot.)
            let fslot := sload(_preBytes.slot)
            // Arrays of 31 bytes or less have an even value in their slot,
            // while longer arrays have an odd value. The actual length is
            // the slot divided by two for odd values, and the lowest order
            // byte divided by two for even values.
            // If the slot is even, bitwise and the slot with 255 and divide by
            // two to get the length. If the slot is odd, bitwise and the slot
            // with -1 and divide by two.
            let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
            let mlength := mload(_postBytes)
            let newlength := add(slength, mlength)
            // slength can contain both the length and contents of the array
            // if length < 32 bytes so let's prepare for that
            // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
            switch add(lt(slength, 32), lt(newlength, 32))
            case 2 {
                // Since the new array still fits in the slot, we just need to
                // update the contents of the slot.
                // uint256(bytes_storage) = uint256(bytes_storage) + uint256(bytes_memory) + new_length
                sstore(
                    _preBytes.slot,
                    // all the modifications to the slot are inside this
                    // next block
                    add(
                        // we can just add to the slot contents because the
                        // bytes we want to change are the LSBs
                        fslot,
                        add(
                            mul(
                                div(
                                    // load the bytes from memory
                                    mload(add(_postBytes, 0x20)),
                                    // zero all bytes to the right
                                    exp(0x100, sub(32, mlength))
                                ),
                                // and now shift left the number of bytes to
                                // leave space for the length in the slot
                                exp(0x100, sub(32, newlength))
                            ),
                            // increase length by the double of the memory
                            // bytes length
                            mul(mlength, 2)
                        )
                    )
                )
            }
            case 1 {
                // The stored value fits in the slot, but the combined value
                // will exceed it.
                // get the keccak hash to get the contents of the array
                mstore(0x0, _preBytes.slot)
                let sc := add(keccak256(0x0, 0x20), div(slength, 32))

                // save new length
                sstore(_preBytes.slot, add(mul(newlength, 2), 1))

                // The contents of the _postBytes array start 32 bytes into
                // the structure. Our first read should obtain the `submod`
                // bytes that can fit into the unused space in the last word
                // of the stored array. To get this, we read 32 bytes starting
                // from `submod`, so the data we read overlaps with the array
                // contents by `submod` bytes. Masking the lowest-order
                // `submod` bytes allows us to add that value directly to the
                // stored value.

                let submod := sub(32, slength)
                let mc := add(_postBytes, submod)
                let end := add(_postBytes, mlength)
                let mask := sub(exp(0x100, submod), 1)

                sstore(
                    sc,
                    add(
                        and(fslot, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00),
                        and(mload(mc), mask)
                    )
                )

                for {
                    mc := add(mc, 0x20)
                    sc := add(sc, 1)
                } lt(mc, end) {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } { sstore(sc, mload(mc)) }

                mask := exp(0x100, sub(mc, end))

                sstore(sc, mul(div(mload(mc), mask), mask))
            }
            default {
                // get the keccak hash to get the contents of the array
                mstore(0x0, _preBytes.slot)
                // Start copying to the last used word of the stored array.
                let sc := add(keccak256(0x0, 0x20), div(slength, 32))

                // save new length
                sstore(_preBytes.slot, add(mul(newlength, 2), 1))

                // Copy over the first `submod` bytes of the new data as in
                // case 1 above.
                let slengthmod := mod(slength, 32)
                let mlengthmod := mod(mlength, 32)
                let submod := sub(32, slengthmod)
                let mc := add(_postBytes, submod)
                let end := add(_postBytes, mlength)
                let mask := sub(exp(0x100, submod), 1)

                sstore(sc, add(sload(sc), and(mload(mc), mask)))

                for {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } lt(mc, end) {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } { sstore(sc, mload(mc)) }

                mask := exp(0x100, sub(mc, end))

                sstore(sc, mul(div(mload(mc), mask), mask))
            }
        }
    }

    function slice(bytes memory _bytes, uint256 _start, uint256 _length) internal pure returns (bytes memory) {
        // We're using the unchecked block below because otherwise execution ends
        // with the native overflow error code.
        unchecked {
            require(_length + 31 >= _length, "slice_overflow");
        }
        require(_bytes.length >= _start + _length, "slice_outOfBounds");

        bytes memory tempBytes;

        assembly {
            switch iszero(_length)
            case 0 {
                // Get a location of some free memory and store it in tempBytes as
                // Solidity does for memory variables.
                tempBytes := mload(0x40)

                // The first word of the slice result is potentially a partial
                // word read from the original array. To read it, we calculate
                // the length of that partial word and start copying that many
                // bytes into the array. The first word we copy will start with
                // data we don't care about, but the last `lengthmod` bytes will
                // land at the beginning of the contents of the new array. When
                // we're done copying, we overwrite the full first word with
                // the actual length of the slice.
                let lengthmod := and(_length, 31)

                // The multiplication in the next line is necessary
                // because when slicing multiples of 32 bytes (lengthmod == 0)
                // the following copy loop was copying the origin's length
                // and then ending prematurely not copying everything it should.
                let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
                let end := add(mc, _length)

                for {
                    // The multiplication in the next line has the same exact purpose
                    // as the one above.
                    let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)
                } lt(mc, end) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } { mstore(mc, mload(cc)) }

                mstore(tempBytes, _length)

                //update free-memory pointer
                //allocating the array padded to 32 bytes like the compiler does now
                mstore(0x40, and(add(mc, 31), not(31)))
            }
            //if we want a zero-length slice let's just return a zero-length array
            default {
                tempBytes := mload(0x40)
                //zero out the 32 bytes slice we are about to return
                //we need to do it because Solidity does not garbage collect
                mstore(tempBytes, 0)

                mstore(0x40, add(tempBytes, 0x20))
            }
        }

        return tempBytes;
    }

    function toAddress(bytes memory _bytes, uint256 _start) internal pure returns (address) {
        require(_bytes.length >= _start + 20, "toAddress_outOfBounds");
        address tempAddress;

        assembly {
            tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)
        }

        return tempAddress;
    }

    function toUint8(bytes memory _bytes, uint256 _start) internal pure returns (uint8) {
        require(_bytes.length >= _start + 1, "toUint8_outOfBounds");
        uint8 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x1), _start))
        }

        return tempUint;
    }

    function toUint16(bytes memory _bytes, uint256 _start) internal pure returns (uint16) {
        require(_bytes.length >= _start + 2, "toUint16_outOfBounds");
        uint16 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x2), _start))
        }

        return tempUint;
    }

    function toUint32(bytes memory _bytes, uint256 _start) internal pure returns (uint32) {
        require(_bytes.length >= _start + 4, "toUint32_outOfBounds");
        uint32 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x4), _start))
        }

        return tempUint;
    }

    function toUint64(bytes memory _bytes, uint256 _start) internal pure returns (uint64) {
        require(_bytes.length >= _start + 8, "toUint64_outOfBounds");
        uint64 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x8), _start))
        }

        return tempUint;
    }

    function toUint96(bytes memory _bytes, uint256 _start) internal pure returns (uint96) {
        require(_bytes.length >= _start + 12, "toUint96_outOfBounds");
        uint96 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0xc), _start))
        }

        return tempUint;
    }

    function toUint128(bytes memory _bytes, uint256 _start) internal pure returns (uint128) {
        require(_bytes.length >= _start + 16, "toUint128_outOfBounds");
        uint128 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x10), _start))
        }

        return tempUint;
    }

    function toUint256(bytes memory _bytes, uint256 _start) internal pure returns (uint256) {
        require(_bytes.length >= _start + 32, "toUint256_outOfBounds");
        uint256 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x20), _start))
        }

        return tempUint;
    }

    function toBytes32(bytes memory _bytes, uint256 _start) internal pure returns (bytes32) {
        require(_bytes.length >= _start + 32, "toBytes32_outOfBounds");
        bytes32 tempBytes32;

        assembly {
            tempBytes32 := mload(add(add(_bytes, 0x20), _start))
        }

        return tempBytes32;
    }

    function equal(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bool) {
        bool success = true;

        assembly {
            let length := mload(_preBytes)

            // if lengths don't match the arrays are not equal
            switch eq(length, mload(_postBytes))
            case 1 {
                // cb is a circuit breaker in the for loop since there's
                //  no said feature for inline assembly loops
                // cb = 1 - don't breaker
                // cb = 0 - break
                let cb := 1

                let mc := add(_preBytes, 0x20)
                let end := add(mc, length)

                for { let cc := add(_postBytes, 0x20) }
                // the next line is the loop condition:
                // while(uint256(mc < end) + cb == 2)
                eq(add(lt(mc, end), cb), 2) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    // if any of these checks fails then arrays are not equal
                    if iszero(eq(mload(mc), mload(cc))) {
                        // unsuccess:
                        success := 0
                        cb := 0
                    }
                }
            }
            default {
                // unsuccess:
                success := 0
            }
        }

        return success;
    }

    function equalStorage(bytes storage _preBytes, bytes memory _postBytes) internal view returns (bool) {
        bool success = true;

        assembly {
            // we know _preBytes_offset is 0
            let fslot := sload(_preBytes.slot)
            // Decode the length of the stored array like in concatStorage().
            let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
            let mlength := mload(_postBytes)

            // if lengths don't match the arrays are not equal
            switch eq(slength, mlength)
            case 1 {
                // slength can contain both the length and contents of the array
                // if length < 32 bytes so let's prepare for that
                // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
                if iszero(iszero(slength)) {
                    switch lt(slength, 32)
                    case 1 {
                        // blank the last byte which is the length
                        fslot := mul(div(fslot, 0x100), 0x100)

                        if iszero(eq(fslot, mload(add(_postBytes, 0x20)))) {
                            // unsuccess:
                            success := 0
                        }
                    }
                    default {
                        // cb is a circuit breaker in the for loop since there's
                        //  no said feature for inline assembly loops
                        // cb = 1 - don't breaker
                        // cb = 0 - break
                        let cb := 1

                        // get the keccak hash to get the contents of the array
                        mstore(0x0, _preBytes.slot)
                        let sc := keccak256(0x0, 0x20)

                        let mc := add(_postBytes, 0x20)
                        let end := add(mc, mlength)

                        // the next line is the loop condition:
                        // while(uint256(mc < end) + cb == 2)
                        for { } eq(add(lt(mc, end), cb), 2) {
                            sc := add(sc, 1)
                            mc := add(mc, 0x20)
                        } {
                            if iszero(eq(sload(sc), mload(mc))) {
                                // unsuccess:
                                success := 0
                                cb := 0
                            }
                        }
                    }
                }
            }
            default {
                // unsuccess:
                success := 0
            }
        }

        return success;
    }
}


0.0% lib/v2-core/src/vendor/awesome-oracles/IOracle.sol

Lines covered: 0 / 0 (0.0%)

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

/// @title Common interface for price oracles.
/// @dev Implements the spec at https://eips.ethereum.org/EIPS/eip-7726
interface IOracle {
    /// @notice The oracle does not support the given base/quote pair.
    /// @param base The asset that the user needs to know the value or price for.
    /// @param quote The asset in which the user needs to value or price the base.
    error OracleUnsupportedPair(address base, address quote);

    /// @notice The oracle is not capable to provide data within a degree of confidence.
    /// @param base The asset that the user needs to know the value or price for.
    /// @param quote The asset in which the user needs to value or price the base.
    error OracleUntrustedData(address base, address quote);

    /// @notice Returns the value of `baseAmount` of `base` in `quote` terms.
    /// @dev MUST round down towards 0.
    /// MUST revert with `OracleUnsupportedPair` if not capable to provide data for the specified `base` and `quote`
    /// pair.
    /// MUST revert with `OracleUntrustedData` if not capable to provide data within a degree of confidence publicly
    /// specified.
    /// @param baseAmount The amount of `base` to convert.
    /// @param base The asset that the user needs to know the value for.
    /// @param quote The asset in which the user needs to value the base.
    /// @return quoteAmount The value of `baseAmount` of `base` in `quote` terms
    function getQuote(uint256 baseAmount, address base, address quote) external view returns (uint256 quoteAmount);
}


0.0% lib/v2-core/src/vendor/pendle/IStandardizedYield.sol

Lines covered: 0 / 0 (0.0%)

// SPDX-License-Identifier: GPL-3.0-or-later
/*
 * MIT License
 * ===========
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 */

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";

interface IStandardizedYield is IERC20Metadata {
    /// @dev Emitted when any base tokens is deposited to mint shares
    event Deposit(
        address indexed caller,
        address indexed receiver,
        address indexed tokenIn,
        uint256 amountDeposited,
        uint256 amountSyOut
    );

    /// @dev Emitted when any shares are redeemed for base tokens
    event Redeem(
        address indexed caller,
        address indexed receiver,
        address indexed tokenOut,
        uint256 amountSyToRedeem,
        uint256 amountTokenOut
    );

    /// @dev check `assetInfo()` for more information
    enum AssetType {
        TOKEN,
        LIQUIDITY
    }

    /// @dev Emitted when (`user`) claims their rewards
    event ClaimRewards(address indexed user, address[] rewardTokens, uint256[] rewardAmounts);

    /**
     * @notice mints an amount of shares by depositing a base token.
     * @param receiver shares recipient address
     * @param tokenIn address of the base tokens to mint shares
     * @param amountTokenToDeposit amount of base tokens to be transferred from (`msg.sender`)
     * @param minSharesOut reverts if amount of shares minted is lower than this
     * @return amountSharesOut amount of shares minted
     * @dev Emits a {Deposit} event
     *
     * Requirements:
     * - (`tokenIn`) must be a valid base token.
     */
    function deposit(
        address receiver,
        address tokenIn,
        uint256 amountTokenToDeposit,
        uint256 minSharesOut
    )
        external
        payable
        returns (uint256 amountSharesOut);

    /**
     * @notice redeems an amount of base tokens by burning some shares
     * @param receiver recipient address
     * @param amountSharesToRedeem amount of shares to be burned
     * @param tokenOut address of the base token to be redeemed
     * @param minTokenOut reverts if amount of base token redeemed is lower than this
     * @param burnFromInternalBalance if true, burns from balance of `address(this)`, otherwise burns from `msg.sender`
     * @return amountTokenOut amount of base tokens redeemed
     * @dev Emits a {Redeem} event
     *
     * Requirements:
     * - (`tokenOut`) must be a valid base token.
     */
    function redeem(
        address receiver,
        uint256 amountSharesToRedeem,
        address tokenOut,
        uint256 minTokenOut,
        bool burnFromInternalBalance
    )
        external
        returns (uint256 amountTokenOut);

    /**
     * @notice exchangeRate * syBalance / 1e18 must return the asset balance of the account
     * @notice vice-versa, if a user uses some amount of tokens equivalent to X asset, the amount of sy
     *  he can mint must be X * exchangeRate / 1e18
     * @dev SYUtils's assetToSy & syToAsset should be used instead of raw multiplication
     *  & division
     */
    function exchangeRate() external view returns (uint256 res);

    /**
     * @notice claims reward for (`user`)
     * @param user the user receiving their rewards
     * @return rewardAmounts an array of reward amounts in the same order as `getRewardTokens`
     * @dev
     * Emits a `ClaimRewards` event
     * See {getRewardTokens} for list of reward tokens
     */
    function claimRewards(address user) external returns (uint256[] memory rewardAmounts);

    /**
     * @notice get the amount of unclaimed rewards for (`user`)
     * @param user the user to check for
     * @return rewardAmounts an array of reward amounts in the same order as `getRewardTokens`
     */
    function accruedRewards(address user) external view returns (uint256[] memory rewardAmounts);

    function rewardIndexesCurrent() external returns (uint256[] memory indexes);

    function rewardIndexesStored() external view returns (uint256[] memory indexes);

    /**
     * @notice returns the list of reward token addresses
     */
    function getRewardTokens() external view returns (address[] memory);

    /**
     * @notice returns the address of the underlying yield token
     */
    function yieldToken() external view returns (address);

    /**
     * @notice returns all tokens that can mint this SY
     */
    function getTokensIn() external view returns (address[] memory res);

    /**
     * @notice returns all tokens that can be redeemed by this SY
     */
    function getTokensOut() external view returns (address[] memory res);

    function isValidTokenIn(address token) external view returns (bool);

    function isValidTokenOut(address token) external view returns (bool);

    function previewDeposit(
        address tokenIn,
        uint256 amountTokenToDeposit
    )
        external
        view
        returns (uint256 amountSharesOut);

    function previewRedeem(
        address tokenOut,
        uint256 amountSharesToRedeem
    )
        external
        view
        returns (uint256 amountTokenOut);

    /**
     * @notice This function contains information to interpret what the asset is
     * @return assetType the type of the asset (0 for ERC20 tokens, 1 for AMM liquidity tokens,
     *     2 for bridged yield bearing tokens like wstETH, rETH on Arbi whose the underlying asset doesn't exist on the
     * chain)
     * @return assetAddress the address of the asset
     * @return assetDecimals the decimals of the asset
     */
    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals);
}


0.0% lib/v2-core/src/vendor/standards/ERC7540/IERC7540Vault.sol

Lines covered: 0 / 0 (0.0%)

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

import { IERC7741 } from "../ERC7741/IERC7741.sol";

interface IERC7540Operator {
    /**
     * @dev The event emitted when an operator is set.
     *
     * @param controller The address of the controller.
     * @param operator The address of the operator.
     * @param approved The approval status.
     */
    event OperatorSet(address indexed controller, address indexed operator, bool approved);

    /**
     * @dev Sets or removes an operator for the caller.
     *
     * @param operator The address of the operator.
     * @param approved The approval status.
     * @return Whether the call was executed successfully or not
     */
    function setOperator(address operator, bool approved) external returns (bool);

    /**
     * @dev Returns `true` if the `operator` is approved as an operator for an `controller`.
     *
     * @param controller The address of the controller.
     * @param operator The address of the operator.
     * @return status The approval status
     */
    function isOperator(address controller, address operator) external view returns (bool status);
}

interface IERC7540Deposit is IERC7540Operator {
    event DepositRequest(
        address indexed controller, address indexed owner, uint256 indexed requestId, address sender, uint256 assets
    );
    /**
     * @dev Transfers assets from sender into the Vault and submits a Request for asynchronous deposit.
     *
     * - MUST support ERC-20 approve / transferFrom on asset as a deposit Request flow.
     * - MUST revert if all of assets cannot be requested for deposit.
     * - owner MUST be msg.sender unless some unspecified explicit approval is given by the caller,
     *    approval of ERC-20 tokens from owner to sender is NOT enough.
     *
     * @param assets the amount of deposit assets to transfer from owner
     * @param controller the controller of the request who will be able to operate the request
     * @param owner the source of the deposit assets
     *
     * NOTE: most implementations will require pre-approval of the Vault with the Vault's underlying asset token.
     */

    function requestDeposit(uint256 assets, address controller, address owner) external returns (uint256 requestId);

    /**
     * @dev Returns the amount of requested assets in Pending state.
     *
     * - MUST NOT include any assets in Claimable state for deposit or mint.
     * - MUST NOT show any variations depending on the caller.
     * - MUST NOT revert unless due to integer overflow caused by an unreasonably large input.
     */
    function pendingDepositRequest(
        uint256 requestId,
        address controller
    )
        external
        view
        returns (uint256 pendingAssets);

    /**
     * @dev Returns the amount of requested assets in Claimable state for the controller to deposit or mint.
     *
     * - MUST NOT include any assets in Pending state.
     * - MUST NOT show any variations depending on the caller.
     * - MUST NOT revert unless due to integer overflow caused by an unreasonably large input.
     */
    function claimableDepositRequest(
        uint256 requestId,
        address controller
    )
        external
        view
        returns (uint256 claimableAssets);

    /**
     * @dev Mints shares Vault shares to receiver by claiming the Request of the controller.
     *
     * - MUST emit the Deposit event.
     * - controller MUST equal msg.sender unless the controller has approved the msg.sender as an operator.
     */
    function deposit(uint256 assets, address receiver, address controller) external returns (uint256 shares);

    /**
     * @dev Mints exactly shares Vault shares to receiver by claiming the Request of the controller.
     *
     * - MUST emit the Deposit event.
     * - controller MUST equal msg.sender unless the controller has approved the msg.sender as an operator.
     */
    function mint(uint256 shares, address receiver, address controller) external returns (uint256 assets);
}

interface IERC7540Redeem is IERC7540Operator {
    event RedeemRequest(
        address indexed controller, address indexed owner, uint256 indexed requestId, address sender, uint256 assets
    );

    /**
     * @dev Assumes control of shares from sender into the Vault and submits a Request for asynchronous redeem.
     *
     * - MUST support a redeem Request flow where the control of shares is taken from sender directly
     *   where msg.sender has ERC-20 approval over the shares of owner.
     * - MUST revert if all of shares cannot be requested for redeem.
     *
     * @param shares the amount of shares to be redeemed to transfer from owner
     * @param controller the controller of the request who will be able to operate the request
     * @param owner the source of the shares to be redeemed
     *
     * NOTE: most implementations will require pre-approval of the Vault with the Vault's share token.
     */
    function requestRedeem(uint256 shares, address controller, address owner) external returns (uint256 requestId);

    /**
     * @dev Returns the amount of requested shares in Pending state.
     *
     * - MUST NOT include any shares in Claimable state for redeem or withdraw.
     * - MUST NOT show any variations depending on the caller.
     * - MUST NOT revert unless due to integer overflow caused by an unreasonably large input.
     */
    function pendingRedeemRequest(
        uint256 requestId,
        address controller
    )
        external
        view
        returns (uint256 pendingShares);

    /**
     * @dev Returns the amount of requested shares in Claimable state for the controller to redeem or withdraw.
     *
     * - MUST NOT include any shares in Pending state for redeem or withdraw.
     * - MUST NOT show any variations depending on the caller.
     * - MUST NOT revert unless due to integer overflow caused by an unreasonably large input.
     */
    function claimableRedeemRequest(
        uint256 requestId,
        address controller
    )
        external
        view
        returns (uint256 claimableShares);
}

interface IERC7540CancelDeposit {
    event CancelDepositRequest(address indexed controller, uint256 indexed requestId, address sender);
    event CancelDepositClaim(
        address indexed receiver, address indexed controller, uint256 indexed requestId, address sender, uint256 assets
    );

    /**
     * @dev Submits a Request for cancelling the pending deposit Request
     *
     * - controller MUST be msg.sender unless some unspecified explicit approval is given by the caller,
     *    approval of ERC-20 tokens from controller to sender is NOT enough.
     * - MUST set pendingCancelDepositRequest to `true` for the returned requestId after request
     * - MUST increase claimableCancelDepositRequest for the returned requestId after fulfillment
     * - SHOULD be claimable using `claimCancelDepositRequest`
     * Note: while `pendingCancelDepositRequest` is `true`, `requestDeposit` cannot be called
     */
    function cancelDepositRequest(uint256 requestId, address controller) external;

    /**
     * @dev Returns whether the deposit Request is pending cancelation
     *
     * - MUST NOT show any variations depending on the caller.
     */
    function pendingCancelDepositRequest(
        uint256 requestId,
        address controller
    )
        external
        view
        returns (bool isPending);

    /**
     * @dev Returns the amount of assets that were canceled from a deposit Request, and can now be claimed.
     *
     * - MUST NOT show any variations depending on the caller.
     */
    function claimableCancelDepositRequest(
        uint256 requestId,
        address controller
    )
        external
        view
        returns (uint256 claimableAssets);

    /**
     * @dev Claims the canceled deposit assets, and removes the pending cancelation Request
     *
     * - controller MUST be msg.sender unless some unspecified explicit approval is given by the caller,
     *    approval of ERC-20 tokens from controller to sender is NOT enough.
     * - MUST set pendingCancelDepositRequest to `false` for the returned requestId after request
     * - MUST set claimableCancelDepositRequest to 0 for the returned requestId after fulfillment
     */
    function claimCancelDepositRequest(
        uint256 requestId,
        address receiver,
        address controller
    )
        external
        returns (uint256 assets);
}

interface IERC7540CancelRedeem {
    event CancelRedeemRequest(address indexed controller, uint256 indexed requestId, address sender);
    event CancelRedeemClaim(
        address indexed receiver, address indexed controller, uint256 indexed requestId, address sender, uint256 shares
    );

    /**
     * @dev Submits a Request for cancelling the pending redeem Request
     *
     * - controller MUST be msg.sender unless some unspecified explicit approval is given by the caller,
     *    approval of ERC-20 tokens from controller to sender is NOT enough.
     * - MUST set pendingCancelRedeemRequest to `true` for the returned requestId after request
     * - MUST increase claimableCancelRedeemRequest for the returned requestId after fulfillment
     * - SHOULD be claimable using `claimCancelRedeemRequest`
     * Note: while `pendingCancelRedeemRequest` is `true`, `requestRedeem` cannot be called
     */
    function cancelRedeemRequest(uint256 requestId, address controller) external;

    /**
     * @dev Returns whether the redeem Request is pending cancelation
     *
     * - MUST NOT show any variations depending on the caller.
     */
    function pendingCancelRedeemRequest(uint256 requestId, address controller) external view returns (bool isPending);

    /**
     * @dev Returns the amount of shares that were canceled from a redeem Request, and can now be claimed.
     *
     * - MUST NOT show any variations depending on the caller.
     */
    function claimableCancelRedeemRequest(
        uint256 requestId,
        address controller
    )
        external
        view
        returns (uint256 claimableShares);

    /**
     * @dev Claims the canceled redeem shares, and removes the pending cancelation Request
     *
     * - controller MUST be msg.sender unless some unspecified explicit approval is given by the caller,
     *    approval of ERC-20 tokens from controller to sender is NOT enough.
     * - MUST set pendingCancelRedeemRequest to `false` for the returned requestId after request
     * - MUST set claimableCancelRedeemRequest to 0 for the returned requestId after fulfillment
     */
    function claimCancelRedeemRequest(
        uint256 requestId,
        address receiver,
        address controller
    )
        external
        returns (uint256 shares);
}

/**
 * @title  IERC7540
 * @dev    Fully async ERC7540 implementation according to the standard
 * @dev    Adapted from Centrifuge's IERC7540 implementation
 */
interface IERC7540 is IERC7540Deposit, IERC7540Redeem { }

/**
 * @title  IERC7540Vault
 * @dev    This is the specific set of interfaces used by the SuperVaults
 */
interface IERC7540Vault is IERC7540, IERC7741 {
    event DepositClaimable(address indexed controller, uint256 indexed requestId, uint256 assets, uint256 shares);
    event RedeemClaimable(address indexed controller, uint256 indexed requestId, uint256 assets, uint256 shares);
}


0.0% lib/v2-core/src/vendor/standards/ERC7741/IERC7741.sol

Lines covered: 0 / 0 (0.0%)

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

interface IERC7741 {
    /**
     * @dev Grants or revokes permissions for `operator` to manage Requests on behalf of the
     *      `msg.sender`, using an [EIP-712](./eip-712.md) signature.
     */
    function authorizeOperator(
        address controller,
        address operator,
        bool approved,
        bytes32 nonce,
        uint256 deadline,
        bytes memory signature
    )
        external
        returns (bool);

    /**
     * @dev Revokes the given `nonce` for `msg.sender` as the `owner`.
     */
    function invalidateNonce(bytes32 nonce) external;

    /**
     * @dev Returns whether the given `nonce` has been used for the `controller`.
     */
    function authorizations(address controller, bytes32 nonce) external view returns (bool used);

    /**
     * @dev Returns the `DOMAIN_SEPARATOR` as defined according to EIP-712. The `DOMAIN_SEPARATOR
     *      should be unique to the contract and chain to prevent replay attacks from other domains,
     *      and satisfy the requirements of EIP-712, but is otherwise unconstrained.
     */
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}


0.0% lib/v2-core/src/vendor/superform/ISuperVault.sol

Lines covered: 0 / 0 (0.0%)

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.30;

/// @title ISuperVault
/// @notice Interface for SuperVault core contract that manages share minting
/// @author Superform Labs
interface ISuperVault {
    /*//////////////////////////////////////////////////////////////
                                ERRORS
    //////////////////////////////////////////////////////////////*/
    error ALREADY_INITIALIZED();
    error INVALID_ASSET();
    error INVALID_STRATEGY();
    error INVALID_ESCROW();
    error ZERO_ADDRESS();
    error ZERO_AMOUNT();
    error INVALID_OWNER_OR_OPERATOR();
    error INVALID_AMOUNT();
    error REQUEST_NOT_FOUND();
    error UNAUTHORIZED();
    error TIMELOCK_NOT_EXPIRED();
    error INVALID_SIGNATURE();
    error NOT_IMPLEMENTED();
    error INVALID_NONCE();
    error INVALID_WITHDRAW_PRICE();
    error TRANSFER_FAILED();
    error CAP_EXCEEDED();
    error INVALID_PPS();
    error INVALID_CONTROLLER();

    /*//////////////////////////////////////////////////////////////
                                EVENTS
    //////////////////////////////////////////////////////////////*/

    event RedeemClaimable(
        address indexed user,
        uint256 indexed requestId,
        uint256 assets,
        uint256 shares,
        uint256 averageWithdrawPrice,
        uint256 accumulatorShares,
        uint256 accumulatorCostBasis
    );

    event NonceInvalidated(address indexed sender, bytes32 indexed nonce);

    event RedeemRequestCancelled(address indexed controller, address indexed sender);

    /*//////////////////////////////////////////////////////////////
                            EXTERNAL METHODS
    //////////////////////////////////////////////////////////////*/

    function cancelRedeem(address controller) external;

    /// @notice Mint new shares, only callable by strategy
    /// @param amount The amount of shares to mint
    function mintShares(uint256 amount) external;

    /// @notice Burn shares, only callable by strategy
    /// @param amount The amount of shares to burn
    function burnShares(uint256 amount) external;

    /// @notice Callback function for when a redeem becomes claimable
    /// @param user The user whose redeem is claimable
    /// @param assets The amount of assets to be received
    /// @param shares The amount of shares redeemed
    /// @param averageWithdrawPrice The average price of the redeem
    /// @param accumulatorShares The amount of shares in the accumulator
    /// @param accumulatorCostBasis The cost basis of the accumulator
    function onRedeemClaimable(
        address user,
        uint256 assets,
        uint256 shares,
        uint256 averageWithdrawPrice,
        uint256 accumulatorShares,
        uint256 accumulatorCostBasis
    )
        external;
}


0.0% lib/v2-core/src/vendor/vaults/7540/IERC7540.sol

Lines covered: 0 / 0 (0.0%)

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.30;

interface IERC7575 {
    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 address of the share token
     *
     * - MUST be an ERC-20 token contract.
     * - MUST NOT revert.
     */
    function share() external view returns (address shareTokenAddress);

    /**
     * @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 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 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);
}
// As defined by https://eips.ethereum.org/EIPS/eip-7540#request-flows

interface IERC7540 is IERC7575 {
    event DepositRequest(
        address indexed controller, address indexed owner, uint256 indexed requestId, address sender, uint256 assets
    );

    event RedeemRequest(
        address indexed controller, address indexed owner, uint256 indexed requestId, address sender, uint256 assets
    );

    /*//////////////////////////////////////////////////////////////
                                 VIEW METHODS
    //////////////////////////////////////////////////////////////*/
    /// @notice Check if the contract supports an interface
    /// @param interfaceId The selector of the interface to check
    function supportsInterface(bytes4 interfaceId) external view returns (bool);

    /// @notice Preview the amount of assets that would be received for a given amount of shares
    /// @param shares The amount of shares to redeem
    function previewRedeem(uint256 shares) external view returns (uint256 assets);

    /// @notice Check if a deposit request is pending
    /// @param requestId The id of the request to check
    /// @param controller The address of the controller
    function pendingDepositRequest(uint256 requestId, address controller) external view returns (uint256);

    /// @notice Check if a deposit request is pending cancellation
    /// @param requestId The id of the request to check
    /// @param controller The address of the controller
    function pendingCancelDepositRequest(uint256 requestId, address controller) external view returns (bool);

    /// @notice Check if a redeem request is pending
    /// @param requestId The id of the request to check
    /// @param controller The address of the controller
    function pendingRedeemRequest(uint256 requestId, address controller) external view returns (uint256);

    /// @notice Get the amount of assets that can be claimed from a deposit request
    /// @param requestId The id of the request to check
    /// @param controller The address of the controller
    function claimableDepositRequest(uint256 requestId, address controller) external view returns (uint256);

    /// @notice Get the amount of shares that can be claimed from a redeem request
    /// @param requestId The id of the request to check
    /// @param controller The address of the controller
    function claimableRedeemRequest(uint256 requestId, address controller) external view returns (uint256);

    /// @notice Check if a redeem request is pending cancellation
    /// @param requestId The id of the request to check
    /// @param controller The address of the controller
    function pendingCancelRedeemRequest(uint256 requestId, address controller) external view returns (bool);

    /*//////////////////////////////////////////////////////////////
                                 EXTERNAL METHODS
    //////////////////////////////////////////////////////////////*/
    /// @notice Mints amount of shares by claiming the controller's request
    /// @dev sender must be the controller or an operator approved by the controller
    /// @param assets The amount of assets to deposit
    /// @param receiver The address of the receiver
    /// @param controller The address of the controller
    function deposit(uint256 assets, address receiver, address controller) external returns (uint256 shares);

    /// @notice Mint exact amount of shares into the vault by claiming the controller's request
    /// @param shares The amount of shares to mint
    /// @param receiver The address of the receiver
    /// @param controller The address of the controller
    function mint(uint256 shares, address receiver, address controller) external returns (uint256 assets);

    /// @notice Burn shares from the vault and sends exact amount of assets to the receiver
    /// @param assets The amount of assets to withdraw
    /// @param receiver The address of the receiver
    /// @param owner The address of the owner
    function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);

    /// @notice Burns exact shares from the vault and sends assets to the receiver
    /// @param shares The amount of shares to redeem
    /// @param receiver The address of the receiver
    /// @param owner The address of the owner
    function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);

    /// @notice Request a deposit of assets
    /// @param assets The amount of assets to deposit
    /// @param controller The address of the controller
    /// @param owner The address of the owner
    function requestDeposit(uint256 assets, address controller, address owner) external returns (uint256 requestId);

    /// @notice Request a redeem of shares
    /// @param shares The amount of shares to redeem
    /// @param controller The address of the controller
    /// @param owner The address of the owner
    function requestRedeem(uint256 shares, address controller, address owner) external returns (uint256 requestId);

    /// @notice Cancel a deposit request
    /// @param requestId The id of the request to cancel
    /// @param controller The address of the controller
    function cancelDepositRequest(uint256 requestId, address controller) external;

    /// @notice Claims the canceled deposit assets, and removes the pending cancelation Request
    /// @dev sender must be the controller
    /// @param requestId The id of the request to claim
    /// @param receiver The address of the receiver
    /// @param controller The address of the controller
    function claimCancelDepositRequest(
        uint256 requestId,
        address receiver,
        address controller
    )
        external
        returns (uint256 assets);

    /// @notice Cancel a redeem request
    /// @param requestId The id of the request to cancel
    /// @param controller The address of the controller
    function cancelRedeemRequest(uint256 requestId, address controller) external;

    /// @notice Claims the canceled redeem shares, and removes the pending cancelation Request
    /// @dev sender must be the controller
    /// @param requestId The id of the request to claim
    /// @param receiver The address of the receiver
    /// @param controller The address of the controller
    function claimCancelRedeemRequest(
        uint256 requestId,
        address receiver,
        address controller
    )
        external
        returns (uint256 shares);

    /// @notice Get the pool id
    function poolId() external view returns (uint64);

    /// @notice Get the tranche id
    function trancheId() external view returns (bytes16);

    /*//////////////////////////////////////////////////////////////
                                 OWNER METHODS
    //////////////////////////////////////////////////////////////*/
    function setOperator(address operator, bool approved) external returns (bool);
    function isOperator(address controller, address operator) external view returns (bool status);
}


33.0% src/SuperGovernor.sol

Lines covered: 155 / 457 (33.0%)

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.30;

// external
import { AccessControl } from "@openzeppelin/contracts/access/AccessControl.sol";
import { EnumerableSet } from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";

// Superform
import { ISuperGovernor, FeeType } from "./interfaces/ISuperGovernor.sol";
import { ISuperVaultAggregator } from "./interfaces/SuperVault/ISuperVaultAggregator.sol";
import { ISuperAssetFactory } from "./interfaces/SuperAsset/ISuperAssetFactory.sol";
import { ISuperOracle } from "./interfaces/oracles/ISuperOracle.sol";
import { ISuperOracleL2 } from "./interfaces/oracles/ISuperOracleL2.sol";

/// @title SuperGovernor
/// @author Superform Labs
/// @notice Central registry for all deployed contracts in the Superform periphery
contract SuperGovernor is ISuperGovernor, AccessControl {
    using EnumerableSet for EnumerableSet.AddressSet;

    /*//////////////////////////////////////////////////////////////
                                 STORAGE
    //////////////////////////////////////////////////////////////*/
    // Address registry
    mapping(bytes32 id => address address_) private _addressRegistry;

    // PPS Oracle management
    // Active PPS Oracle quorum requirement
    uint256 private _activePPSOracleQuorum;
    // Current active PPS Oracle
    address private _activePPSOracle;
    // Proposed new active PPS Oracle
    address private _proposedActivePPSOracle;
    // Effective time for proposed active PPS Oracle change
    uint256 private _activePPSOracleEffectiveTime;

    // Hook registry
    EnumerableSet.AddressSet private _registeredHooks;
    EnumerableSet.AddressSet private _registeredFulfillRequestsHooks;

    // SuperBank Hook Target validation
    mapping(address hook => ISuperGovernor.HookMerkleRootData merkleData) private superBankHooksMerkleRoots;

    // VaultBank registry
    EnumerableSet.AddressSet private _vaultBanks;
    mapping(uint64 chainId => address vaultBank) private _vaultBanksByChainId;

    // VaultBank Hook Target validation
    mapping(address hook => ISuperGovernor.HookMerkleRootData merkleData) private vaultBankHooksMerkleRoots;

    // Global freeze for manager takeovers
    bool private _managerTakeoversFrozen;

    // Validator registry
    EnumerableSet.AddressSet private _validators;

    // Relayer registry
    EnumerableSet.AddressSet private _relayers;

    // Protected keepers registry (cannot be added as authorized callers by managers)
    EnumerableSet.AddressSet private _protectedKeepers;

    // Executor registry
    EnumerableSet.AddressSet private _executors;

    // Polymer prover
    address private _prover;

    // Whitelisted incentive tokens
    mapping(address token => bool isWhitelisted) private _isWhitelistedIncentiveToken;
    EnumerableSet.AddressSet private _proposedWhitelistedIncentiveTokens;
    EnumerableSet.AddressSet private _proposedRemoveWhitelistedIncentiveTokens;
    uint256 private _proposedAddWhitelistedIncentiveTokensEffectiveTime;
    uint256 private _proposedRemoveWhitelistedIncentiveTokensEffectiveTime;

    // Fee management
    // Current fee values
    mapping(FeeType type_ => uint256 value) private _feeValues;
    // Proposed fee values
    mapping(FeeType type_ => uint256 proposedValue) private _proposedFeeValues;
    // Effective times for proposed fee updates
    mapping(FeeType type_ => uint256 effectiveTime) private _feeEffectiveTimes;

    mapping(address _oracle => GasInfo info) private _oracleGasInfo;

    // Upkeep control
    bool private _upkeepPaymentsEnabled;
    bool private _proposedUpkeepPaymentsEnabled;
    uint256 private _upkeepPaymentsChangeEffectiveTime;

    // Superform managers (exempt from upkeep costs)
    EnumerableSet.AddressSet private _superformManagers;

    // Min staleness configuration to prevent maxStaleness from being set too low
    uint256 private _minStaleness;
    uint256 private _proposedMinStaleness;
    uint256 private _minStalenesEffectiveTime;

    // Oracle constants
    address private constant NATIVE_TOKEN = address(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
    address private constant USD_TOKEN = address(840);
    address private constant GAS_QUOTE =
        address(uint160(uint256(keccak256("GAS_QUOTE"))));
    address private constant GWEI_QUOTE =
        address(uint160(uint256(keccak256("GWEI_QUOTE"))));
    bytes32 private constant AVERAGE_PROVIDER = keccak256("AVERAGE_PROVIDER");

    // Timelock configuration
    uint256 private constant TIMELOCK = 7 days;
    uint256 private constant BPS_MAX = 10_000; // 100% in basis points

    // Role definitions
    bytes32 private constant _SUPER_GOVERNOR_ROLE = keccak256("SUPER_GOVERNOR_ROLE");
    bytes32 private constant _GOVERNOR_ROLE = keccak256("GOVERNOR_ROLE");
    bytes32 private constant _BANK_MANAGER_ROLE = keccak256("BANK_MANAGER_ROLE");
    bytes32 private constant _GUARDIAN_ROLE = keccak256("GUARDIAN_ROLE");
    bytes32 private constant _SUPER_ASSET_FACTORY = keccak256("SUPER_ASSET_FACTORY");
    bytes32 private constant _GAS_MANAGER_ROLE = keccak256("GAS_MANAGER_ROLE");

    // Common contract keys
    bytes32 public constant UP = keccak256("UP");
    bytes32 public constant SUP = keccak256("SUP");
    bytes32 public constant TREASURY = keccak256("TREASURY");
    bytes32 public constant VAULT_BANK = keccak256("VAULT_BANK");
    bytes32 public constant SUPER_BANK = keccak256("SUPER_BANK");
    bytes32 public constant SUPER_ORACLE = keccak256("SUPER_ORACLE");
    bytes32 public constant BANK_MANAGER = keccak256("BANK_MANAGER");
    bytes32 public constant ECDSAPPSORACLE = keccak256("ECDSAPPSORACLE");
    bytes32 public constant SUPER_VAULT_AGGREGATOR = keccak256("SUPER_VAULT_AGGREGATOR");

    /*//////////////////////////////////////////////////////////////
                              CONSTRUCTOR
    //////////////////////////////////////////////////////////////*/
    /// @notice Initializes the SuperGovernor contract
    /// @param superGovernor Address of the default admin (will have SUPER_GOVERNOR_ROLE)
    /// @param governor Address that will have the GOVERNOR_ROLE for daily operations
    /// @param bankManager Address that will have the BANK_MANAGER_ROLE for daily operations
    /// @param treasury_ Address of the treasury
    /// @param prover_ Address of the prover
    constructor(address superGovernor, address governor, address bankManager, address gasManager, address treasury_, address prover_) {
        if (
            superGovernor == address(0) || treasury_ == address(0) || governor == address(0)
                || bankManager == address(0) || prover_ == address(0) || gasManager == address(0)
        ) revert INVALID_ADDRESS();

        // Set up roles
        _grantRole(DEFAULT_ADMIN_ROLE, superGovernor);
        _grantRole(_SUPER_GOVERNOR_ROLE, superGovernor);
        _grantRole(_GOVERNOR_ROLE, governor);
        _grantRole(_BANK_MANAGER_ROLE, bankManager);
        _grantRole(_GAS_MANAGER_ROLE, gasManager);
        // Setup GUARDIAN_ROLE without assigning any address
        _setRoleAdmin(_GUARDIAN_ROLE, DEFAULT_ADMIN_ROLE);

        // Set role admins
        _setRoleAdmin(_GOVERNOR_ROLE, DEFAULT_ADMIN_ROLE);
        _setRoleAdmin(_SUPER_GOVERNOR_ROLE, DEFAULT_ADMIN_ROLE);
        _setRoleAdmin(_BANK_MANAGER_ROLE, DEFAULT_ADMIN_ROLE);
        _setRoleAdmin(_GAS_MANAGER_ROLE, DEFAULT_ADMIN_ROLE);

        // Initialize with default fees
        _feeValues[FeeType.REVENUE_SHARE] = 2000; // 20% revenue share
        _feeValues[FeeType.SUPER_VAULT_PERFORMANCE_FEE] = 2000; // 20% performance fee
        _feeValues[FeeType.SUPER_ASSET_SWAP_FEE] = 4000; // 40% swap fee
        emit FeeUpdated(FeeType.REVENUE_SHARE, _feeValues[FeeType.REVENUE_SHARE]);
        emit FeeUpdated(FeeType.SUPER_VAULT_PERFORMANCE_FEE, _feeValues[FeeType.SUPER_VAULT_PERFORMANCE_FEE]);
        emit FeeUpdated(FeeType.SUPER_ASSET_SWAP_FEE, _feeValues[FeeType.SUPER_ASSET_SWAP_FEE]);

        // Set treasury in address registry
        _addressRegistry[TREASURY] = treasury_;
        emit AddressSet(TREASURY, treasury_);

        // Initialize minimum staleness (5 minutes to prevent extremely low staleness values)
        _minStaleness = 300; // 5 minutes in seconds

        // Initialize prover
        _prover = prover_;
        emit ProverSet(prover_);
    }

    /*//////////////////////////////////////////////////////////////
                       CONTRACT REGISTRY FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperGovernor
    function setAddress(bytes32 key, address value) external onlyRole(_SUPER_GOVERNOR_ROLE) {
        if (value == address(0)) revert INVALID_ADDRESS();

        _addressRegistry[key] = value;
        emit AddressSet(key, value);
    }

    /*//////////////////////////////////////////////////////////////
                    PERIPHERY CONFIGURATIONS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperGovernor
    function setProver(address prover) external onlyRole(_SUPER_GOVERNOR_ROLE) {
        if (prover == address(0)) revert INVALID_ADDRESS();

        _prover = prover;
        emit ProverSet(prover);
    }

    /// @inheritdoc ISuperGovernor
    function changePrimaryManager(address strategy, address newManager) external onlyRole(_SUPER_GOVERNOR_ROLE) {
        // Check if takeovers are globally frozen
        if (_managerTakeoversFrozen) revert MANAGER_TAKEOVERS_FROZEN();

        address aggregator = _addressRegistry[SUPER_VAULT_AGGREGATOR];
        if (aggregator == address(0)) revert CONTRACT_NOT_FOUND();

        // Call the interface method to change the manager
        // This function can only be called by the SuperGovernor and bypasses the timelock
        ISuperVaultAggregator(aggregator).changePrimaryManager(strategy, newManager);
    }

    /// @inheritdoc ISuperGovernor
    function freezeManagerTakeover() external onlyRole(_SUPER_GOVERNOR_ROLE) {
        if (_managerTakeoversFrozen) revert MANAGER_TAKEOVERS_FROZEN();

        // Set frozen status to true (permanent, cannot be undone)
        _managerTakeoversFrozen = true;

        // Emit event for the frozen status
        emit ManagerTakeoversFrozen();
    }

    /// @inheritdoc ISuperGovernor
    function changeHooksRootUpdateTimelock(uint256 newTimelock) external onlyRole(_SUPER_GOVERNOR_ROLE) {
        address aggregator = _addressRegistry[SUPER_VAULT_AGGREGATOR];
        if (aggregator == address(0)) revert CONTRACT_NOT_FOUND();

        // Call the SuperVaultAggregator to change the hooks root update timelock
        ISuperVaultAggregator(aggregator).setHooksRootUpdateTimelock(newTimelock);
    }

    /// @inheritdoc ISuperGovernor
    function proposeGlobalHooksRoot(bytes32 newRoot) external onlyRole(_GOVERNOR_ROLE) {
        address aggregator = _addressRegistry[SUPER_VAULT_AGGREGATOR];
        if (aggregator == address(0)) revert CONTRACT_NOT_FOUND();

        ISuperVaultAggregator(aggregator).proposeGlobalHooksRoot(newRoot);
    }

    /// @inheritdoc ISuperGovernor
    function setGlobalHooksRootVetoStatus(bool vetoed) external onlyRole(_GUARDIAN_ROLE) {
        address aggregator = _addressRegistry[SUPER_VAULT_AGGREGATOR];
        if (aggregator == address(0)) revert CONTRACT_NOT_FOUND();

        ISuperVaultAggregator(aggregator).setGlobalHooksRootVetoStatus(vetoed);
    }

    /// @inheritdoc ISuperGovernor
    function setStrategyHooksRootVetoStatus(address strategy, bool vetoed) external onlyRole(_GUARDIAN_ROLE) {
        if (strategy == address(0)) revert INVALID_ADDRESS();

        address aggregator = _addressRegistry[SUPER_VAULT_AGGREGATOR];
        if (aggregator == address(0)) revert CONTRACT_NOT_FOUND();

        ISuperVaultAggregator(aggregator).setStrategyHooksRootVetoStatus(strategy, vetoed);
    }

    /// @inheritdoc ISuperGovernor
    function setSuperAssetManager(address superAsset, address superAssetManager) external onlyRole(_GOVERNOR_ROLE) {
        if (superAsset == address(0) || superAssetManager == address(0)) revert INVALID_ADDRESS();
        address value = _addressRegistry[_SUPER_ASSET_FACTORY];
        if (value == address(0)) revert CONTRACT_NOT_FOUND();
        ISuperAssetFactory factory = ISuperAssetFactory(value);
        factory.setSuperAssetManager(superAsset, superAssetManager);
    }

    /// @inheritdoc ISuperGovernor
    function addICCToWhitelist(address icc) external onlyRole(_SUPER_GOVERNOR_ROLE) {
        if (icc == address(0)) revert INVALID_ADDRESS();
        address value = _addressRegistry[_SUPER_ASSET_FACTORY];
        if (value == address(0)) revert CONTRACT_NOT_FOUND();
        ISuperAssetFactory factory = ISuperAssetFactory(value);
        factory.addICCToWhitelist(icc);
    }

    /// @inheritdoc ISuperGovernor
    function removeICCFromWhitelist(address icc) external onlyRole(_SUPER_GOVERNOR_ROLE) {
        if (icc == address(0)) revert INVALID_ADDRESS();
        address value = _addressRegistry[_SUPER_ASSET_FACTORY];
        if (value == address(0)) revert CONTRACT_NOT_FOUND();
        ISuperAssetFactory factory = ISuperAssetFactory(value);
        factory.removeICCFromWhitelist(icc);
    }

    /// @inheritdoc ISuperGovernor
    function setOracleMaxStaleness(uint256 newMaxStaleness) external onlyRole(_GOVERNOR_ROLE) {
        if (newMaxStaleness < _minStaleness) revert MAX_STALENESS_TOO_LOW();
        address oracle = _addressRegistry[SUPER_ORACLE];
        if (oracle == address(0)) revert CONTRACT_NOT_FOUND();

        ISuperOracle(oracle).setMaxStaleness(newMaxStaleness);
    }

    /// @inheritdoc ISuperGovernor
    function setOracleFeedMaxStaleness(address feed, uint256 newMaxStaleness) external onlyRole(_GOVERNOR_ROLE) {
        if (feed == address(0)) revert INVALID_ADDRESS();
        if (newMaxStaleness < _minStaleness) revert MAX_STALENESS_TOO_LOW();
        address oracle = _addressRegistry[SUPER_ORACLE];
        if (oracle == address(0)) revert CONTRACT_NOT_FOUND();

        ISuperOracle(oracle).setFeedMaxStaleness(feed, newMaxStaleness);
    }

    /// @inheritdoc ISuperGovernor
    function setOracleFeedMaxStalenessBatch(
        address[] calldata feeds_,
        uint256[] calldata newMaxStalenessList_
    )
        external
        onlyRole(_GOVERNOR_ROLE)
    {
        // Validate all staleness values before proceeding
        for (uint256 i; i < newMaxStalenessList_.length; i++) {
            if (newMaxStalenessList_[i] < _minStaleness) revert MAX_STALENESS_TOO_LOW();
        }

        address oracle = _addressRegistry[SUPER_ORACLE];
        if (oracle == address(0)) revert CONTRACT_NOT_FOUND();

        ISuperOracle(oracle).setFeedMaxStalenessBatch(feeds_, newMaxStalenessList_);
    }

    /// @inheritdoc ISuperGovernor
    function queueOracleUpdate(
        address[] calldata bases_,
        address[] calldata quotes_,
        bytes32[] calldata providers_,
        address[] calldata feeds_
    )
        external
        onlyRole(_GOVERNOR_ROLE)
    {
        address oracle = _addressRegistry[SUPER_ORACLE];
        if (oracle == address(0)) revert CONTRACT_NOT_FOUND();

        ISuperOracle(oracle).queueOracleUpdate(bases_, quotes_, providers_, feeds_);
    }

    /// @inheritdoc ISuperGovernor
    function queueOracleProviderRemoval(bytes32[] calldata providers) external onlyRole(_GOVERNOR_ROLE) {
        address oracle = _addressRegistry[SUPER_ORACLE];
        if (oracle == address(0)) revert CONTRACT_NOT_FOUND();

        ISuperOracle(oracle).queueProviderRemoval(providers);
    }

    /// @inheritdoc ISuperGovernor
    function batchSetOracleUptimeFeed(
        address[] calldata dataOracles_,
        address[] calldata uptimeOracles_,
        uint256[] calldata gracePeriods_
    )
        external
        onlyRole(_GOVERNOR_ROLE)
    {
        address oracleL2 = _addressRegistry[SUPER_ORACLE];
        if (oracleL2 == address(0)) revert CONTRACT_NOT_FOUND();

        ISuperOracleL2(oracleL2).batchSetUptimeFeed(dataOracles_, uptimeOracles_, gracePeriods_);
    }

    /// @inheritdoc ISuperGovernor
    function setEmergencyPrice(address token, uint256 price) external onlyRole(_GOVERNOR_ROLE) {
        address oracle = _addressRegistry[SUPER_ORACLE];
        if (oracle == address(0)) revert CONTRACT_NOT_FOUND();

        ISuperOracle(oracle).setEmergencyPrice(token, price);
    }

    /// @inheritdoc ISuperGovernor
    function batchSetEmergencyPrices(
        address[] calldata tokens_,
        uint256[] calldata prices_
    )
        external
        onlyRole(_GOVERNOR_ROLE)
    {
        address oracle = _addressRegistry[SUPER_ORACLE];
        if (oracle == address(0)) revert CONTRACT_NOT_FOUND();

        ISuperOracle(oracle).batchSetEmergencyPrice(tokens_, prices_);
    }

    /*//////////////////////////////////////////////////////////////
                            HOOK MANAGEMENT
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperGovernor
    function registerHook(address hook, bool isFulfillRequestsHook) external onlyRole(_GOVERNOR_ROLE) {
        if (hook == address(0)) revert INVALID_ADDRESS();

        if (isFulfillRequestsHook && _registeredFulfillRequestsHooks.add(hook)) {
            emit FulfillRequestsHookRegistered(hook);
        }
        if (_registeredHooks.add(hook)) {
            emit HookApproved(hook);
        }
    }

    /// @inheritdoc ISuperGovernor
    function unregisterHook(address hook) external onlyRole(_GOVERNOR_ROLE) {
        if (_registeredFulfillRequestsHooks.remove(hook)) {
            emit FulfillRequestsHookUnregistered(hook);
        }
        if (_registeredHooks.remove(hook)) {
            // Clear merkle root data for the unregistered hook to prevent stale data
            delete superBankHooksMerkleRoots[hook];
            delete vaultBankHooksMerkleRoots[hook];

            emit HookRemoved(hook);
        }
    }

    /*//////////////////////////////////////////////////////////////
                        EXECUTORS MANAGEMENT
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperGovernor
    function addExecutor(address executor) external onlyRole(_GOVERNOR_ROLE) {
        if (executor == address(0)) revert INVALID_ADDRESS();
        if (!_executors.add(executor)) revert EXECUTOR_ALREADY_REGISTERED();

        emit ExecutorAdded(executor);
    }

    /// @inheritdoc ISuperGovernor
    function removeExecutor(address executor) external onlyRole(_GOVERNOR_ROLE) {
        if (!_executors.remove(executor)) revert EXECUTOR_NOT_REGISTERED();

        emit ExecutorRemoved(executor);
    }

    /*//////////////////////////////////////////////////////////////
                          RELAYER MANAGEMENT
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperGovernor
    function addRelayer(address relayer) external onlyRole(_GOVERNOR_ROLE) {
        if (relayer == address(0)) revert INVALID_ADDRESS();
        if (!_relayers.add(relayer)) revert RELAYER_ALREADY_REGISTERED();

        emit RelayerAdded(relayer);
    }

    /// @inheritdoc ISuperGovernor
    function removeRelayer(address relayer) external onlyRole(_GOVERNOR_ROLE) {
        if (!_relayers.remove(relayer)) revert RELAYER_NOT_REGISTERED();

        emit RelayerRemoved(relayer);
    }

    /*//////////////////////////////////////////////////////////////
                        VALIDATOR MANAGEMENT
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperGovernor
    function addValidator(address validator) external onlyRole(_GOVERNOR_ROLE) {
        if (validator == address(0)) revert INVALID_ADDRESS();
        if (!_validators.add(validator)) revert VALIDATOR_ALREADY_REGISTERED();

        emit ValidatorAdded(validator);
    }

    /// @inheritdoc ISuperGovernor
    function removeValidator(address validator) external onlyRole(_GOVERNOR_ROLE) {
        if (!_validators.remove(validator)) revert VALIDATOR_NOT_REGISTERED();

        emit ValidatorRemoved(validator);
    }

    /*//////////////////////////////////////////////////////////////
                         PPS ORACLE MANAGEMENT
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperGovernor
    function setActivePPSOracle(address oracle) external onlyRole(_SUPER_GOVERNOR_ROLE) {
        if (oracle == address(0)) revert INVALID_ADDRESS();

        // If this is the first oracle or replacing a zero oracle, set it immediately
        if (_activePPSOracle == address(0)) {
            _activePPSOracle = oracle;
            emit ActivePPSOracleSet(oracle);
        } else {
            // Otherwise require the timelock process
            revert MUST_USE_TIMELOCK_FOR_CHANGE();
        }
    }

    /// @inheritdoc ISuperGovernor
    function proposeActivePPSOracle(address oracle) external onlyRole(_SUPER_GOVERNOR_ROLE) {
        if (oracle == address(0)) revert INVALID_ADDRESS();

        _proposedActivePPSOracle = oracle;
        _activePPSOracleEffectiveTime = block.timestamp + TIMELOCK;

        emit ActivePPSOracleProposed(oracle, _activePPSOracleEffectiveTime);
    }

    /// @inheritdoc ISuperGovernor
    function executeActivePPSOracleChange() external {
        if (_proposedActivePPSOracle == address(0)) revert NO_PROPOSED_PPS_ORACLE();

        if (block.timestamp < _activePPSOracleEffectiveTime) {
            revert TIMELOCK_NOT_EXPIRED();
        }

        address oldOracle = _activePPSOracle;
        _activePPSOracle = _proposedActivePPSOracle;

        // Reset proposal data
        _proposedActivePPSOracle = address(0);
        _activePPSOracleEffectiveTime = 0;

        emit ActivePPSOracleChanged(oldOracle, _activePPSOracle);
    }

    /// @inheritdoc ISuperGovernor
    function setPPSOracleQuorum(uint256 quorum) external onlyRole(_GOVERNOR_ROLE) {
        if (quorum == 0) revert INVALID_QUORUM();

        _activePPSOracleQuorum = quorum;
        emit PPSOracleQuorumUpdated(quorum);
    }

    /*//////////////////////////////////////////////////////////////
                      REVENUE SHARE MANAGEMENT
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperGovernor
    function proposeFee(FeeType feeType, uint256 value) external onlyRole(_SUPER_GOVERNOR_ROLE) {
        if (value > BPS_MAX) revert INVALID_FEE_VALUE();

        _proposedFeeValues[feeType] = value;
        _feeEffectiveTimes[feeType] = block.timestamp + TIMELOCK;

        emit FeeProposed(feeType, value, _feeEffectiveTimes[feeType]);
    }

    /// @inheritdoc ISuperGovernor
    function executeFeeUpdate(FeeType feeType) external {
        uint256 effectiveTime = _feeEffectiveTimes[feeType];
        if (effectiveTime == 0) revert NO_PROPOSED_FEE(feeType);
        if (block.timestamp < effectiveTime) {
            revert TIMELOCK_NOT_EXPIRED();
        }

        // Update the fee value
        _feeValues[feeType] = _proposedFeeValues[feeType];

        // Reset proposal data
        delete _proposedFeeValues[feeType];
        delete _feeEffectiveTimes[feeType];

        emit FeeUpdated(feeType, _feeValues[feeType]);
    }

    /// @inheritdoc ISuperGovernor
    function executeUpkeepClaim(uint256 amount) external onlyRole(_GOVERNOR_ROLE) {
        address aggregator = _addressRegistry[SUPER_VAULT_AGGREGATOR];
        if (aggregator == address(0)) revert CONTRACT_NOT_FOUND();

        ISuperVaultAggregator(aggregator).claimUpkeep(amount);
    }

    /*//////////////////////////////////////////////////////////////
                        UPKEEP COST MANAGEMENT
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperGovernor
    function setGasInfo(address oracle, uint256 baseGasBatch, uint256 gasIncreasePerEntryBatch) external onlyRole(_GAS_MANAGER_ROLE) {
        if (oracle == address(0)) revert INVALID_ADDRESS();
        if (baseGasBatch == 0 || gasIncreasePerEntryBatch == 0) revert INVALID_GAS_INFO();

        _oracleGasInfo[oracle] = GasInfo({baseGasBatch: baseGasBatch, gasIncreasePerEntryBatch: gasIncreasePerEntryBatch});
        emit GasInfoSet(oracle, baseGasBatch, gasIncreasePerEntryBatch);
    }

    /// @notice Proposes a change to the upkeep payments enabled status
    /// @param enabled The proposed new status for upkeep payments
    function proposeUpkeepPaymentsChange(bool enabled) external onlyRole(_SUPER_GOVERNOR_ROLE) {
        _proposedUpkeepPaymentsEnabled = enabled;
        _upkeepPaymentsChangeEffectiveTime = block.timestamp + TIMELOCK;

        emit UpkeepPaymentsChangeProposed(enabled, _upkeepPaymentsChangeEffectiveTime);
    }

    /// @notice Executes a previously proposed change to upkeep payments status after timelock expires
    function executeUpkeepPaymentsChange() external {
        if (_upkeepPaymentsChangeEffectiveTime == 0) revert NO_PENDING_CHANGE();
        if (block.timestamp < _upkeepPaymentsChangeEffectiveTime) revert TIMELOCK_NOT_EXPIRED();

        _upkeepPaymentsEnabled = _proposedUpkeepPaymentsEnabled;
        _upkeepPaymentsChangeEffectiveTime = 0;
        _proposedUpkeepPaymentsEnabled = false;

        emit UpkeepPaymentsChanged(_upkeepPaymentsEnabled);
    }

    /*//////////////////////////////////////////////////////////////
                        MIN STALENESS MANAGEMENT
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperGovernor
    function proposeMinStaleness(uint256 newMinStaleness) external onlyRole(_SUPER_GOVERNOR_ROLE) {
        _proposedMinStaleness = newMinStaleness;
        _minStalenesEffectiveTime = block.timestamp + TIMELOCK;

        emit MinStalenesProposed(newMinStaleness, _minStalenesEffectiveTime);
    }

    /// @inheritdoc ISuperGovernor
    function executeMinStalenesChange() external {
        uint256 minStalenesEffectiveTime = _minStalenesEffectiveTime;
        if (minStalenesEffectiveTime == 0) revert NO_PROPOSED_MIN_STALENESS();
        if (block.timestamp < minStalenesEffectiveTime) revert TIMELOCK_NOT_EXPIRED();

        _minStaleness = _proposedMinStaleness;

        // Reset proposal data
        _proposedMinStaleness = 0;
        _minStalenesEffectiveTime = 0;

        emit MinStalenesChanged(_minStaleness);
    }

    /*//////////////////////////////////////////////////////////////
                      SUPERFORM MANAGER MANAGEMENT
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperGovernor
    function addSuperformManager(address manager) external onlyRole(_GOVERNOR_ROLE) {
        if (manager == address(0)) revert INVALID_ADDRESS();
        if (!_superformManagers.add(manager)) revert MANAGER_ALREADY_REGISTERED();

        emit SuperformManagerAdded(manager);
    }

    /// @inheritdoc ISuperGovernor
    function removeSuperformManager(address manager) external onlyRole(_GOVERNOR_ROLE) {
        if (!_superformManagers.remove(manager)) revert MANAGER_NOT_REGISTERED();

        emit SuperformManagerRemoved(manager);
    }

    /*//////////////////////////////////////////////////////////////
                           VAULT HOOKS MGMT
    //////////////////////////////////////////////////////////////*/

    /// @inheritdoc ISuperGovernor
    function proposeVaultBankHookMerkleRoot(address hook, bytes32 proposedRoot) external onlyRole(_GOVERNOR_ROLE) {
        if (!_registeredHooks.contains(hook)) revert HOOK_NOT_APPROVED();
        if (proposedRoot == bytes32(0)) revert ZERO_PROPOSED_MERKLE_ROOT();

        uint256 effectiveTime = block.timestamp + TIMELOCK;
        ISuperGovernor.HookMerkleRootData storage data = vaultBankHooksMerkleRoots[hook];
        data.proposedRoot = proposedRoot;
        data.effectiveTime = effectiveTime;

        emit VaultBankHookMerkleRootProposed(hook, proposedRoot, effectiveTime);
    }

    /// @inheritdoc ISuperGovernor
    function executeVaultBankHookMerkleRootUpdate(address hook) external {
        if (!_registeredHooks.contains(hook)) revert HOOK_NOT_APPROVED();

        ISuperGovernor.HookMerkleRootData storage data = vaultBankHooksMerkleRoots[hook];

        // Check if there's a proposed update
        bytes32 proposedRoot = data.proposedRoot;
        if (proposedRoot == bytes32(0)) revert NO_PROPOSED_MERKLE_ROOT();

        // Check if the effective time has passed
        if (block.timestamp < data.effectiveTime) revert TIMELOCK_NOT_EXPIRED();

        // Update the Merkle root
        data.currentRoot = proposedRoot;

        // Reset the proposal
        data.proposedRoot = bytes32(0);
        data.effectiveTime = 0;

        emit VaultBankHookMerkleRootUpdated(hook, proposedRoot);
    }

    /*//////////////////////////////////////////////////////////////
                           SUPERBANK HOOKS MGMT
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperGovernor
    function proposeSuperBankHookMerkleRoot(address hook, bytes32 proposedRoot) external onlyRole(_GOVERNOR_ROLE) {
        if (!_registeredHooks.contains(hook)) revert HOOK_NOT_APPROVED();
        if (proposedRoot == bytes32(0)) revert ZERO_PROPOSED_MERKLE_ROOT();

        uint256 effectiveTime = block.timestamp + TIMELOCK;
        ISuperGovernor.HookMerkleRootData storage data = superBankHooksMerkleRoots[hook];
        data.proposedRoot = proposedRoot;
        data.effectiveTime = effectiveTime;

        emit SuperBankHookMerkleRootProposed(hook, proposedRoot, effectiveTime);
    }

    /// @inheritdoc ISuperGovernor
    function executeSuperBankHookMerkleRootUpdate(address hook) external {
        if (!_registeredHooks.contains(hook)) revert HOOK_NOT_APPROVED();

        ISuperGovernor.HookMerkleRootData storage data = superBankHooksMerkleRoots[hook];

        // Check if there's a proposed update
        bytes32 proposedRoot = data.proposedRoot;
        if (proposedRoot == bytes32(0)) revert NO_PROPOSED_MERKLE_ROOT();

        // Check if the effective time has passed
        if (block.timestamp < data.effectiveTime) revert TIMELOCK_NOT_EXPIRED();

        // Update the Merkle root
        data.currentRoot = proposedRoot;

        // Reset the proposal
        data.proposedRoot = bytes32(0);
        data.effectiveTime = 0;

        emit SuperBankHookMerkleRootUpdated(hook, proposedRoot);
    }

    /*//////////////////////////////////////////////////////////////
                        VAULT BANK MANAGEMENT
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperGovernor
    function addVaultBank(uint64 chainId, address vaultBank) external onlyRole(_GOVERNOR_ROLE) {
        if (chainId == 0) revert INVALID_CHAIN_ID();
        if (vaultBank == address(0)) revert INVALID_ADDRESS();

        if (_vaultBanksByChainId[chainId] != address(0)) {
            _vaultBanks.remove(_vaultBanksByChainId[chainId]);
        }

        _vaultBanks.add(vaultBank);
        _vaultBanksByChainId[chainId] = vaultBank;

        emit VaultBankAddressAdded(chainId, vaultBank);
    }

    /// @inheritdoc ISuperGovernor
    function getVaultBank(uint64 chainId) external view returns (address) {
        return _vaultBanksByChainId[chainId];
    }

    /*//////////////////////////////////////////////////////////////
                      INCENTIVE TOKEN MANAGEMENT
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperGovernor
    function proposeAddIncentiveTokens(address[] memory tokens) external onlyRole(_GOVERNOR_ROLE) {
        for (uint256 i; i < tokens.length; i++) {
            if (tokens[i] == address(0)) revert INVALID_ADDRESS();
            _proposedWhitelistedIncentiveTokens.add(tokens[i]);
        }

        _proposedAddWhitelistedIncentiveTokensEffectiveTime = block.timestamp + TIMELOCK;

        emit WhitelistedIncentiveTokensProposed(
            _proposedWhitelistedIncentiveTokens.values(), _proposedAddWhitelistedIncentiveTokensEffectiveTime
        );
    }

    /// @inheritdoc ISuperGovernor
    function executeAddIncentiveTokens() external {
        if (
            _proposedAddWhitelistedIncentiveTokensEffectiveTime == 0
                || block.timestamp < _proposedAddWhitelistedIncentiveTokensEffectiveTime
        ) revert TIMELOCK_NOT_EXPIRED();

        // Get all proposed tokens before modifying the set
        address[] memory tokensToAdd = _proposedWhitelistedIncentiveTokens.values();
        uint256 len = tokensToAdd.length;
        address token;
        for (uint256 i; i < len; i++) {
            token = tokensToAdd[i];
            _isWhitelistedIncentiveToken[token] = true;
            // Remove from proposed whitelisted tokens
            _proposedWhitelistedIncentiveTokens.remove(token);
        }

        // Emit event once with all tokens
        emit WhitelistedIncentiveTokensAdded(tokensToAdd);

        // Reset proposal timestamp
        _proposedAddWhitelistedIncentiveTokensEffectiveTime = 0;
    }

    /// @inheritdoc ISuperGovernor
    function proposeRemoveIncentiveTokens(address[] memory tokens) external onlyRole(_GOVERNOR_ROLE) {
        for (uint256 i; i < tokens.length; i++) {
            if (tokens[i] == address(0)) revert INVALID_ADDRESS();
            if (!_isWhitelistedIncentiveToken[tokens[i]]) revert NOT_WHITELISTED_INCENTIVE_TOKEN();

            _proposedRemoveWhitelistedIncentiveTokens.add(tokens[i]);
        }

        _proposedRemoveWhitelistedIncentiveTokensEffectiveTime = block.timestamp + TIMELOCK;

        emit WhitelistedIncentiveTokensProposed(
            _proposedRemoveWhitelistedIncentiveTokens.values(), _proposedRemoveWhitelistedIncentiveTokensEffectiveTime
        );
    }

    /// @inheritdoc ISuperGovernor
    function executeRemoveIncentiveTokens() external {
        if (
            _proposedRemoveWhitelistedIncentiveTokensEffectiveTime == 0
                || block.timestamp < _proposedRemoveWhitelistedIncentiveTokensEffectiveTime
        ) revert TIMELOCK_NOT_EXPIRED();

        // Get all proposed tokens before modifying the set
        address[] memory tokensToRemove = _proposedRemoveWhitelistedIncentiveTokens.values();
        uint256 len = tokensToRemove.length;
        address token;
        for (uint256 i; i < len; i++) {
            token = tokensToRemove[i];
            if (_isWhitelistedIncentiveToken[token]) {
                _isWhitelistedIncentiveToken[token] = false;
            }
            // Remove from proposed whitelisted tokens to be removed
            _proposedRemoveWhitelistedIncentiveTokens.remove(token);
        }

        // Emit event once with all tokens
        emit WhitelistedIncentiveTokensRemoved(tokensToRemove);

        // Reset proposal timestamp
        _proposedRemoveWhitelistedIncentiveTokensEffectiveTime = 0;
    }

    /*//////////////////////////////////////////////////////////////
                         EXTERNAL VIEW FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperGovernor
    function SUPER_GOVERNOR_ROLE() external pure returns (bytes32) {
        return _SUPER_GOVERNOR_ROLE;
    }

    /// @inheritdoc ISuperGovernor
    function GOVERNOR_ROLE() external pure returns (bytes32) {
        return _GOVERNOR_ROLE;
    }

    /// @inheritdoc ISuperGovernor
    function BANK_MANAGER_ROLE() external pure returns (bytes32) {
        return _BANK_MANAGER_ROLE;
    }

    /// @inheritdoc ISuperGovernor
    function GAS_MANAGER_ROLE() external pure returns (bytes32) {
        return _GAS_MANAGER_ROLE;
    }

    /// @inheritdoc ISuperGovernor
    function GUARDIAN_ROLE() external pure returns (bytes32) {
        return _GUARDIAN_ROLE;
    }

    /// @inheritdoc ISuperGovernor
    function SUPER_ASSET_FACTORY() external pure returns (bytes32) {
        return _SUPER_ASSET_FACTORY;
    }

    /// @inheritdoc ISuperGovernor
    function getAddress(bytes32 key) external view returns (address) {
        address value = _addressRegistry[key];
        if (value == address(0)) revert CONTRACT_NOT_FOUND();
        return value;
    }

    /// @inheritdoc ISuperGovernor
    function isManagerTakeoverFrozen() external view returns (bool) {
        return _managerTakeoversFrozen;
    }

    /// @inheritdoc ISuperGovernor
    function isHookRegistered(address hook) external view returns (bool) {
        return _registeredHooks.contains(hook);
    }

    /// @inheritdoc ISuperGovernor
    function isFulfillRequestsHookRegistered(address hook) external view returns (bool) {
        return _registeredFulfillRequestsHooks.contains(hook);
    }

    /// @inheritdoc ISuperGovernor
    function getRegisteredHooks() external view returns (address[] memory) {
        return _registeredHooks.values();
    }

    /// @inheritdoc ISuperGovernor
    function getRegisteredFulfillRequestsHooks() external view returns (address[] memory) {
        return _registeredFulfillRequestsHooks.values();
    }

    /// @inheritdoc ISuperGovernor
    function isValidator(address validator) external view returns (bool) {
        return _validators.contains(validator);
    }

    /// @inheritdoc ISuperGovernor
    function isGuardian(address guardian) external view returns (bool) {
        return hasRole(_GUARDIAN_ROLE, guardian);
    }

    /// @inheritdoc ISuperGovernor
    function isRelayer(address relayer) external view returns (bool) {
        return _relayers.contains(relayer);
    }

    /// @inheritdoc ISuperGovernor
    function isExecutor(address executor) external view returns (bool) {
        return _executors.contains(executor);
    }

    /// @inheritdoc ISuperGovernor
    function getValidators() external view returns (address[] memory) {
        return _validators.values();
    }

    /// @inheritdoc ISuperGovernor
    function getRelayers() external view returns (address[] memory) {
        return _relayers.values();
    }

    /// @inheritdoc ISuperGovernor
    function getExecutors() external view returns (address[] memory) {
        return _executors.values();
    }

    /// @inheritdoc ISuperGovernor
    function getProposedActivePPSOracle() external view returns (address proposedOracle, uint256 effectiveTime) {
        return (_proposedActivePPSOracle, _activePPSOracleEffectiveTime);
    }

    /// @inheritdoc ISuperGovernor
    function getPPSOracleQuorum() external view returns (uint256) {
        return _activePPSOracleQuorum;
    }

    /// @inheritdoc ISuperGovernor
    function getActivePPSOracle() external view returns (address) {
        if (_activePPSOracle == address(0)) revert NO_ACTIVE_PPS_ORACLE();
        return _activePPSOracle;
    }

    /// @inheritdoc ISuperGovernor
    function isActivePPSOracle(address oracle) external view returns (bool) {
        return oracle == _activePPSOracle;
    }

    /// @inheritdoc ISuperGovernor
    function getFee(FeeType feeType) external view returns (uint256) {
        return _feeValues[feeType];
    }

    /// @inheritdoc ISuperGovernor
    function getGasInfo(address oracle_) external view returns (GasInfo memory) {
        return _oracleGasInfo[oracle_];
    }

     /// @inheritdoc ISuperGovernor
    function getUpkeepCostPerBatchUpdate(address oracle_, uint256 chargeableEntries_) external view returns (uint256) {
        // Calculate total gas cost
        uint256 totalGas = _oracleGasInfo[oracle_].baseGasBatch + 
            (_oracleGasInfo[oracle_].gasIncreasePerEntryBatch * chargeableEntries_);

        return _convertGasToUp(totalGas);
    }

    /// @inheritdoc ISuperGovernor
    function getMinStaleness() external view returns (uint256) {
        return _minStaleness;
    }

    /// @inheritdoc ISuperGovernor
    function getProposedMinStaleness() external view returns (uint256 proposedMinStaleness, uint256 effectiveTime) {
        return (_proposedMinStaleness, _minStalenesEffectiveTime);
    }

    /// @inheritdoc ISuperGovernor
    function getSuperBankHookMerkleRoot(address hook) external view returns (bytes32) {
        if (!_registeredHooks.contains(hook)) revert HOOK_NOT_APPROVED();
        return superBankHooksMerkleRoots[hook].currentRoot;
    }

    /// @inheritdoc ISuperGovernor
    function getVaultBankHookMerkleRoot(address hook) external view returns (bytes32) {
        if (!_registeredHooks.contains(hook)) revert HOOK_NOT_APPROVED();
        return vaultBankHooksMerkleRoots[hook].currentRoot;
    }

    /// @inheritdoc ISuperGovernor
    function getProposedSuperBankHookMerkleRoot(address hook)
        external
        view
        returns (bytes32 proposedRoot, uint256 effectiveTime)
    {
        if (!_registeredHooks.contains(hook)) revert HOOK_NOT_APPROVED();
        ISuperGovernor.HookMerkleRootData storage data = superBankHooksMerkleRoots[hook];
        return (data.proposedRoot, data.effectiveTime);
    }

    /// @inheritdoc ISuperGovernor
    function getProposedVaultBankHookMerkleRoot(address hook)
        external
        view
        returns (bytes32 proposedRoot, uint256 effectiveTime)
    {
        if (!_registeredHooks.contains(hook)) revert HOOK_NOT_APPROVED();
        ISuperGovernor.HookMerkleRootData storage data = vaultBankHooksMerkleRoots[hook];
        return (data.proposedRoot, data.effectiveTime);
    }

    /// @inheritdoc ISuperGovernor
    function getProver() external view returns (address) {
        return _prover;
    }

    /// @inheritdoc ISuperGovernor
    function isUpkeepPaymentsEnabled() external view returns (bool enabled) {
        return _upkeepPaymentsEnabled;
    }

    /// @inheritdoc ISuperGovernor
    function getProposedUpkeepPaymentsStatus() external view returns (bool enabled, uint256 effectiveTime) {
        return (_proposedUpkeepPaymentsEnabled, _upkeepPaymentsChangeEffectiveTime);
    }

    /// @inheritdoc ISuperGovernor
    function isSuperformManager(address manager) external view returns (bool isSuperform) {
        return _superformManagers.contains(manager);
    }

    /// @inheritdoc ISuperGovernor
    function getAllSuperformManagers() external view returns (address[] memory managers) {
        return _superformManagers.values();
    }

    /// @inheritdoc ISuperGovernor
    function getManagersPaginated(
        uint256 cursor,
        uint256 limit
    )
        external
        view
        returns (address[] memory chunkOfManagers, uint256 next)
    {
        uint256 len = _superformManagers.length();

        // clamp limit so we don’t read past end
        uint256 realLimit = limit;
        // If cursor is beyond the end, return empty array
        if (cursor >= len) {
            return (new address[](0), 0);
        }

        uint256 remaining = len - cursor;
        if (realLimit > remaining) realLimit = remaining;

        chunkOfManagers = new address[](realLimit);
        for (uint256 i; i < realLimit; ++i) {
            chunkOfManagers[i] = _superformManagers.at(cursor + i);
        }

        next = (cursor + realLimit < len) ? cursor + realLimit : 0;
    }

    /// @inheritdoc ISuperGovernor
    function getSuperformManagersCount() external view returns (uint256) {
        return _superformManagers.length();
    }

    /// @inheritdoc ISuperGovernor
    function isWhitelistedIncentiveToken(address token) external view returns (bool) {
        return _isWhitelistedIncentiveToken[token];
    }

    /// @inheritdoc ISuperGovernor
    function registerProtectedKeeper(address keeper) external onlyRole(_GOVERNOR_ROLE) {
        if (keeper == address(0)) revert INVALID_ADDRESS();
        if (_protectedKeepers.contains(keeper)) revert KEEPER_ALREADY_REGISTERED();

        _protectedKeepers.add(keeper);
        emit ProtectedKeeperRegistered(keeper);
    }

    /// @inheritdoc ISuperGovernor
    function unregisterProtectedKeeper(address keeper) external onlyRole(_GOVERNOR_ROLE) {
        if (!_protectedKeepers.contains(keeper)) revert KEEPER_NOT_REGISTERED();

        _protectedKeepers.remove(keeper);
        emit ProtectedKeeperUnregistered(keeper);
    }

    /// @inheritdoc ISuperGovernor
    function isProtectedKeeper(address keeper) external view returns (bool) {
        return _protectedKeepers.contains(keeper);
    }

    /// @inheritdoc ISuperGovernor
    function getProtectedKeepers() external view returns (address[] memory) {
        return _protectedKeepers.values();
    }

    /// @inheritdoc ISuperGovernor
    function getProtectedKeepersCount() external view returns (uint256) {
        return _protectedKeepers.length();
    }

    /*//////////////////////////////////////////////////////////////
                           INTERNAL FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    function _convertGasToUp(uint256 gasAmount) internal view returns (uint256) {
        address oracle = _addressRegistry[SUPER_ORACLE];
        if (oracle == address(0)) revert SUPER_ORACLE_NOT_FOUND();
        address upToken = _addressRegistry[UP];
        if (upToken == address(0)) revert UP_NOT_FOUND();

        // Step 1: convert gas to ETH
        (uint256 ethAmount,,,) = ISuperOracle(oracle).getQuoteFromProvider(
            gasAmount,
            GAS_QUOTE,
            GWEI_QUOTE,
            AVERAGE_PROVIDER
        );

        // Step 2: convert ETH to USD
        (uint256 ethToUsd,,,) = ISuperOracle(oracle).getQuoteFromProvider(
            ethAmount,
            NATIVE_TOKEN,
            USD_TOKEN,
            AVERAGE_PROVIDER
        );

        // Step 3: convert USD to UP (how much USD per UP token)
        (uint256 upPerUsd,,,) = ISuperOracle(oracle).getQuoteFromProvider(
            1e18, // 1 UP token (18 decimals)
            upToken,
            USD_TOKEN,
            AVERAGE_PROVIDER
        );

        // Calculate required UP tokens
        // usdAmount / upPerUsd = required UP tokens
        uint256 requiredUpTokens = Math.mulDiv(ethToUsd, 1e18, upPerUsd, Math.Rounding.Ceil);
        return requiredUpTokens;
    }
}


86.0% src/SuperVault/SuperVault.sol

Lines covered: 167 / 192 (86.0%)

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.30;

// External
import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";
import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import { IERC4626 } from "@openzeppelin/contracts/interfaces/IERC4626.sol";

// OpenZeppelin Upgradeable
import { Initializable } from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import { ReentrancyGuardUpgradeable } from "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
import { ERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { IERC165 } from "@openzeppelin/contracts/interfaces/IERC165.sol";
import { EIP712Upgradeable } from "@openzeppelin/contracts-upgradeable/utils/cryptography/EIP712Upgradeable.sol";
import { IERC20Metadata } from "@openzeppelin/contracts/interfaces/IERC20Metadata.sol";

// Interfaces
import { ISuperVault } from "../interfaces/SuperVault/ISuperVault.sol";
import { ISuperVaultStrategy } from "../interfaces/SuperVault/ISuperVaultStrategy.sol";
import { ISuperGovernor } from "../interfaces/ISuperGovernor.sol";
import { ISuperVaultAggregator } from "../interfaces/SuperVault/ISuperVaultAggregator.sol";
import { IERC7540Operator, IERC7540Redeem, IERC7741 } from "../vendor/standards/ERC7540/IERC7540Vault.sol";
import { IERC7575 } from "../vendor/standards/ERC7575/IERC7575.sol";
import { ISuperVaultEscrow } from "../interfaces/SuperVault/ISuperVaultEscrow.sol";

// Libraries
import { AssetMetadataLib } from "../libraries/AssetMetadataLib.sol";

/// @title SuperVault
/// @author Superform Labs
/// @notice SuperVault vault contract implementing ERC4626 with synchronous deposits and asynchronous redeems via
/// ERC7540
contract SuperVault is
    Initializable,
    ERC20Upgradeable,
    IERC7540Redeem,
    IERC7741,
    IERC4626,
    ISuperVault,
    ReentrancyGuardUpgradeable,
    EIP712Upgradeable
{
    using AssetMetadataLib for address;
    using SafeERC20 for IERC20;
    using Math for uint256;

    /*//////////////////////////////////////////////////////////////
                                CONSTANTS
    //////////////////////////////////////////////////////////////*/
    uint256 private constant REQUEST_ID = 0;
    uint256 private constant BPS_PRECISION = 10_000;

    // EIP712 TypeHash
    bytes32 public constant AUTHORIZE_OPERATOR_TYPEHASH =
        keccak256("AuthorizeOperator(address controller,address operator,bool approved,bytes32 nonce,uint256 deadline)");

    /*//////////////////////////////////////////////////////////////
                                STATE
    //////////////////////////////////////////////////////////////*/
    address public share;
    IERC20 private _asset;
    uint8 private _underlyingDecimals;
    ISuperVaultStrategy public strategy;
    address public escrow;
    uint256 public PRECISION;

    // Core contracts
    ISuperGovernor public immutable superGovernor;

    /// @inheritdoc IERC7540Operator
    mapping(address owner => mapping(address operator => bool)) public isOperator;

    // Authorization tracking
    mapping(address controller => mapping(bytes32 nonce => bool used)) private _authorizations;

    /*//////////////////////////////////////////////////////////////
                            CONSTRUCTOR
    //////////////////////////////////////////////////////////////*/

    constructor(address superGovernor_) {
        if (superGovernor_ == address(0)) revert ZERO_ADDRESS();
        superGovernor = ISuperGovernor(superGovernor_);
        emit SuperGovernorSet(superGovernor_);

        _disableInitializers();
    }

    /*//////////////////////////////////////////////////////////////
                            INITIALIZATION
    //////////////////////////////////////////////////////////////*/

    /// @notice Initialize the vault with required parameters
    /// @param asset_ The underlying asset token address
    /// @param name_ The name of the vault token
    /// @param symbol_ The symbol of the vault token
    /// @param strategy_ The strategy contract address
    /// @param escrow_ The escrow contract address
    function initialize(
        address asset_,
        string memory name_,
        string memory symbol_,
        address strategy_,
        address escrow_
    )
        external
        initializer
    {
        if (asset_ == address(0)) revert INVALID_ASSET();
        if (strategy_ == address(0)) revert INVALID_STRATEGY();
        if (escrow_ == address(0)) revert INVALID_ESCROW();

        // Initialize parent contracts
        __ERC20_init(name_, symbol_);
        __ReentrancyGuard_init();
        __EIP712_init(name_, "1");

        // Set asset and precision
        _asset = IERC20(asset_);
        (bool success, uint8 assetDecimals) = asset_.tryGetAssetDecimals();
        if (!success) revert INVALID_ASSET();
        _underlyingDecimals = assetDecimals;
        PRECISION = 10 ** _underlyingDecimals;
        share = address(this);
        strategy = ISuperVaultStrategy(strategy_);
        escrow = escrow_;
    }

    /*//////////////////////////////////////////////////////////////
                            ERC20 OVERRIDES
    //////////////////////////////////////////////////////////////*/

    /*//////////////////////////////////////////////////////////////
                        USER EXTERNAL FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    /// @inheritdoc IERC4626
    function deposit(uint256 assets, address receiver) public override nonReentrant returns (uint256 shares) {
        if (receiver == address(0)) revert ZERO_ADDRESS();
        if (assets == 0) revert ZERO_AMOUNT();

        // Forward assets from msg-sender to strategy
        _asset.safeTransferFrom(msg.sender, address(strategy), assets);

        // Single executor call: strategy skims entry fee, accounts on NET, returns net shares
        shares = strategy.handleOperations4626Deposit(receiver, assets);
        if (shares == 0) revert ZERO_AMOUNT();

        // Mint the net shares
        _mint(receiver, shares);

        emit Deposit(msg.sender, receiver, assets, shares);
    }

    /// @inheritdoc IERC4626
    function mint(uint256 shares, address receiver) public override nonReentrant returns (uint256 assets) {
        if (receiver == address(0)) revert ZERO_ADDRESS();
        if (shares == 0) revert ZERO_AMOUNT();

        uint256 assetsNet;
        (assets, assetsNet) = strategy.quoteMintAssetsGross(shares);

        // Forward quoted gross assets from msg-sender to strategy
        _asset.safeTransferFrom(msg.sender, address(strategy), assets);

        // Single executor call: strategy handles fees and accounts on NET
        strategy.handleOperations4626Mint(receiver, shares, assets, assetsNet);

        // Mint the exact shares asked
        _mint(receiver, shares);

        emit Deposit(msg.sender, receiver, assets, shares);
    }

    /// @inheritdoc IERC7540Redeem
    /// @notice Once owner has authorized an operator, the operator can request a redeem with any controller address
    function requestRedeem(uint256 shares, address controller, address owner) external returns (uint256) {
        if (shares == 0) revert ZERO_AMOUNT();
        if (owner == address(0) || controller == address(0)) revert ZERO_ADDRESS();
        if (owner != msg.sender && !isOperator[owner][msg.sender]) revert INVALID_OWNER_OR_OPERATOR();
        if (balanceOf(owner) < shares) revert INVALID_AMOUNT();

        // Enforce auditor's invariant for current accounting model
        if (controller != owner) revert CONTROLLER_MUST_EQUAL_OWNER();

        // Transfer shares to escrow for temporary locking
        _approve(owner, escrow, shares);
        ISuperVaultEscrow(escrow).escrowShares(owner, shares);

        // Forward to strategy (7540 path)
        strategy.handleOperations7540(ISuperVaultStrategy.Operation.RedeemRequest, controller, address(0), shares);

        emit RedeemRequest(controller, owner, REQUEST_ID, msg.sender, shares);
        return REQUEST_ID;
    }

    /// @inheritdoc ISuperVault
    function cancelRedeem(address controller) external {
        _validateController(controller);

        uint256 shares = strategy.pendingRedeemRequest(controller);

        // Forward to strategy (7540 path)
        strategy.handleOperations7540(ISuperVaultStrategy.Operation.CancelRedeem, controller, address(0), 0);

        // Return shares to controller
        ISuperVaultEscrow(escrow).returnShares(controller, shares);

        emit RedeemRequestCancelled(controller, msg.sender);
    }

    /// @inheritdoc IERC7540Operator
    function setOperator(address operator, bool approved) external returns (bool success) {
        if (msg.sender == operator) revert UNAUTHORIZED();
        isOperator[msg.sender][operator] = approved;
        emit OperatorSet(msg.sender, operator, approved);
        return true;
    }

    /// @inheritdoc IERC7741
    function authorizeOperator(
        address controller,
        address operator,
        bool approved,
        bytes32 nonce,
        uint256 deadline,
        bytes memory signature
    )
        external
        returns (bool)
    {
        if (controller == operator) revert UNAUTHORIZED();
        if (block.timestamp > deadline) revert DEADLINE_PASSED();
        if (_authorizations[controller][nonce]) revert UNAUTHORIZED();

        _authorizations[controller][nonce] = true;

        bytes32 structHash =
            keccak256(abi.encode(AUTHORIZE_OPERATOR_TYPEHASH, controller, operator, approved, nonce, deadline));
        bytes32 digest = _hashTypedDataV4(structHash);

        if (!_isValidSignature(controller, digest, signature)) revert INVALID_SIGNATURE();

        isOperator[controller][operator] = approved;
        emit OperatorSet(controller, operator, approved);

        return true;
    }

    /*//////////////////////////////////////////////////////////////
                    USER EXTERNAL VIEW FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    //--ERC7540--

    /// @inheritdoc IERC7540Redeem
    function pendingRedeemRequest(
        uint256, /*requestId*/
        address controller
    )
        external
        view
        returns (uint256 pendingShares)
    {
        return strategy.pendingRedeemRequest(controller);
    }

    /// @inheritdoc IERC7540Redeem
    function claimableRedeemRequest(
        uint256, /*requestId*/
        address controller
    )
        external
        view
        returns (uint256 claimableShares)
    {
        return maxRedeem(controller);
    }

    //--Operator Management--

    /// @inheritdoc IERC7741
    function authorizations(address controller, bytes32 nonce) external view returns (bool used) {
        return _authorizations[controller][nonce];
    }

    /// @inheritdoc IERC7741
    function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
        return _domainSeparatorV4();
    }

    /// @inheritdoc IERC7741
    function invalidateNonce(bytes32 nonce) external {
        if (_authorizations[msg.sender][nonce]) revert INVALID_NONCE();
        _authorizations[msg.sender][nonce] = true;

        emit NonceInvalidated(msg.sender, nonce);
    }

    /*//////////////////////////////////////////////////////////////
                            ERC4626 IMPLEMENTATION
    //////////////////////////////////////////////////////////////*/
    function decimals() public view virtual override(ERC20Upgradeable, IERC20Metadata) returns (uint8) {
        return _underlyingDecimals;
    }

    function asset() public view virtual override returns (address) {
        return address(_asset);
    }

    /// @inheritdoc IERC4626
    function totalAssets() external view override returns (uint256) {
        uint256 supply = totalSupply();
        if (supply == 0) return 0;
        uint256 currentPPS = _getStoredPPS();
        return Math.mulDiv(supply, currentPPS, PRECISION, Math.Rounding.Floor);
    }

    /// @inheritdoc IERC4626
    function convertToShares(uint256 assets) public view override returns (uint256) {
        uint256 pps = _getStoredPPS();
        if (pps == 0) return 0;
        return Math.mulDiv(assets, PRECISION, pps, Math.Rounding.Floor);
    }

    /// @inheritdoc IERC4626
    function convertToAssets(uint256 shares) public view override returns (uint256) {
        uint256 currentPPS = _getStoredPPS();
        if (currentPPS == 0) return 0;
        return Math.mulDiv(shares, currentPPS, PRECISION, Math.Rounding.Floor);
    }

    /// @inheritdoc IERC4626
    function maxDeposit(address) public view override returns (uint256) {
        if (_isPaused()) return 0;
        return type(uint256).max;
    }

    /// @inheritdoc IERC4626
    function maxMint(address) external view override returns (uint256) {
        if (_isPaused()) return 0;
        return type(uint256).max;
    }

    /// @inheritdoc IERC4626
    function maxWithdraw(address owner) public view override returns (uint256) {
        return strategy.claimableWithdraw(owner);
    }

    /// @inheritdoc IERC4626
    function maxRedeem(address owner) public view override returns (uint256) {
        uint256 withdrawPrice = strategy.getAverageWithdrawPrice(owner);
        if (withdrawPrice == 0) return 0;
        return maxWithdraw(owner).mulDiv(PRECISION, withdrawPrice, Math.Rounding.Floor);
    }

    /// @inheritdoc IERC4626
    function previewDeposit(uint256 assets) public view override returns (uint256) {
        uint256 pps = _getStoredPPS();
        if (pps == 0) return 0;

        (uint256 feeBps,) = _getManagementFeeConfig();

        if (feeBps == 0) return Math.mulDiv(assets, PRECISION, pps, Math.Rounding.Floor);
        // fee-on-gross: fee = ceil(gross * feeBps / BPS)
        uint256 fee = Math.mulDiv(assets, feeBps, BPS_PRECISION, Math.Rounding.Ceil);

        uint256 assetsNet = assets - fee;
        return Math.mulDiv(assetsNet, PRECISION, pps, Math.Rounding.Floor);
    }

    /// @inheritdoc IERC4626
    function previewMint(uint256 shares) public view override returns (uint256) {
        uint256 pps = _getStoredPPS();
        if (pps == 0) return 0;

        uint256 assetsNet = Math.mulDiv(shares, pps, PRECISION, Math.Rounding.Ceil);

        (uint256 feeBps,) = _getManagementFeeConfig();
        if (feeBps == 0) return assetsNet;
        if (feeBps >= BPS_PRECISION) return 0; // impossible to mint (would require infinite gross)

        return Math.mulDiv(assetsNet, BPS_PRECISION, (BPS_PRECISION - feeBps), Math.Rounding.Ceil);
    }

    /// @inheritdoc IERC4626
    function previewWithdraw(uint256 /* assets*/ ) public pure override returns (uint256) {
        revert NOT_IMPLEMENTED();
    }

    /// @inheritdoc IERC4626
    function previewRedeem(uint256 /* shares*/ ) public pure override returns (uint256) {
        revert NOT_IMPLEMENTED();
    }

    /// @inheritdoc IERC4626
    function withdraw(
        uint256 assets,
        address receiver,
        address controller
    )
        public
        override
        nonReentrant
        returns (uint256 shares)
    {
        if (receiver == address(0)) revert ZERO_ADDRESS();
        _validateController(controller);

        uint256 averageWithdrawPrice = strategy.getAverageWithdrawPrice(controller);
        if (averageWithdrawPrice == 0) revert INVALID_WITHDRAW_PRICE();

        uint256 maxWithdrawAmount = maxWithdraw(controller);
        if (assets > maxWithdrawAmount) revert INVALID_AMOUNT();

        // Calculate shares based on assets and average withdraw price
        shares = assets.mulDiv(PRECISION, averageWithdrawPrice, Math.Rounding.Floor);

        // Take assets from strategy (7540 path)
        strategy.handleOperations7540(ISuperVaultStrategy.Operation.ClaimRedeem, controller, receiver, assets);

        emit Withdraw(msg.sender, receiver, controller, assets, shares);
    }

    /// @inheritdoc IERC4626
    function redeem(
        uint256 shares,
        address receiver,
        address controller
    )
        public
        override
        nonReentrant
        returns (uint256 assets)
    {
        if (receiver == address(0)) revert ZERO_ADDRESS();
        _validateController(controller);

        uint256 averageWithdrawPrice = strategy.getAverageWithdrawPrice(controller);
        if (averageWithdrawPrice == 0) revert INVALID_WITHDRAW_PRICE();

        // Calculate assets based on shares and average withdraw price
        assets = shares.mulDiv(averageWithdrawPrice, PRECISION, Math.Rounding.Floor);

        uint256 maxWithdrawAmount = maxWithdraw(controller);
        if (assets > maxWithdrawAmount) revert INVALID_AMOUNT();

        // Take assets from strategy (7540 path)
        strategy.handleOperations7540(ISuperVaultStrategy.Operation.ClaimRedeem, controller, receiver, assets);

        emit Withdraw(msg.sender, receiver, controller, assets, shares);
    }

    // @inheritdoc ISuperVault
    function burnShares(uint256 amount) external {
        if (msg.sender != address(strategy)) revert UNAUTHORIZED();
        _burn(escrow, amount);
    }

    // @inheritdoc ISuperVault
    function onRedeemClaimable(
        address user,
        uint256 assets,
        uint256 shares,
        uint256 averageWithdrawPrice,
        uint256 accumulatorShares,
        uint256 accumulatorCostBasis
    )
        external
    {
        if (msg.sender != address(strategy)) revert UNAUTHORIZED();
        emit RedeemClaimable(
            user, REQUEST_ID, assets, shares, averageWithdrawPrice, accumulatorShares, accumulatorCostBasis
        );
    }

    /*//////////////////////////////////////////////////////////////
                            ERC165 INTERFACE
    //////////////////////////////////////////////////////////////*/
    function supportsInterface(bytes4 interfaceId) public pure returns (bool) {
        return interfaceId == type(IERC7540Redeem).interfaceId || interfaceId == type(IERC165).interfaceId
            || interfaceId == type(IERC7741).interfaceId || interfaceId == type(IERC4626).interfaceId
            || interfaceId == type(IERC7575).interfaceId || interfaceId == type(IERC7540Operator).interfaceId;
    }

    /*//////////////////////////////////////////////////////////////
                        INTERNAL FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    /// @notice Validates that the controller is the msg.sender or has been authorized by the controller
    /// @param controller The controller to validate
    function _validateController(address controller) internal view {
        if (controller != msg.sender && !isOperator[controller][msg.sender]) revert INVALID_CONTROLLER();
    }

    /// @notice Verify an EIP712 signature using OpenZeppelin's ECDSA library
    /// @param signer The signer to verify
    /// @param digest The digest to verify
    /// @param signature The signature to verify
    function _isValidSignature(address signer, bytes32 digest, bytes memory signature) internal pure returns (bool) {
        address recoveredSigner = ECDSA.recover(digest, signature);
        return recoveredSigner == signer;
    }

    /// @notice Overrides the ERC20 _update function to update the state of the vault when a transfer occurs
    /// @param from The address of the sender
    /// @param to The address of the recipient
    /// @param value The amount of shares being transferred
    function _update(address from, address to, uint256 value) internal override(ERC20Upgradeable) {
        /// @dev Move only accumulators pro-rata between actual users, not to/from infrastructure contracts
        if (from != address(0) && to != address(0) && to != address(escrow) && from != address(escrow)) {
            uint256 shares = value;
            // Zero-value transfers are legal: treat as accounting no-op.
            if (shares > 0) {
                strategy.moveAccumulatorOnTransfer(from, to, shares);
            }
        }
        super._update(from, to, value);
    }

    function _getStoredPPS() internal view returns (uint256) {
        return strategy.getStoredPPS();
    }

    /// @notice Checks if the vault is currently paused
    /// @dev This accesses the SuperVaultAggregator directly via the governor to determine pause status
    /// @return True if the vault is paused, false otherwise
    function _isPaused() internal view returns (bool) {
        address aggregatorAddress = superGovernor.getAddress(superGovernor.SUPER_VAULT_AGGREGATOR());
        return ISuperVaultAggregator(aggregatorAddress).isStrategyPaused(address(strategy));
    }

    /// @dev Read management fee config (view-only for previews)
    function _getManagementFeeConfig() internal view returns (uint256 feeBps, address recipient) {
        ISuperVaultStrategy.FeeConfig memory cfg = strategy.getConfigInfo();
        return (cfg.managementFeeBps, cfg.recipient);
    }
}


50.0% src/SuperVault/SuperVaultAggregator.sol

Lines covered: 315 / 621 (50.0%)

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.30;

// External
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Clones} from "@openzeppelin/contracts/proxy/Clones.sol";
import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import {MerkleProof} from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";

// Superform
import {SuperVault} from "./SuperVault.sol";
import {SuperVaultStrategy} from "./SuperVaultStrategy.sol";
import {SuperVaultEscrow} from "./SuperVaultEscrow.sol";
import {ISuperGovernor} from "../interfaces/ISuperGovernor.sol";
import {ISuperVaultAggregator} from "../interfaces/SuperVault/ISuperVaultAggregator.sol";
// Libraries
import {AssetMetadataLib} from "../libraries/AssetMetadataLib.sol";

/// @title SuperVaultAggregator
/// @author Superform Labs
/// @notice Registry and PPS oracle for all SuperVaults
/// @dev Creates new SuperVault trios and manages PPS updates
contract SuperVaultAggregator is ISuperVaultAggregator {
    using AssetMetadataLib for address;
    using Clones for address;
    using SafeERC20 for IERC20;
    using Math for uint256;
    using EnumerableSet for EnumerableSet.AddressSet;

    /*//////////////////////////////////////////////////////////////
                                 STORAGE
    //////////////////////////////////////////////////////////////*/
    // Vault implementation contracts
    address public immutable VAULT_IMPLEMENTATION;
    address public immutable STRATEGY_IMPLEMENTATION;
    address public immutable ESCROW_IMPLEMENTATION;

    // Governance
    ISuperGovernor public immutable SUPER_GOVERNOR;

    // Claimable upkeep
    uint256 public claimableUpkeep;

    // Strategy data storage
    mapping(address strategy => StrategyData) private _strategyData;

    // Upkeep balances
    mapping(address manager => uint256 upkeep) private _managerUpkeepBalance;

    // Stake balances
    mapping(address manager => uint256 stake) private _managerStakeBalance;

    // Registry of created vaults
    EnumerableSet.AddressSet private _superVaults;
    EnumerableSet.AddressSet private _superVaultStrategies;
    EnumerableSet.AddressSet private _superVaultEscrows;

    // Constant for PPS decimals
    uint256 public constant PPS_DECIMALS = 18;

    // Maximum number of secondary managers per strategy to prevent governance DoS on manager replacement
    uint256 public constant MAX_SECONDARY_MANAGERS = 5;

    // Maximum number of strategies to process in `batchForwardPPS`
    uint256 public constant MAX_STRATEGIES = 300;

    // Timelock for manager changes and Merkle root updates
    uint256 private constant _MANAGER_CHANGE_TIMELOCK = 7 days;
    uint256 private _hooksRootUpdateTimelock = 15 minutes;

    // Global hooks Merkle root data
    bytes32 private _globalHooksRoot;
    bytes32 private _proposedGlobalHooksRoot;
    uint256 private _globalHooksRootEffectiveTime;
    bool private _globalHooksRootVetoed;

    // Nonce for vault creation tracking
    uint256 private _vaultCreationNonce;

    /*//////////////////////////////////////////////////////////////
                               MODIFIERS
    //////////////////////////////////////////////////////////////*/
    /// @notice Validates that msg.sender is the active PPS Oracle
    modifier onlyPPSOracle() {
        if (!SUPER_GOVERNOR.isActivePPSOracle(msg.sender)) {
            revert UNAUTHORIZED_PPS_ORACLE();
        }
        _;
    }

    /// @notice Validates that a strategy exists (has been created by this aggregator)
    modifier validStrategy(address strategy) {
        if (!_superVaultStrategies.contains(strategy))
            revert UNKNOWN_STRATEGY();
        _;
    }

    /*//////////////////////////////////////////////////////////////
                              CONSTRUCTOR
    //////////////////////////////////////////////////////////////*/
    /// @notice Initializes the SuperVaultAggregator
    /// @param superGovernor_ Address of the SuperGovernor contract
    /// @param vaultImpl_ Address of the pre-deployed SuperVault implementation
    /// @param strategyImpl_ Address of the pre-deployed SuperVaultStrategy implementation
    /// @param escrowImpl_ Address of the pre-deployed SuperVaultEscrow implementation
    constructor(
        address superGovernor_,
        address vaultImpl_,
        address strategyImpl_,
        address escrowImpl_
    ) {
        if (superGovernor_ == address(0)) revert ZERO_ADDRESS();
        if (vaultImpl_ == address(0)) revert ZERO_ADDRESS();
        if (strategyImpl_ == address(0)) revert ZERO_ADDRESS();
        if (escrowImpl_ == address(0)) revert ZERO_ADDRESS();

        SUPER_GOVERNOR = ISuperGovernor(superGovernor_);
        VAULT_IMPLEMENTATION = vaultImpl_;
        STRATEGY_IMPLEMENTATION = strategyImpl_;
        ESCROW_IMPLEMENTATION = escrowImpl_;
    }

    /*//////////////////////////////////////////////////////////////
                            VAULT CREATION
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperVaultAggregator
    function createVault(
        VaultCreationParams calldata params
    ) external returns (address superVault, address strategy, address escrow) {
        // Input validation
        if (
            params.asset == address(0) ||
            params.mainManager == address(0) ||
            params.feeConfig.recipient == address(0)
        ) {
            revert ZERO_ADDRESS();
        }

        // Initialize local variables struct to avoid stack too deep
        VaultCreationLocalVars memory vars;

        // Increment nonce before creating proxies
        vars.currentNonce = _vaultCreationNonce++;
        vars.salt = keccak256(
            abi.encode(
                msg.sender,
                params.asset,
                params.name,
                params.symbol,
                vars.currentNonce
            )
        );

        // Create minimal proxies
        superVault = VAULT_IMPLEMENTATION.cloneDeterministic(vars.salt);
        escrow = ESCROW_IMPLEMENTATION.cloneDeterministic(vars.salt);
        strategy = STRATEGY_IMPLEMENTATION.cloneDeterministic(vars.salt);

        // Initialize superVault
        SuperVault(superVault).initialize(
            params.asset,
            params.name,
            params.symbol,
            strategy,
            escrow
        );

        // Initialize escrow
        SuperVaultEscrow(escrow).initialize(superVault, strategy);

        // Initialize strategy
        SuperVaultStrategy(payable(strategy)).initialize(
            superVault,
            params.feeConfig
        );

        // Store vault trio in registry
        _superVaults.add(superVault);
        _superVaultStrategies.add(strategy);
        _superVaultEscrows.add(escrow);

        // Get asset decimals
        (bool success, uint8 assetDecimals) = params
            .asset
            .tryGetAssetDecimals();
        if (!success) revert INVALID_ASSET();
        vars.initialPPS = 10 ** assetDecimals; // 1.0 as initial PPS

        // Validate maxStaleness against minimum required staleness
        if (params.maxStaleness < SUPER_GOVERNOR.getMinStaleness()) {
            revert MAX_STALENESS_TOO_LOW();
        }

        // Initialize StrategyData individually to avoid mapping assignment issues
        _strategyData[strategy].pps = vars.initialPPS;
        // Initialize standard deviation to 0
        _strategyData[strategy].lastUpdateTimestamp = block.timestamp;
        _strategyData[strategy].minUpdateInterval = params.minUpdateInterval;
        _strategyData[strategy].maxStaleness = params.maxStaleness;
        _strategyData[strategy].isPaused = false;
        _strategyData[strategy].mainManager = params.mainManager;

        uint256 secondaryLen = params.secondaryManagers.length;
        for (uint256 i; i < secondaryLen; ++i) {
            _strategyData[strategy].secondaryManagers.add(
                params.secondaryManagers[i]
            );
        }
        if (
            _strategyData[strategy].secondaryManagers.length() >=
            MAX_SECONDARY_MANAGERS
        ) {
            revert TOO_MANY_SECONDARY_MANAGERS();
        }

        // Set default threshold values
        _strategyData[strategy].dispersionThreshold = type(uint256).max; // Default: max (disabled)
        _strategyData[strategy].deviationThreshold = type(uint256).max; // Default: max (disabled)

        emit VaultDeployed(
            superVault,
            strategy,
            escrow,
            params.asset,
            params.name,
            params.symbol,
            vars.currentNonce
        );
        emit PPSUpdated(
            strategy,
            vars.initialPPS,
            0,
            0,
            0,
            _strategyData[strategy].lastUpdateTimestamp
        );

        return (superVault, strategy, escrow);
    }

    /*//////////////////////////////////////////////////////////////
                          PPS UPDATE FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperVaultAggregator
    function forwardPPS(ForwardPPSArgs calldata args) external onlyPPSOracle {
        uint256 strategiesLength = args.strategies.length;
        if (strategiesLength > MAX_STRATEGIES) revert MAX_STRATEGIES_EXCEEDED();

        if (strategiesLength == 0) revert ZERO_ARRAY_LENGTH();
        // Validate input array lengths
        if (
            strategiesLength != args.ppss.length ||
            strategiesLength != args.ppsStdevs.length ||
            strategiesLength != args.validatorSets.length ||
            strategiesLength != args.timestamps.length ||
            strategiesLength != args.totalValidators.length
        ) revert ARRAY_LENGTH_MISMATCH();

        bool paymentsEnabled = SUPER_GOVERNOR.isUpkeepPaymentsEnabled();
        uint256 chargeableCount;
        if (paymentsEnabled) {
            for (uint256 i; i < strategiesLength; ++i) {
                // Skip invalid strategies without reverting
                if (!_superVaultStrategies.contains(args.strategies[i])) {
                    emit UnknownStrategy(args.strategies[i]);
                    continue;
                }

                // Skip when invalid timestamp is provided
                if (args.timestamps[i] > block.timestamp) {
                    emit ProvidedTimestampExceedsBlockTimestamp(
                        args.strategies[i],
                        args.timestamps[i],
                        block.timestamp
                    );
                    continue;
                }

                // Skip Superform manager
                address manager = _strategyData[args.strategies[i]].mainManager;
                if (SUPER_GOVERNOR.isSuperformManager(manager)) {
                    emit SuperformManager(args.strategies[i], manager);
                    continue;
                }

                // Skip if updateAuthority is in the authorized callers list
                // These are manager-designated keepers that should be exempt from fees
                // NOTE: Protected keepers cannot be added to this list (blocked in addAuthorizedCaller)
                /// @dev: cannot underflow; it's checked above already and it skips the entry if that's the case
                if (
                    _strategyData[args.strategies[i]]
                        .authorizedCallers
                        .contains(args.updateAuthority)
                ) {
                    emit AuthorizedCaller(
                        args.strategies[i],
                        args.updateAuthority
                    );
                    continue;
                }

                // Count only non-stale entries as chargeable
                if (
                    block.timestamp - args.timestamps[i] <=
                    _strategyData[args.strategies[i]].maxStaleness
                ) {
                    ++chargeableCount;
                }
            }
        }

        ///@dev Total upkeep cost is determined by the oracle based on the number of chargeable entries
        uint256 totalCost = paymentsEnabled
            ? SUPER_GOVERNOR.getUpkeepCostPerBatchUpdate(
                msg.sender,
                chargeableCount
            )
            : 0;

        // Compute per-entry charge
        uint256 perEntry = 0;
        if (paymentsEnabled && chargeableCount > 0) {
            perEntry = totalCost / chargeableCount;
        }

        // Process all valid strategies
        for (uint256 i; i < strategiesLength; ++i) {
            // Skip invalid strategies without reverting
            if (!_superVaultStrategies.contains(args.strategies[i])) continue;

            // Skip when invalid timestamp is provided (future timestamp)
            if (args.timestamps[i] > block.timestamp) {
                emit ProvidedTimestampExceedsBlockTimestamp(
                    args.strategies[i],
                    args.timestamps[i],
                    block.timestamp
                );
                continue;
            }

            uint256 upkeepCost;
            if (paymentsEnabled) {
                // check exemption due to staleness of a given strategy
                /// @dev cannot underflow as it's already checked above, in the previous `for` loop
                if (
                    block.timestamp - args.timestamps[i] >
                    _strategyData[args.strategies[i]].maxStaleness
                ) {
                    upkeepCost = 0;
                    emit StaleUpdate(
                        args.strategies[i],
                        args.updateAuthority,
                        args.timestamps[i]
                    );
                } else {
                    address manager = _strategyData[args.strategies[i]]
                        .mainManager;
                    if (
                        SUPER_GOVERNOR.isSuperformManager(manager) ||
                        _strategyData[args.strategies[i]]
                            .authorizedCallers
                            .contains(args.updateAuthority)
                    ) {
                        upkeepCost = 0;
                    } else {
                        // Split the total batch cost fairly across chargeable entries
                        upkeepCost = perEntry;
                    }
                }
            }

            // Forward update
            _forwardPPS(
                PPSUpdateData({
                    strategy: args.strategies[i],
                    isExempt: (!paymentsEnabled) || (upkeepCost == 0), // If payments are disabled or the update is exempt from UP payments
                    pps: args.ppss[i],
                    ppsStdev: args.ppsStdevs[i],
                    validatorSet: args.validatorSets[i],
                    totalValidators: args.totalValidators[i],
                    timestamp: args.timestamps[i],
                    upkeepCost: upkeepCost
                })
            );
        }
    }

    /*//////////////////////////////////////////////////////////////
                        UPKEEP MANAGEMENT
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperVaultAggregator
    function depositUpkeep(address manager, uint256 amount) external {
        if (amount == 0) revert ZERO_AMOUNT();

        // Get the UP token address from SUPER_GOVERNOR
        address upToken = SUPER_GOVERNOR.getAddress(SUPER_GOVERNOR.UP());

        // Transfer UP tokens from msg.sender to this contract
        IERC20(upToken).safeTransferFrom(msg.sender, address(this), amount);

        // Update upkeep balance
        _managerUpkeepBalance[manager] += amount;

        emit UpkeepDeposited(manager, amount);
    }

    /// @inheritdoc ISuperVaultAggregator
    function claimUpkeep(uint256 amount) external {
        // Only SUPER_GOVERNOR can claim upkeep
        if (msg.sender != address(SUPER_GOVERNOR)) {
            revert CALLER_NOT_AUTHORIZED();
        }

        if (claimableUpkeep < amount) revert INSUFFICIENT_UPKEEP();
        claimableUpkeep -= amount;

        // Get the UP token address from SUPER_GOVERNOR
        address upToken = SUPER_GOVERNOR.getAddress(SUPER_GOVERNOR.UP());

        // Transfer UP tokens to `SuperBank`
        address _superBank = _getSuperBank();
        IERC20(upToken).safeTransfer(_superBank, amount);
        emit UpkeepClaimed(_superBank, amount);
    }

    /// @inheritdoc ISuperVaultAggregator
    function withdrawUpkeep(uint256 amount) external {
        if (amount == 0) revert ZERO_AMOUNT();

        // Check sufficient balance
        if (_managerUpkeepBalance[msg.sender] < amount) {
            revert INSUFFICIENT_UPKEEP_BALANCE();
        }

        // Get the UP token address from SUPER_GOVERNOR
        address upToken = SUPER_GOVERNOR.getAddress(SUPER_GOVERNOR.UP());

        // Update upkeep balance
        unchecked {
            _managerUpkeepBalance[msg.sender] -= amount;
        }

        // Transfer UP tokens to manager
        IERC20(upToken).safeTransfer(msg.sender, amount);

        emit UpkeepWithdrawn(msg.sender, amount);
    }

    /*//////////////////////////////////////////////////////////////
                        STAKE MANAGEMENT
    //////////////////////////////////////////////////////////////*/
    /// @notice Deposits UP tokens as stake for manager economic security
    /// @param manager Address of the manager to deposit stake for
    /// @param amount Amount of UP tokens to deposit as stake
    function depositStake(address manager, uint256 amount) external {
        if (amount == 0) revert ZERO_ADDRESS(); // Reusing error code for consistency
        if (manager == address(0)) revert ZERO_ADDRESS();

        // Get the UP token address from SUPER_GOVERNOR
        address upToken = SUPER_GOVERNOR.getAddress(SUPER_GOVERNOR.UP());

        // Transfer UP tokens from msg.sender to this contract
        IERC20(upToken).safeTransferFrom(msg.sender, address(this), amount);

        // Update stake balance
        _managerStakeBalance[manager] += amount;

        emit StakeDeposited(manager, amount);
    }

    /// @notice Withdraws UP tokens from stake balance
    /// @param amount Amount of UP tokens to withdraw from stake
    function withdrawStake(uint256 amount) external {
        if (amount == 0) revert ZERO_ADDRESS(); // Reusing error code for consistency

        // Check sufficient balance
        if (_managerStakeBalance[msg.sender] < amount) {
            revert INSUFFICIENT_STAKE_BALANCE();
        }

        // Get the UP token address from SUPER_GOVERNOR
        address upToken = SUPER_GOVERNOR.getAddress(SUPER_GOVERNOR.UP());

        // Update stake balance
        unchecked {
            _managerStakeBalance[msg.sender] -= amount;
        }

        // Transfer UP tokens to manager
        IERC20(upToken).safeTransfer(msg.sender, amount);

        emit StakeWithdrawn(msg.sender, amount);
    }

    /// @notice Slashes a manager's stake balance by a specified amount
    /// @param manager The manager whose stake will be slashed
    /// @param amount The amount of UP tokens to slash from the manager's stake balance
    function slashStake(address manager, uint256 amount) external {
        // Only SUPER_GOVERNOR can slash stake
        if (msg.sender != address(SUPER_GOVERNOR)) {
            revert CALLER_NOT_AUTHORIZED();
        }

        // Validate inputs
        if (manager == address(0)) revert ZERO_ADDRESS();
        if (amount == 0) revert ZERO_ADDRESS(); // Reusing error code for consistency

        // Check if manager has sufficient stake balance to slash
        if (_managerStakeBalance[manager] < amount) {
            revert INSUFFICIENT_STAKE_BALANCE();
        }

        // Reduce manager's stake balance
        _managerStakeBalance[manager] -= amount;

        // Get the UP token address and SuperBank address
        address upToken = SUPER_GOVERNOR.getAddress(SUPER_GOVERNOR.UP());
        address superBank = _getSuperBank();

        // Transfer slashed amount directly to SuperBank
        IERC20(upToken).safeTransfer(superBank, amount);

        // Emit event for transparency
        emit StakeSlashed(manager, amount);
    }

    /*//////////////////////////////////////////////////////////////
                        AUTHORIZED CALLER MANAGEMENT
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperVaultAggregator
    function addAuthorizedCaller(
        address strategy,
        address caller
    ) external validStrategy(strategy) {
        // Either primary or secondary manager can add authorized callers
        if (!isAnyManager(msg.sender, strategy))
            revert UNAUTHORIZED_UPDATE_AUTHORITY();

        if (caller == address(0)) revert ZERO_ADDRESS();

        // Prevent managers from adding protected keepers to circumvent fees
        if (SUPER_GOVERNOR.isProtectedKeeper(caller)) {
            revert CANNOT_ADD_PROTECTED_KEEPER();
        }

        // Check if caller is already authorized and add if not
        if (!_strategyData[strategy].authorizedCallers.add(caller)) {
            revert CALLER_ALREADY_AUTHORIZED();
        }
        emit AuthorizedCallerAdded(strategy, caller);
    }

    /// @inheritdoc ISuperVaultAggregator
    function removeAuthorizedCaller(
        address strategy,
        address caller
    ) external validStrategy(strategy) {
        // Either primary or secondary manager can remove authorized callers
        if (!isAnyManager(msg.sender, strategy))
            revert UNAUTHORIZED_UPDATE_AUTHORITY();

        // Remove the caller
        if (!_strategyData[strategy].authorizedCallers.remove(caller)) {
            revert CALLER_NOT_AUTHORIZED();
        }
        emit AuthorizedCallerRemoved(strategy, caller);
    }

    /*//////////////////////////////////////////////////////////////
                       MANAGER MANAGEMENT FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperVaultAggregator
    function addSecondaryManager(
        address strategy,
        address manager
    ) external validStrategy(strategy) {
        // Only the primary manager can add secondary managers
        if (msg.sender != _strategyData[strategy].mainManager)
            revert UNAUTHORIZED_UPDATE_AUTHORITY();

        if (manager == address(0)) revert ZERO_ADDRESS();

        // Check if manager is already the primary manager
        if (_strategyData[strategy].mainManager == manager)
            revert MANAGER_ALREADY_EXISTS();

        // Enforce a cap on secondary managers to prevent governance DoS on changePrimaryManager
        if (
            _strategyData[strategy].secondaryManagers.length() >=
            MAX_SECONDARY_MANAGERS
        ) {
            revert TOO_MANY_SECONDARY_MANAGERS();
        }

        // Add as secondary manager using EnumerableSet
        if (!_strategyData[strategy].secondaryManagers.add(manager))
            revert MANAGER_ALREADY_EXISTS();

        emit SecondaryManagerAdded(strategy, manager);
    }

    /// @inheritdoc ISuperVaultAggregator
    function removeSecondaryManager(
        address strategy,
        address manager
    ) external validStrategy(strategy) {
        // Only the primary manager can remove secondary managers
        if (msg.sender != _strategyData[strategy].mainManager)
            revert UNAUTHORIZED_UPDATE_AUTHORITY();

        // Remove the manager using EnumerableSet
        if (!_strategyData[strategy].secondaryManagers.remove(manager))
            revert MANAGER_NOT_FOUND();

        emit SecondaryManagerRemoved(strategy, manager);
    }

    /// @inheritdoc ISuperVaultAggregator
    function updatePPSVerificationThresholds(
        address strategy,
        uint256 dispersionThreshold_,
        uint256 deviationThreshold_,
        uint256 mnThreshold_
    ) external validStrategy(strategy) {
        // Since this is a risky call, we only allow main managers as callers
        if (msg.sender != _strategyData[strategy].mainManager) {
            revert UNAUTHORIZED_UPDATE_AUTHORITY();
        }

        // Update the thresholds
        _strategyData[strategy].dispersionThreshold = dispersionThreshold_;
        _strategyData[strategy].deviationThreshold = deviationThreshold_;
        _strategyData[strategy].mnThreshold = mnThreshold_;

        // Emit the event
        emit PPSVerificationThresholdsUpdated(
            strategy,
            dispersionThreshold_,
            deviationThreshold_,
            mnThreshold_
        );
    }

    /// @inheritdoc ISuperVaultAggregator
    function changeGlobalLeavesStatus(
        bytes32[] memory leaves,
        bool[] memory statuses,
        address strategy
    ) external validStrategy(strategy) {
        // Only the primary manager can change global leaves status
        if (msg.sender != _strategyData[strategy].mainManager) {
            revert UNAUTHORIZED_UPDATE_AUTHORITY();
        }
        uint256 leavesLen = leaves.length;
        // Check array lengths match
        if (leavesLen != statuses.length) {
            revert MISMATCHED_ARRAY_LENGTHS();
        }

        // Update banned status for each leaf
        for (uint256 i; i < leavesLen; i++) {
            _strategyData[strategy].bannedLeaves[leaves[i]] = statuses[i];
        }

        // Emit event
        emit GlobalLeavesStatusChanged(strategy, leaves, statuses);
    }

    /// @inheritdoc ISuperVaultAggregator
    function changePrimaryManager(
        address strategy,
        address newManager
    ) external validStrategy(strategy) {
        // Only SuperGovernor can call this
        if (msg.sender != address(SUPER_GOVERNOR)) {
            revert UNAUTHORIZED_UPDATE_AUTHORITY();
        }

        if (strategy == address(0)) revert ZERO_ADDRESS();

        if (newManager == address(0)) revert ZERO_ADDRESS();

        address oldManager = _strategyData[strategy].mainManager;

        // SECURITY: Clear any pending manager proposals to prevent malicious re-takeover
        _strategyData[strategy].proposedManager = address(0);
        _strategyData[strategy].managerChangeEffectiveTime = 0;

        // SECURITY: Clear any pending hooks root proposals to prevent malicious hook updates
        _strategyData[strategy].proposedHooksRoot = bytes32(0);
        _strategyData[strategy].hooksRootEffectiveTime = 0;

        // SECURITY: Clear all secondary managers as they may be controlled by malicious manager
        // Get all secondary managers first to emit proper events
        address[] memory clearedSecondaryManagers = _strategyData[strategy]
            .secondaryManagers
            .values();

        // Clear the entire secondary managers set
        for (uint256 i = 0; i < clearedSecondaryManagers.length; i++) {
            _strategyData[strategy].secondaryManagers.remove(
                clearedSecondaryManagers[i]
            );
            emit SecondaryManagerRemoved(strategy, clearedSecondaryManagers[i]);
        }

        // Set the new primary manager
        _strategyData[strategy].mainManager = newManager;

        emit PrimaryManagerChanged(strategy, oldManager, newManager);
    }

    /// @inheritdoc ISuperVaultAggregator
    function proposeChangePrimaryManager(
        address strategy,
        address newManager
    ) external validStrategy(strategy) {
        // Only secondary managers can propose changes to the primary manager
        if (!_strategyData[strategy].secondaryManagers.contains(msg.sender)) {
            revert UNAUTHORIZED_UPDATE_AUTHORITY();
        }

        if (newManager == address(0)) revert ZERO_ADDRESS();

        // Set up the proposal with 7-day timelock
        uint256 effectiveTime = block.timestamp + _MANAGER_CHANGE_TIMELOCK;

        // Store proposal in the strategy data
        _strategyData[strategy].proposedManager = newManager;
        _strategyData[strategy].managerChangeEffectiveTime = effectiveTime;

        emit PrimaryManagerChangeProposed(
            strategy,
            msg.sender,
            newManager,
            effectiveTime
        );
    }

    /// @inheritdoc ISuperVaultAggregator
    function executeChangePrimaryManager(
        address strategy
    ) external validStrategy(strategy) {
        // Check if there is a pending proposal
        if (_strategyData[strategy].proposedManager == address(0))
            revert NO_PENDING_MANAGER_CHANGE();

        // Check if the timelock period has passed
        if (
            block.timestamp < _strategyData[strategy].managerChangeEffectiveTime
        ) revert TIMELOCK_NOT_EXPIRED();

        address newManager = _strategyData[strategy].proposedManager;
        address oldManager = _strategyData[strategy].mainManager;

        // If new manager is already a secondary manager, remove them
        _strategyData[strategy].secondaryManagers.remove(newManager);

        // Make the old primary manager a secondary manager
        if (
            _strategyData[strategy].secondaryManagers.length() <
            MAX_SECONDARY_MANAGERS
        ) {
            _strategyData[strategy].secondaryManagers.add(oldManager);
        }

        // Set the new primary manager
        _strategyData[strategy].mainManager = newManager;

        // Clear the proposal
        _strategyData[strategy].proposedManager = address(0);

        emit PrimaryManagerChanged(strategy, oldManager, newManager);
    }

    /*//////////////////////////////////////////////////////////////
                        HOOK VALIDATION FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperVaultAggregator
    function setHooksRootUpdateTimelock(uint256 newTimelock) external {
        // Only SUPER_GOVERNOR can update the timelock
        if (msg.sender != address(SUPER_GOVERNOR)) {
            revert UNAUTHORIZED_UPDATE_AUTHORITY();
        }

        // Update the timelock
        _hooksRootUpdateTimelock = newTimelock;

        emit HooksRootUpdateTimelockChanged(newTimelock);
    }

    /// @inheritdoc ISuperVaultAggregator
    function proposeGlobalHooksRoot(bytes32 newRoot) external {
        // Only SUPER_GOVERNOR can update the global hooks root
        if (msg.sender != address(SUPER_GOVERNOR)) {
            revert UNAUTHORIZED_UPDATE_AUTHORITY();
        }

        // Set new root with timelock
        _proposedGlobalHooksRoot = newRoot;
        uint256 effectiveTime = block.timestamp + _hooksRootUpdateTimelock;
        _globalHooksRootEffectiveTime = effectiveTime;

        emit GlobalHooksRootUpdateProposed(newRoot, effectiveTime);
    }

    /// @inheritdoc ISuperVaultAggregator
    function executeGlobalHooksRootUpdate() external {
        bytes32 proposedRoot = _proposedGlobalHooksRoot;
        // Ensure there is a pending proposal
        if (proposedRoot == bytes32(0)) {
            revert NO_PENDING_GLOBAL_ROOT_CHANGE();
        }

        // Check if timelock period has elapsed
        if (block.timestamp < _globalHooksRootEffectiveTime) {
            revert ROOT_UPDATE_NOT_READY();
        }

        // Update the global hooks root
        bytes32 oldRoot = _globalHooksRoot;
        _globalHooksRoot = _proposedGlobalHooksRoot;
        _globalHooksRootEffectiveTime = 0;
        _proposedGlobalHooksRoot = bytes32(0);

        emit GlobalHooksRootUpdated(oldRoot, proposedRoot);
    }

    /// @inheritdoc ISuperVaultAggregator
    function setGlobalHooksRootVetoStatus(bool vetoed) external {
        // Only SuperGovernor can call this
        if (msg.sender != address(SUPER_GOVERNOR)) {
            revert UNAUTHORIZED_UPDATE_AUTHORITY();
        }

        // Don't emit event if status doesn't change
        if (_globalHooksRootVetoed == vetoed) {
            return;
        }

        // Update veto status
        _globalHooksRootVetoed = vetoed;

        emit GlobalHooksRootVetoStatusChanged(vetoed, _globalHooksRoot);
    }

    /// @inheritdoc ISuperVaultAggregator
    function proposeStrategyHooksRoot(
        address strategy,
        bytes32 newRoot
    ) external validStrategy(strategy) {
        // Only the main manager can propose strategy-specific hooks root
        if (_strategyData[strategy].mainManager != msg.sender) {
            revert UNAUTHORIZED_UPDATE_AUTHORITY();
        }

        // Set proposed root with timelock
        _strategyData[strategy].proposedHooksRoot = newRoot;
        uint256 effectiveTime = block.timestamp + _hooksRootUpdateTimelock;
        _strategyData[strategy].hooksRootEffectiveTime = effectiveTime;

        emit StrategyHooksRootUpdateProposed(
            strategy,
            msg.sender,
            newRoot,
            effectiveTime
        );
    }

    /// @inheritdoc ISuperVaultAggregator
    function executeStrategyHooksRootUpdate(
        address strategy
    ) external validStrategy(strategy) {
        bytes32 proposedRoot = _strategyData[strategy].proposedHooksRoot;
        // Ensure there is a pending proposal
        if (proposedRoot == bytes32(0)) {
            revert NO_PENDING_MANAGER_CHANGE(); // Reusing error for simplicity
        }

        // Check if timelock period has elapsed
        if (block.timestamp < _strategyData[strategy].hooksRootEffectiveTime) {
            revert ROOT_UPDATE_NOT_READY();
        }

        // Update the strategy's hooks root
        bytes32 oldRoot = _strategyData[strategy].managerHooksRoot;
        _strategyData[strategy].managerHooksRoot = proposedRoot;

        // Reset proposal state
        _strategyData[strategy].proposedHooksRoot = bytes32(0);
        _strategyData[strategy].hooksRootEffectiveTime = 0;

        emit StrategyHooksRootUpdated(strategy, oldRoot, proposedRoot);
    }

    /// @inheritdoc ISuperVaultAggregator
    function setStrategyHooksRootVetoStatus(
        address strategy,
        bool vetoed
    ) external validStrategy(strategy) {
        // Only SuperGovernor can call this
        if (msg.sender != address(SUPER_GOVERNOR)) {
            revert UNAUTHORIZED_UPDATE_AUTHORITY();
        }

        // Don't emit event if status doesn't change
        if (_strategyData[strategy].hooksRootVetoed == vetoed) {
            return;
        }

        // Update veto status
        _strategyData[strategy].hooksRootVetoed = vetoed;

        emit StrategyHooksRootVetoStatusChanged(
            strategy,
            vetoed,
            _strategyData[strategy].managerHooksRoot
        );
    }
    /// @inheritdoc ISuperVaultAggregator

    function isGlobalHooksRootVetoed() external view returns (bool vetoed) {
        return _globalHooksRootVetoed;
    }

    /// @inheritdoc ISuperVaultAggregator
    function isStrategyHooksRootVetoed(
        address strategy
    ) external view returns (bool vetoed) {
        return _strategyData[strategy].hooksRootVetoed;
    }

    /*//////////////////////////////////////////////////////////////
                              VIEW FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    /// @inheritdoc ISuperVaultAggregator
    function getCurrentNonce() external view returns (uint256) {
        return _vaultCreationNonce;
    }

    /// @inheritdoc ISuperVaultAggregator
    function getHooksRootUpdateTimelock() external view returns (uint256) {
        return _hooksRootUpdateTimelock;
    }

    /// @inheritdoc ISuperVaultAggregator
    function getPPS(
        address strategy
    ) external view validStrategy(strategy) returns (uint256 pps) {
        return _strategyData[strategy].pps;
    }

    /// @inheritdoc ISuperVaultAggregator
    function getPPSWithStdDev(
        address strategy
    )
        external
        view
        validStrategy(strategy)
        returns (uint256 pps, uint256 ppsStdev)
    {
        return (_strategyData[strategy].pps, _strategyData[strategy].ppsStdev);
    }

    /// @inheritdoc ISuperVaultAggregator
    function getLastUpdateTimestamp(
        address strategy
    ) external view returns (uint256 timestamp) {
        return _strategyData[strategy].lastUpdateTimestamp;
    }

    /// @inheritdoc ISuperVaultAggregator
    function getMinUpdateInterval(
        address strategy
    ) external view returns (uint256 interval) {
        return _strategyData[strategy].minUpdateInterval;
    }

    /// @inheritdoc ISuperVaultAggregator
    function getMaxStaleness(
        address strategy
    ) external view returns (uint256 staleness) {
        return _strategyData[strategy].maxStaleness;
    }

    /// @inheritdoc ISuperVaultAggregator
    function getPPSVerificationThresholds(
        address strategy
    )
        external
        view
        validStrategy(strategy)
        returns (
            uint256 dispersionThreshold,
            uint256 deviationThreshold,
            uint256 mnThreshold
        )
    {
        return (
            _strategyData[strategy].dispersionThreshold,
            _strategyData[strategy].deviationThreshold,
            _strategyData[strategy].mnThreshold
        );
    }

    /// @inheritdoc ISuperVaultAggregator
    function isStrategyPaused(
        address strategy
    ) external view returns (bool isPaused) {
        return _strategyData[strategy].isPaused;
    }

    /// @inheritdoc ISuperVaultAggregator
    function getUpkeepBalance(
        address manager
    ) external view returns (uint256 balance) {
        return _managerUpkeepBalance[manager];
    }

    /// @notice Gets the current stake balance for a manager
    /// @param manager Address of the manager
    /// @return balance Current stake balance in UP tokens
    function getStakeBalance(
        address manager
    ) external view returns (uint256 balance) {
        return _managerStakeBalance[manager];
    }

    /// @inheritdoc ISuperVaultAggregator
    function getAuthorizedCallers(
        address strategy
    ) external view returns (address[] memory callers) {
        return _strategyData[strategy].authorizedCallers.values();
    }

    /// @inheritdoc ISuperVaultAggregator
    function getMainManager(
        address strategy
    ) external view returns (address manager) {
        manager = _strategyData[strategy].mainManager;
        if (manager == address(0)) revert ZERO_ADDRESS();

        return manager;
    }

    /// @inheritdoc ISuperVaultAggregator
    function isMainManager(
        address manager,
        address strategy
    ) external view returns (bool) {
        return _strategyData[strategy].mainManager == manager;
    }

    /// @inheritdoc ISuperVaultAggregator
    function getSecondaryManagers(
        address strategy
    ) external view returns (address[] memory) {
        return _strategyData[strategy].secondaryManagers.values();
    }

    /// @inheritdoc ISuperVaultAggregator
    function isSecondaryManager(
        address manager,
        address strategy
    ) external view returns (bool) {
        return _strategyData[strategy].secondaryManagers.contains(manager);
    }

    /// @inheritdoc ISuperVaultAggregator
    function isAnyManager(
        address manager,
        address strategy
    ) public view returns (bool) {
        // Check if primary manager
        if (_strategyData[strategy].mainManager == manager) {
            return true;
        }

        // Check if secondary manager using EnumerableSet
        return _strategyData[strategy].secondaryManagers.contains(manager);
    }

    /// @inheritdoc ISuperVaultAggregator
    function getAllSuperVaults() external view returns (address[] memory) {
        return _superVaults.values();
    }

    /// @inheritdoc ISuperVaultAggregator
    function superVaults(uint256 index) external view returns (address) {
        if (index >= _superVaults.length()) revert INDEX_OUT_OF_BOUNDS();
        return _superVaults.at(index);
    }

    /// @inheritdoc ISuperVaultAggregator
    function getAllSuperVaultStrategies()
        external
        view
        returns (address[] memory)
    {
        return _superVaultStrategies.values();
    }

    /// @inheritdoc ISuperVaultAggregator
    function superVaultStrategies(
        uint256 index
    ) external view returns (address) {
        if (index >= _superVaultStrategies.length())
            revert INDEX_OUT_OF_BOUNDS();
        return _superVaultStrategies.at(index);
    }

    /// @inheritdoc ISuperVaultAggregator
    function getAllSuperVaultEscrows()
        external
        view
        returns (address[] memory)
    {
        return _superVaultEscrows.values();
    }

    /// @inheritdoc ISuperVaultAggregator
    function superVaultEscrows(uint256 index) external view returns (address) {
        if (index >= _superVaultEscrows.length()) revert INDEX_OUT_OF_BOUNDS();
        return _superVaultEscrows.at(index);
    }

    /// @inheritdoc ISuperVaultAggregator
    function validateHook(
        address strategy,
        ValidateHookArgs calldata args
    ) external view virtual returns (bool isValid) {
        // Cache all state variables in struct
        HookValidationCache memory cache = HookValidationCache({
            globalHooksRootVetoed: _globalHooksRootVetoed,
            globalHooksRoot: _globalHooksRoot,
            strategyHooksRootVetoed: _strategyData[strategy].hooksRootVetoed,
            strategyRoot: _strategyData[strategy].managerHooksRoot
        });

        // Early return false if either global or strategy hooks root is vetoed
        if (cache.globalHooksRootVetoed || cache.strategyHooksRootVetoed) {
            return false;
        }

        // Try to validate against global root first
        if (
            _validateSingleHook(
                args.hookAddress,
                args.hookArgs,
                args.globalProof,
                true,
                cache,
                strategy
            )
        ) {
            return true;
        }

        // If global validation fails, try strategy root
        return
            _validateSingleHook(
                args.hookAddress,
                args.hookArgs,
                args.strategyProof,
                false,
                cache,
                strategy
            );
    }

    /// @inheritdoc ISuperVaultAggregator
    function validateHooks(
        address strategy,
        ValidateHookArgs[] calldata argsArray
    ) external view returns (bool[] memory validHooks) {
        uint256 length = argsArray.length;

        // Cache all state variables in struct
        HookValidationCache memory cache = HookValidationCache({
            globalHooksRootVetoed: _globalHooksRootVetoed,
            globalHooksRoot: _globalHooksRoot,
            strategyHooksRootVetoed: _strategyData[strategy].hooksRootVetoed,
            strategyRoot: _strategyData[strategy].managerHooksRoot
        });

        // Early return all false if either global or strategy hooks root is vetoed
        if (cache.globalHooksRootVetoed || cache.strategyHooksRootVetoed) {
            return new bool[](length); // Array initialized with all false values
        }

        // Validate each hook
        validHooks = new bool[](length);
        for (uint256 i; i < length; i++) {
            // Try global root first
            if (
                _validateSingleHook(
                    argsArray[i].hookAddress,
                    argsArray[i].hookArgs,
                    argsArray[i].globalProof,
                    true,
                    cache,
                    strategy
                )
            ) {
                validHooks[i] = true;
            } else {
                // Try strategy root
                validHooks[i] = _validateSingleHook(
                    argsArray[i].hookAddress,
                    argsArray[i].hookArgs,
                    argsArray[i].strategyProof,
                    false,
                    cache,
                    strategy
                );
            }
            // If both conditions fail, validHooks[i] remains false (default value)
        }

        return validHooks;
    }

    /// @inheritdoc ISuperVaultAggregator
    function getGlobalHooksRoot() external view returns (bytes32 root) {
        return _globalHooksRoot;
    }

    /// @inheritdoc ISuperVaultAggregator
    function getProposedGlobalHooksRoot()
        external
        view
        returns (bytes32 root, uint256 effectiveTime)
    {
        return (_proposedGlobalHooksRoot, _globalHooksRootEffectiveTime);
    }

    /// @notice Checks if the global hooks root is active (timelock period has passed)
    /// @return isActive True if the global hooks root is active
    function isGlobalHooksRootActive() external view returns (bool) {
        return
            block.timestamp >= _globalHooksRootEffectiveTime &&
            _globalHooksRoot != bytes32(0);
    }

    /// @inheritdoc ISuperVaultAggregator
    function getStrategyHooksRoot(
        address strategy
    ) external view returns (bytes32 root) {
        return _strategyData[strategy].managerHooksRoot;
    }

    /// @inheritdoc ISuperVaultAggregator
    function getProposedStrategyHooksRoot(
        address strategy
    ) external view returns (bytes32 root, uint256 effectiveTime) {
        return (
            _strategyData[strategy].proposedHooksRoot,
            _strategyData[strategy].hooksRootEffectiveTime
        );
    }

    /*//////////////////////////////////////////////////////////////
                         INTERNAL HELPER FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    /// @notice Internal implementation of forwarding PPS updates
    /// @param args Struct containing all parameters for PPS update
    function _forwardPPS(PPSUpdateData memory args) internal {
        // Check rate limiting
        uint256 minInterval = _strategyData[args.strategy].minUpdateInterval;
        uint256 lastUpdate = _strategyData[args.strategy].lastUpdateTimestamp;
        if (block.timestamp - lastUpdate < minInterval) {
            emit UpdateTooFrequent();
            return;
        }

        // Ensure timestamp is monotonically increasing to prevent out-of-order updates
        if (args.timestamp <= lastUpdate) {
            emit TimestampNotMonotonic();
            return;
        }

        // Get the strategy's manager to deduct upkeep cost from
        address manager = _strategyData[args.strategy].mainManager;

        // Flag to track if any check failed
        bool checksFailed = false;

        // C2.1) Dispersion Check: Check if the standard deviation is too high relative to mean
        if (
            _strategyData[args.strategy].dispersionThreshold !=
            type(uint256).max &&
            args.pps > 0
        ) {
            // Calculate dispersion as stddev/mean
            uint256 dispersion = (args.ppsStdev * 1e18) / args.pps; // Scaled by 1e18 for precision
            if (dispersion > _strategyData[args.strategy].dispersionThreshold) {
                checksFailed = true;
                emit StrategyCheckFailed(args.strategy, "HIGH_PPS_DISPERSION");
            }
        }

        // C2.2) Deviation Check: Check if new PPS deviates too much from current PPS
        uint256 currentPPS = _strategyData[args.strategy].pps;
        if (
            _strategyData[args.strategy].deviationThreshold !=
            type(uint256).max &&
            currentPPS > 0
        ) {
            // Calculate absolute deviation, scaled by 1e18
            uint256 absDiff = args.pps > currentPPS
                ? (args.pps - currentPPS)
                : (currentPPS - args.pps);
            uint256 relativeDeviation = (absDiff * 1e18) / currentPPS;
            if (
                relativeDeviation >
                _strategyData[args.strategy].deviationThreshold
            ) {
                checksFailed = true;
                emit StrategyCheckFailed(args.strategy, "HIGH_PPS_DEVIATION");
            }
        }

        // C2.3) M/N Check: Check if enough validators participated
        if (
            args.totalValidators > 0 &&
            _strategyData[args.strategy].mnThreshold > 0
        ) {
            // Calculate participation rate, scaled by 1e18
            uint256 participationRate = (args.validatorSet * 1e18) /
                args.totalValidators;
            if (participationRate < _strategyData[args.strategy].mnThreshold) {
                checksFailed = true;
                emit StrategyCheckFailed(
                    args.strategy,
                    "INSUFFICIENT_VALIDATOR_PARTICIPATION"
                );
            }
        }

        // Pause strategy if any check failed
        if (checksFailed && !_strategyData[args.strategy].isPaused) {
            _strategyData[args.strategy].isPaused = true;
            emit StrategyPaused(args.strategy);
        }
        // Unpause strategy if all checks passed and strategy was previously paused
        else if (!checksFailed && _strategyData[args.strategy].isPaused) {
            _strategyData[args.strategy].isPaused = false;
            emit StrategyUnpaused(args.strategy);
        }

        // Handle upkeep costs unless exempt
        if (!args.isExempt) {
            // Check if manager has sufficient upkeep balance
            if (_managerUpkeepBalance[manager] < args.upkeepCost) {
                emit InsufficientUpkeep(
                    args.strategy,
                    manager,
                    _managerUpkeepBalance[manager],
                    args.upkeepCost
                );
                return;
            }

            // Deduct the upkeep cost and emit event
            _managerUpkeepBalance[manager] -= args.upkeepCost;

            // Add claimable upkeep for the `feeRecipient`
            claimableUpkeep += args.upkeepCost;

            emit UpkeepSpent(manager, args.upkeepCost);
        }

        // Update PPS, ppsStdev and timestamp in StrategyData
        _strategyData[args.strategy].pps = args.pps;
        _strategyData[args.strategy].ppsStdev = args.ppsStdev;
        _strategyData[args.strategy].lastUpdateTimestamp = args.timestamp;

        emit PPSUpdated(
            args.strategy,
            args.pps,
            args.ppsStdev,
            args.validatorSet,
            args.totalValidators,
            args.timestamp
        );
    }

    /// @notice Check if an update authority is exempt from paying upkeep costs
    /// @param strategy Address of the strategy being updated
    /// @param updateAuthority Address initiating the update
    /// @param timestamp Timestamp of the PPS measurement
    /// @return isExempt True if the authority is exempt from paying upkeep
    function _isExemptFromUpkeep(
        address strategy,
        address updateAuthority,
        uint256 timestamp
    ) internal returns (bool) {
        // Check if upkeep payments are globally disabled in SuperGovernor
        if (!SUPER_GOVERNOR.isUpkeepPaymentsEnabled()) {
            return true;
        }

        // Update is exempt if it is stale
        if (
            block.timestamp - timestamp > _strategyData[strategy].maxStaleness
        ) {
            emit StaleUpdate(strategy, updateAuthority, timestamp);
            return true;
        }

        // If manager is a superform manager, they're exempt from upkeep fees
        address manager = _strategyData[strategy].mainManager;
        if (SUPER_GOVERNOR.isSuperformManager(manager)) {
            return true;
        }

        // Check if the updateAuthority is in the authorized callers list
        // These are manager-designated keepers that should be exempt from fees
        // NOTE: Protected keepers cannot be added to this list (blocked in addAuthorizedCaller)
        if (
            _strategyData[strategy].authorizedCallers.contains(updateAuthority)
        ) {
            return true;
        }

        return false;
    }

    /// @notice Creates a leaf node for Merkle verification from hook address and arguments
    /// @param hookAddress The address of the hook contract
    /// @param hookArgs The packed-encoded hook arguments (from solidityPack in JS)
    /// @return leaf The leaf node hash
    function _createLeaf(
        address hookAddress,
        bytes calldata hookArgs
    ) internal pure returns (bytes32) {
        /// @dev The leaf now includes both hook address and args to prevent cross-hook replay attacks
        /// @dev Different hooks with identical encoded args will have different authorization leaves
        /// @dev This matches StandardMerkleTree's standardLeafHash: keccak256(keccak256(abi.encode(hookAddress,
        /// hookArgs)))
        /// @dev but uses bytes.concat for explicit concatenation
        return
            keccak256(
                bytes.concat(keccak256(abi.encode(hookAddress, hookArgs)))
            );
    }

    /**
     * @dev Internal function to validate a single hook against either global or strategy root
     * @param hookAddress The address of the hook contract
     * @param hookArgs Hook arguments
     * @param proof Merkle proof for the specified root
     * @param isGlobalProof Whether to validate against global root (true) or strategy root (false)
     * @param cache Cached hook validation state variables
     * @param strategy Address of the strategy (needed to check banned leaves for global proofs)
     * @return True if hook is valid, false otherwise
     */
    function _validateSingleHook(
        address hookAddress,
        bytes calldata hookArgs,
        bytes32[] calldata proof,
        bool isGlobalProof,
        HookValidationCache memory cache,
        address strategy
    ) internal view returns (bool) {
        // Create leaf node from the hook address and arguments
        bytes32 leaf = _createLeaf(hookAddress, hookArgs);

        if (isGlobalProof) {
            // Validate against global root
            if (
                cache.globalHooksRootVetoed ||
                cache.globalHooksRoot == bytes32(0)
            ) {
                return false;
            }

            // Check if this leaf is banned by the manager
            if (_strategyData[strategy].bannedLeaves[leaf]) {
                return false;
            }

            // For single-leaf trees, empty proof is valid when root equals leaf
            if (proof.length == 0) {
                return cache.globalHooksRoot == leaf;
            }
            return MerkleProof.verify(proof, cache.globalHooksRoot, leaf);
        } else {
            // Validate against strategy root
            if (
                cache.strategyHooksRootVetoed ||
                cache.strategyRoot == bytes32(0)
            ) {
                return false;
            }
            // For single-leaf trees, empty proof is valid when root equals leaf
            if (proof.length == 0) {
                return cache.strategyRoot == leaf;
            }
            return MerkleProof.verify(proof, cache.strategyRoot, leaf);
        }
    }

    /**
     * @dev Internal function to return the `SuperBank` address
     * @return superBank The superBank address
     */
    function _getSuperBank() internal view returns (address) {
        return SUPER_GOVERNOR.getAddress(SUPER_GOVERNOR.SUPER_BANK());
    }
}


80.0% src/SuperVault/SuperVaultEscrow.sol

Lines covered: 12 / 15 (80.0%)

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.30;

import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

/// @title SuperVaultEscrow
/// @author Superform Labs
/// @notice Escrow contract for SuperVault shares during request/claim process
contract SuperVaultEscrow {
    using SafeERC20 for IERC20;

    /*//////////////////////////////////////////////////////////////
                                ERRORS
    //////////////////////////////////////////////////////////////*/
    error ALREADY_INITIALIZED();
    error UNAUTHORIZED();
    error ZERO_ADDRESS();

    /*//////////////////////////////////////////////////////////////
                                STATE
    //////////////////////////////////////////////////////////////*/
    bool public initialized;
    address public vault;
    address public strategy;

    /*//////////////////////////////////////////////////////////////
                                MODIFIERS
    //////////////////////////////////////////////////////////////*/
    modifier onlyVault() {
        if (msg.sender != vault) revert UNAUTHORIZED();
        _;
    }

    /*//////////////////////////////////////////////////////////////
                            INITIALIZATION
    //////////////////////////////////////////////////////////////*/

    /// @notice Initialize the escrow with required parameters
    /// @param vaultAddress The vault contract address
    /// @param strategyAddress The strategy contract address
    function initialize(address vaultAddress, address strategyAddress) external {
        if (initialized) revert ALREADY_INITIALIZED();
        if (vaultAddress == address(0) || strategyAddress == address(0)) revert ZERO_ADDRESS();

        initialized = true;
        vault = vaultAddress;
        strategy = strategyAddress;
    }

    /*//////////////////////////////////////////////////////////////
                            VAULT FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    /// @notice Transfer shares from user to escrow during redeem request
    /// @param from The address to transfer shares from
    /// @param amount The amount of shares to transfer
    function escrowShares(address from, uint256 amount) external onlyVault {
        IERC20(vault).safeTransferFrom(from, address(this), amount);
    }

    /// @notice Return shares from escrow to user during redeem cancellation
    /// @param to The address to return shares to
    /// @param amount The amount of shares to return
    function returnShares(address to, uint256 amount) external onlyVault {
        IERC20(vault).safeTransfer(to, amount);
    }
}


88.0% src/SuperVault/SuperVaultStrategy.sol

Lines covered: 583 / 661 (88.0%)

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.30;

// External
import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
import {ReentrancyGuardUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import {IERC4626} from "@openzeppelin/contracts/interfaces/IERC4626.sol";
import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";

// Core Interfaces
import {ISuperHook, ISuperHookResult, ISuperHookOutflow, ISuperHookInflowOutflow, ISuperHookResultOutflow, ISuperHookContextAware, ISuperHookInspector} from "@superform-v2-core/src/interfaces/ISuperHook.sol";
import {IYieldSourceOracle} from "@superform-v2-core/src/interfaces/accounting/IYieldSourceOracle.sol";

// Periphery Interfaces
import {ISuperVault} from "../interfaces/SuperVault/ISuperVault.sol";
import {HookDataDecoder} from "@superform-v2-core/src/libraries/HookDataDecoder.sol";
import {ISuperVaultStrategy} from "../interfaces/SuperVault/ISuperVaultStrategy.sol";
import {ISuperGovernor, FeeType} from "../interfaces/ISuperGovernor.sol";
import {ISuperVaultAggregator} from "../interfaces/SuperVault/ISuperVaultAggregator.sol";

/// @title SuperVaultStrategy
/// @author Superform Labs
/// @notice Strategy implementation for SuperVault that executes strategies
contract SuperVaultStrategy is
    ISuperVaultStrategy,
    Initializable,
    ReentrancyGuardUpgradeable
{
    using EnumerableSet for EnumerableSet.AddressSet;
    using SafeERC20 for IERC20;
    using Math for uint256;

    /*//////////////////////////////////////////////////////////////
                                CONSTANTS
    //////////////////////////////////////////////////////////////*/
    uint256 private constant ONE_WEEK = 7 days;
    uint256 private constant BPS_PRECISION = 10_000;
    /// @dev The following is needed because the `processedShares` for some vaults (for example Centrifuge)
    ///      can be lower by 1 or 2 wei than the `totalRequestedAmount`in SuperVault shares
    uint256 private constant TOLERANCE_CONSTANT = 10 wei;

    // Slippage tolerance in BPS (1%)
    uint256 private constant SV_SLIPPAGE_TOLERANCE_BPS = 100;

    uint256 public PRECISION;

    /*//////////////////////////////////////////////////////////////
                                STATE
    //////////////////////////////////////////////////////////////*/
    address private _vault;
    IERC20 private _asset;
    uint8 private _vaultDecimals;

    // Global configuration
    uint256 private _maxPPSSlippage;

    // Fee configuration
    FeeConfig private feeConfig;
    FeeConfig private proposedFeeConfig;
    uint256 private feeConfigEffectiveTime;

    // Core contracts
    ISuperGovernor public immutable superGovernor;

    // Emergency withdrawable configuration
    bool public emergencyWithdrawable;
    bool public proposedEmergencyWithdrawable;
    uint256 public emergencyWithdrawableEffectiveTime;

    // Yield source configuration - simplified mapping from source to oracle
    mapping(address source => address oracle) private yieldSources;
    EnumerableSet.AddressSet private yieldSourcesList;

    // --- Redeem Request State ---
    mapping(address controller => SuperVaultState state)
        private superVaultState;

    constructor(address superGovernor_) {
        if (superGovernor_ == address(0)) revert ZERO_ADDRESS();

        superGovernor = ISuperGovernor(superGovernor_);
        emit SuperGovernorSet(superGovernor_);
        _disableInitializers();
    }

    /// @notice Allows the contract to receive native ETH
    /// @dev Required for hooks that may send ETH back to the strategy
    receive() external payable {}

    /*//////////////////////////////////////////////////////////////
                            INITIALIZATION
    //////////////////////////////////////////////////////////////*/
    function initialize(
        address vaultAddress,
        FeeConfig memory feeConfigData
    ) external initializer {
        if (vaultAddress == address(0)) revert INVALID_VAULT();
        // if either fee is configured, check if recipient is address (0), if it is revert with ZERO ADDRESS
        // if both fees are 0, no need check address (it just passes the if). Recipient can be configured later
        if (
            (feeConfigData.performanceFeeBps > 0 ||
                feeConfigData.managementFeeBps > 0) &&
            feeConfigData.recipient == address(0)
        ) revert ZERO_ADDRESS();
        if (feeConfigData.performanceFeeBps > BPS_PRECISION)
            revert INVALID_PERFORMANCE_FEE_BPS();
        if (feeConfigData.managementFeeBps > BPS_PRECISION)
            revert INVALID_PERFORMANCE_FEE_BPS();

        __ReentrancyGuard_init();

        _vault = vaultAddress;
        _asset = IERC20(IERC4626(vaultAddress).asset());
        _vaultDecimals = IERC20Metadata(vaultAddress).decimals();
        PRECISION = 10 ** _vaultDecimals;
        feeConfig = feeConfigData;
        _maxPPSSlippage = 500; // 5% as a start, configurable later

        emit Initialized(_vault);
    }

    /*//////////////////////////////////////////////////////////////
                        CORE STRATEGY OPERATIONS
    //////////////////////////////////////////////////////////////*/

    /// @inheritdoc ISuperVaultStrategy
    function handleOperations4626Deposit(
        address controller,
        uint256 assetsGross
    ) external returns (uint256 sharesNet) {
        _requireVault();

        if (assetsGross == 0) revert INVALID_AMOUNT();
        if (controller == address(0)) revert ZERO_ADDRESS();

        // Check if strategy is paused or if global hooks root is vetoed
        if (_isPaused()) revert STRATEGY_PAUSED();
        if (_getSuperVaultAggregator().isGlobalHooksRootVetoed()) {
            revert OPERATIONS_BLOCKED_BY_VETO();
        }

        // Fee skim in ASSETS (asset-side entry fee)
        uint256 feeBps = feeConfig.managementFeeBps;
        uint256 feeAssets = feeBps == 0
            ? 0
            : Math.mulDiv(
                assetsGross,
                feeBps,
                BPS_PRECISION,
                Math.Rounding.Ceil
            );

        uint256 assetsNet = assetsGross - feeAssets;
        if (assetsNet == 0) revert INVALID_AMOUNT();

        if (feeAssets != 0) {
            address recipient = feeConfig.recipient;
            if (recipient == address(0)) revert ZERO_ADDRESS();
            _safeTokenTransfer(address(_asset), recipient, feeAssets);
            emit ManagementFeePaid(controller, recipient, feeAssets, feeBps);
        }

        // Compute shares on NET using current PPS
        uint256 pps = getStoredPPS();
        if (pps == 0) revert INVALID_PPS();
        sharesNet = Math.mulDiv(assetsNet, PRECISION, pps, Math.Rounding.Floor);
        if (sharesNet == 0) revert INVALID_AMOUNT();

        // Account on NET
        SuperVaultState storage state = superVaultState[controller];
        state.accumulatorShares += sharesNet;
        state.accumulatorCostBasis += assetsNet;
        emit DepositHandled(controller, assetsNet, sharesNet);
        return sharesNet;
    }

    /// @inheritdoc ISuperVaultStrategy
    function handleOperations4626Mint(
        address controller,
        uint256 sharesNet,
        uint256 assetsGross,
        uint256 assetsNet
    ) external {
        _requireVault();

        if (sharesNet == 0) revert INVALID_AMOUNT();
        if (controller == address(0)) revert ZERO_ADDRESS();

        // Check if strategy is paused or if global hooks root is vetoed
        if (_isPaused()) revert STRATEGY_PAUSED();
        if (_getSuperVaultAggregator().isGlobalHooksRootVetoed()) {
            revert OPERATIONS_BLOCKED_BY_VETO();
        }

        uint256 feeBps = feeConfig.managementFeeBps;
        // Transfer fee if needed
        if (feeBps != 0) {
            uint256 feeAssets = assetsGross - assetsNet;
            if (feeAssets != 0) {
                address recipient = feeConfig.recipient;
                if (recipient == address(0)) revert ZERO_ADDRESS();
                _safeTokenTransfer(address(_asset), recipient, feeAssets);
                emit ManagementFeePaid(
                    controller,
                    recipient,
                    feeAssets,
                    feeBps
                );
            }
        }

        // Account on NET
        SuperVaultState storage state = superVaultState[controller];
        state.accumulatorShares += sharesNet;
        state.accumulatorCostBasis += assetsNet;
        emit DepositHandled(controller, assetsNet, sharesNet);
    }

    /// @inheritdoc ISuperVaultStrategy
    function quoteMintAssetsGross(
        uint256 shares
    ) external view returns (uint256 assetsGross, uint256 assetsNet) {
        uint256 pps = getStoredPPS();
        if (pps == 0) revert INVALID_PPS();
        assetsNet = Math.mulDiv(shares, pps, PRECISION, Math.Rounding.Ceil);
        if (assetsNet == 0) revert INVALID_AMOUNT();

        uint256 feeBps = feeConfig.managementFeeBps;
        if (feeBps == 0) return (assetsNet, assetsNet);
        if (feeBps >= BPS_PRECISION) revert INVALID_AMOUNT(); // prevents div-by-zero (100% fee)
        assetsGross = Math.mulDiv(
            assetsNet,
            BPS_PRECISION,
            (BPS_PRECISION - feeBps),
            Math.Rounding.Ceil
        );
        return (assetsGross, assetsNet);
    }

    /// @inheritdoc ISuperVaultStrategy
    function handleOperations7540(
        Operation operation,
        address controller,
        address receiver,
        uint256 amount
    ) external {
        _requireVault();
        if (operation == Operation.RedeemRequest) {
            _handleRequestRedeem(controller, amount); // amount = shares
        } else if (operation == Operation.CancelRedeem) {
            _handleCancelRedeem(controller);
        } else if (operation == Operation.ClaimRedeem) {
            _handleClaimRedeem(controller, receiver, amount); // amount = assets
        } else {
            revert ACTION_TYPE_DISALLOWED();
        }
    }

    /*//////////////////////////////////////////////////////////////
                MANAGER EXTERNAL ACCESS FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    /// @inheritdoc ISuperVaultStrategy
    function executeHooks(
        ExecuteArgs calldata args
    ) external payable nonReentrant {
        _isManager(msg.sender);

        uint256 hooksLength = args.hooks.length;
        if (hooksLength == 0) revert ZERO_LENGTH();
        if (args.hookCalldata.length != hooksLength)
            revert INVALID_ARRAY_LENGTH();
        if (args.expectedAssetsOrSharesOut.length != hooksLength)
            revert INVALID_ARRAY_LENGTH();
        if (args.globalProofs.length != hooksLength)
            revert INVALID_ARRAY_LENGTH();
        if (args.strategyProofs.length != hooksLength)
            revert INVALID_ARRAY_LENGTH();

        address prevHook;
        for (uint256 i; i < hooksLength; ++i) {
            address hook = args.hooks[i];
            if (!_isRegisteredHook(hook)) revert INVALID_HOOK();

            // Check if the hook was validated
            if (
                !_validateHook(
                    hook,
                    args.hookCalldata[i],
                    args.globalProofs[i],
                    args.strategyProofs[i]
                )
            ) {
                revert HOOK_VALIDATION_FAILED();
            }

            prevHook = _processSingleHookExecution(
                hook,
                prevHook,
                args.hookCalldata[i],
                args.expectedAssetsOrSharesOut[i]
            );
        }
        emit HooksExecuted(args.hooks);
    }

    /// @inheritdoc ISuperVaultStrategy
    function fulfillRedeemRequests(
        FulfillArgs calldata args
    ) external nonReentrant {
        _isManager(msg.sender);

        // Check if strategy is paused
        if (_isPaused()) revert STRATEGY_PAUSED();

        uint256 hooksLength = args.hooks.length;
        if (hooksLength == 0) revert ZERO_LENGTH();
        uint256 controllersLength = args.controllers.length;
        if (controllersLength == 0) revert ZERO_LENGTH();
        if (args.hookCalldata.length != hooksLength)
            revert INVALID_ARRAY_LENGTH();
        if (args.expectedAssetsOrSharesOut.length != hooksLength)
            revert INVALID_ARRAY_LENGTH();
        if (args.globalProofs.length != hooksLength)
            revert INVALID_ARRAY_LENGTH();
        if (args.strategyProofs.length != hooksLength)
            revert INVALID_ARRAY_LENGTH();

        uint256 currentPPS = getStoredPPS();
        if (currentPPS == 0) revert INVALID_PPS();

        // Pre-calculate totals to ensure no overburn of escrowed shares
        uint256 totalRequestedShares;
        for (uint256 i; i < controllersLength; ++i) {
            totalRequestedShares += superVaultState[args.controllers[i]]
                .pendingRedeemRequest;
        }
        uint256 intendedShares;
        for (uint256 i; i < hooksLength; ++i) {
            address hook = args.hooks[i];
            if (!_isFulfillRequestsHook(hook)) revert INVALID_HOOK();
            // Check if the hook was validated
            if (
                !_validateHook(
                    hook,
                    args.hookCalldata[i],
                    args.globalProofs[i],
                    args.strategyProofs[i]
                )
            ) {
                revert HOOK_VALIDATION_FAILED();
            }
            if (args.expectedAssetsOrSharesOut[i] == 0)
                revert ZERO_EXPECTED_VALUE();

            intendedShares += ISuperHookInflowOutflow(hook).decodeAmount(
                args.hookCalldata[i]
            );
        }

        // Enforce both lower- and upper-bounds on intended shares to prevent escrow overburn
        if (intendedShares + TOLERANCE_CONSTANT < totalRequestedShares) {
            revert INVALID_REDEEM_FILL();
        }

        if (intendedShares > totalRequestedShares + TOLERANCE_CONSTANT) {
            revert INVALID_REDEEM_FILL();
        }

        uint256 processedShares;
        for (uint256 i; i < hooksLength; ++i) {
            address hook = args.hooks[i];
            uint256 amountSharesSpent = _processSingleFulfillHookExecution(
                hook,
                args.hookCalldata[i],
                args.expectedAssetsOrSharesOut[i],
                currentPPS
            );
            processedShares += amountSharesSpent;
        }

        // Post-condition: processed shares must match intended shares
        if (processedShares != intendedShares) revert INVALID_REDEEM_FILL();

        _processRedeemFulfillments(
            args.controllers,
            controllersLength,
            processedShares,
            currentPPS
        );

        ISuperVault(_vault).burnShares(processedShares);

        emit RedeemRequestsFulfilled(
            args.hooks,
            args.controllers,
            processedShares,
            currentPPS
        );
    }

    /*//////////////////////////////////////////////////////////////
                        YIELD SOURCE MANAGEMENT
    //////////////////////////////////////////////////////////////*/

    // @inheritdoc ISuperVaultStrategy
    function manageYieldSource(
        address source,
        address oracle,
        uint8 actionType
    ) external {
        _isPrimaryManager(msg.sender);
        _manageYieldSource(source, oracle, actionType);
    }

    // @inheritdoc ISuperVaultStrategy
    function manageYieldSources(
        address[] calldata sources,
        address[] calldata oracles,
        uint8[] calldata actionTypes
    ) external {
        _isPrimaryManager(msg.sender);

        uint256 length = sources.length;
        if (length == 0) revert ZERO_LENGTH();
        if (oracles.length != length) revert INVALID_ARRAY_LENGTH();
        if (actionTypes.length != length) revert INVALID_ARRAY_LENGTH();

        for (uint256 i; i < length; ++i) {
            _manageYieldSource(sources[i], oracles[i], actionTypes[i]);
        }
    }

    // @inheritdoc ISuperVaultStrategy
    function proposeVaultFeeConfigUpdate(
        uint256 performanceFeeBps,
        uint256 managementFeeBps,
        address recipient
    ) external {
        _isPrimaryManager(msg.sender);

        if (performanceFeeBps > BPS_PRECISION)
            revert INVALID_PERFORMANCE_FEE_BPS();
        if (managementFeeBps > BPS_PRECISION)
            revert INVALID_PERFORMANCE_FEE_BPS();
        if (recipient == address(0)) revert ZERO_ADDRESS();
        proposedFeeConfig = FeeConfig({
            performanceFeeBps: performanceFeeBps,
            managementFeeBps: managementFeeBps,
            recipient: recipient
        });
        feeConfigEffectiveTime = block.timestamp + ONE_WEEK;
        emit VaultFeeConfigProposed(
            performanceFeeBps,
            managementFeeBps,
            recipient,
            feeConfigEffectiveTime
        );
    }

    // @inheritdoc ISuperVaultStrategy
    function executeVaultFeeConfigUpdate() external {
        if (block.timestamp < feeConfigEffectiveTime)
            revert INVALID_TIMESTAMP();
        if (proposedFeeConfig.recipient == address(0)) revert ZERO_ADDRESS();
        feeConfig = proposedFeeConfig;
        delete proposedFeeConfig;
        feeConfigEffectiveTime = 0;
        emit VaultFeeConfigUpdated(
            feeConfig.performanceFeeBps,
            feeConfig.managementFeeBps,
            feeConfig.recipient
        );
    }

    // @inheritdoc ISuperVaultStrategy
    function updateMaxPPSSlippage(uint256 maxSlippageBps) external {
        _isPrimaryManager(msg.sender);
        if (maxSlippageBps > BPS_PRECISION) revert INVALID_MAX_SLIPPAGE_BPS();
        _maxPPSSlippage = maxSlippageBps;
        emit MaxPPSSlippageUpdated(maxSlippageBps);
    }

    // @inheritdoc ISuperVaultStrategy
    function manageEmergencyWithdraw(
        uint8 action,
        address recipient,
        uint256 amount
    ) external {
        if (action == 1) {
            _proposeEmergencyWithdraw();
        } else if (action == 2) {
            _executeEmergencyWithdrawActivation();
        } else if (action == 3) {
            _performEmergencyWithdraw(recipient, amount);
        } else if (action == 4) {
            _cancelEmergencyWithdrawProposal();
        } else {
            revert ACTION_TYPE_DISALLOWED();
        }
    }

    /*//////////////////////////////////////////////////////////////
                        ACCOUNTING MANAGEMENT
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperVaultStrategy
    function moveAccumulatorOnTransfer(
        address from,
        address to,
        uint256 shares
    ) external {
        _requireVault();
        if (shares == 0) return;

        SuperVaultState storage fromState = superVaultState[from];
        SuperVaultState storage toState = superVaultState[to];

        // Only move accumulator proportional to what's available
        // (accumulator shares may be less than ERC20 shares due to pending redeems)
        // see test_Fix1_AuditAttackScenarioFails
        uint256 availableAccumulatorShares = fromState.accumulatorShares;
        if (availableAccumulatorShares == 0) return; // No accumulator to move

        uint256 sharesToMove = shares > availableAccumulatorShares
            ? availableAccumulatorShares
            : shares;

        // Pro-rata move of cost basis (NO PPS here; preserves fee correctness)
        uint256 movedCostBasis = sharesToMove == availableAccumulatorShares
            ? fromState.accumulatorCostBasis
            : Math.mulDiv(
                sharesToMove,
                fromState.accumulatorCostBasis,
                availableAccumulatorShares,
                Math.Rounding.Floor
            ); /// @audit is there a value st when transfered transfers minimal shares and maximum cost basis

        fromState.accumulatorShares -= sharesToMove;
        fromState.accumulatorCostBasis -= movedCostBasis;

        toState.accumulatorShares += sharesToMove;
        toState.accumulatorCostBasis += movedCostBasis;

        // Never touch: pendingRedeemRequest, averageRequestPPS, maxWithdraw, averageWithdrawPrice
    }

    /*//////////////////////////////////////////////////////////////
                            VIEW FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    // @inheritdoc ISuperVaultStrategy
    function getVaultInfo()
        external
        view
        returns (address vault, address asset, uint8 vaultDecimals)
    {
        vault = _vault;
        asset = address(_asset);
        vaultDecimals = _vaultDecimals;
    }

    // @inheritdoc ISuperVaultStrategy
    function getConfigInfo()
        external
        view
        returns (FeeConfig memory feeConfig_)
    {
        feeConfig_ = feeConfig;
    }

    // @inheritdoc ISuperVaultStrategy
    function getStoredPPS() public view returns (uint256) {
        return _getSuperVaultAggregator().getPPS(address(this));
    }

    // @inheritdoc ISuperVaultStrategy
    function getSuperVaultState(
        address controller
    ) external view returns (SuperVaultState memory state) {
        return superVaultState[controller];
    }

    // @inheritdoc ISuperVaultStrategy
    function getYieldSource(
        address source
    ) external view returns (YieldSource memory) {
        return YieldSource({oracle: yieldSources[source]});
    }

    // @inheritdoc ISuperVaultStrategy
    function getYieldSourcesList()
        external
        view
        returns (YieldSourceInfo[] memory)
    {
        uint256 length = yieldSourcesList.length();
        YieldSourceInfo[] memory sourcesInfo = new YieldSourceInfo[](length);

        for (uint256 i; i < length; ++i) {
            address sourceAddress = yieldSourcesList.at(i);
            address oracle = yieldSources[sourceAddress];

            sourcesInfo[i] = YieldSourceInfo({
                sourceAddress: sourceAddress,
                oracle: oracle
            });
        }

        return sourcesInfo;
    }

    // @inheritdoc ISuperVaultStrategy
    function getYieldSources() external view returns (address[] memory) {
        return yieldSourcesList.values();
    }

    // @inheritdoc ISuperVaultStrategy
    function getYieldSourcesCount() external view returns (uint256) {
        return yieldSourcesList.length();
    }

    // @inheritdoc ISuperVaultStrategy
    function containsYieldSource(address source) external view returns (bool) {
        return yieldSourcesList.contains(source);
    }

    // @inheritdoc ISuperVaultStrategy
    function pendingRedeemRequest(
        address controller
    ) external view returns (uint256 pendingShares) {
        return superVaultState[controller].pendingRedeemRequest;
    }

    // @inheritdoc ISuperVaultStrategy
    function claimableWithdraw(
        address controller
    ) external view returns (uint256 claimableAssets) {
        return superVaultState[controller].maxWithdraw;
    }

    // @inheritdoc ISuperVaultStrategy
    function getAverageWithdrawPrice(
        address controller
    ) external view returns (uint256 averageWithdrawPrice) {
        return superVaultState[controller].averageWithdrawPrice;
    }

    // @inheritdoc ISuperVaultStrategy
    function previewPerformanceFee(
        address controller,
        uint256 sharesToRedeem
    )
        external
        view
        returns (uint256 totalFee, uint256 superformFee, uint256 recipientFee)
    {
        if (sharesToRedeem == 0) return (0, 0, 0);

        // Get controller's state
        SuperVaultState storage state = superVaultState[controller];

        // Check if controller has enough shares
        if (sharesToRedeem > state.accumulatorShares) return (0, 0, 0);

        // Get the current price per share
        uint256 currentPPS = getStoredPPS();

        // Calculate historical assets (cost basis)
        uint256 historicalAssets = 0;
        if (state.accumulatorShares > 0) {
            historicalAssets = sharesToRedeem.mulDiv(
                state.accumulatorCostBasis,
                state.accumulatorShares,
                Math.Rounding.Floor
            );
        }

        // Calculate current value of shares in asset terms
        uint256 currentAssetsWithFees = sharesToRedeem.mulDiv(
            currentPPS,
            PRECISION,
            Math.Rounding.Floor
        );

        // Calculate fee (if any) using same logic as _calculateAndTransferFee
        if (currentAssetsWithFees > historicalAssets) {
            uint256 profit = currentAssetsWithFees - historicalAssets;
            uint256 performanceFeeBps = feeConfig.performanceFeeBps;
            totalFee = profit.mulDiv(
                performanceFeeBps,
                BPS_PRECISION,
                Math.Rounding.Floor
            );

            if (totalFee > 0) {
                // Calculate Superform's portion of the fee using revenueShare from SuperGovernor
                superformFee = totalFee.mulDiv(
                    superGovernor.getFee(FeeType.SUPER_VAULT_PERFORMANCE_FEE),
                    BPS_PRECISION,
                    Math.Rounding.Floor
                );
                recipientFee = totalFee - superformFee;
            }
        }

        return (totalFee, superformFee, recipientFee);
    }

    /*//////////////////////////////////////////////////////////////
                        INTERNAL FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    /// @notice Process a single hook execution
    /// @param hook Hook address
    /// @param prevHook Previous hook address
    /// @param hookCalldata Hook calldata
    /// @param expectedAssetsOrSharesOut Expected assets or shares output
    /// @return processedHook Processed hook address
    function _processSingleHookExecution(
        address hook,
        address prevHook,
        bytes memory hookCalldata,
        uint256 expectedAssetsOrSharesOut
    ) internal returns (address) {
        ExecutionVars memory vars;
        vars.hookContract = ISuperHook(hook);

        vars.targetedYieldSource = HookDataDecoder.extractYieldSource(
            hookCalldata
        );
        if (yieldSources[vars.targetedYieldSource] == address(0))
            revert YIELD_SOURCE_NOT_FOUND();

        bool usePrevHookAmount = _decodeHookUsePrevHookAmount(
            hook,
            hookCalldata
        );
        if (usePrevHookAmount && prevHook != address(0)) {
            vars.outAmount = _getPreviousHookOutAmount(prevHook);
            if (expectedAssetsOrSharesOut == 0) revert ZERO_EXPECTED_VALUE();
            uint256 minExpectedPrevOut = expectedAssetsOrSharesOut *
                (BPS_PRECISION - _getSlippageTolerance());
            if (vars.outAmount * BPS_PRECISION < minExpectedPrevOut) {
                revert MINIMUM_PREVIOUS_HOOK_OUT_AMOUNT_NOT_MET();
            }
        }

        ISuperHook(address(vars.hookContract)).setExecutionContext(
            address(this)
        );
        vars.executions = vars.hookContract.build(
            prevHook,
            address(this),
            hookCalldata
        );
        for (uint256 j; j < vars.executions.length; ++j) {
            (vars.success, ) = vars.executions[j].target.call{
                value: vars.executions[j].value
            }(vars.executions[j].callData);
            if (!vars.success) revert OPERATION_FAILED();
        }
        ISuperHook(address(vars.hookContract)).resetExecutionState(
            address(this)
        );

        uint256 actualOutput = ISuperHookResult(hook).getOutAmount(
            address(this)
        );
        if (actualOutput == 0) revert ZERO_OUTPUT_AMOUNT();

        uint256 minExpectedOut = (expectedAssetsOrSharesOut *
            (BPS_PRECISION - _getSlippageTolerance())) / BPS_PRECISION;
        if (actualOutput < minExpectedOut) {
            revert MINIMUM_OUTPUT_AMOUNT_ASSETS_NOT_MET();
        }

        emit HookExecuted(
            hook,
            prevHook,
            vars.targetedYieldSource,
            usePrevHookAmount,
            hookCalldata
        );

        return hook;
    }

    /// @notice Process a single hook fulfillment execution
    /// @param hook Hook address
    /// @param hookCalldata Hook calldata
    /// @param expectedAssetOutput Expected asset output
    /// @param currentPPS Current price per share
    /// @return processedShares Processed shares
    function _processSingleFulfillHookExecution(
        address hook,
        bytes memory hookCalldata,
        uint256 expectedAssetOutput,
        uint256 currentPPS
    ) internal returns (uint256) {
        OutflowExecutionVars memory vars;
        vars.hookContract = ISuperHook(hook);
        vars.hookType = ISuperHookResult(hook).hookType();
        if (vars.hookType != ISuperHook.HookType.OUTFLOW)
            revert INVALID_HOOK_TYPE();

        vars.targetedYieldSource = HookDataDecoder.extractYieldSource(
            hookCalldata
        );
        if (yieldSources[vars.targetedYieldSource] == address(0))
            revert YIELD_SOURCE_NOT_FOUND();

        // we must always encode supervault shares when fulfilling redemptions
        vars.superVaultShares = ISuperHookInflowOutflow(hook).decodeAmount(
            hookCalldata
        );

        // Calculate underlying shares and update hook calldata
        vars.amountOfAssets = vars.superVaultShares.mulDiv(
            currentPPS,
            PRECISION,
            Math.Rounding.Floor
        );
        vars.svAsset = address(_asset);
        vars.amountConvertedToUnderlyingShares = IYieldSourceOracle(
            yieldSources[vars.targetedYieldSource]
        ).getShareOutput(
                vars.targetedYieldSource,
                vars.svAsset,
                vars.amountOfAssets
            );
        hookCalldata = ISuperHookOutflow(hook).replaceCalldataAmount(
            hookCalldata,
            vars.amountConvertedToUnderlyingShares
        );

        vars.balanceAssetBefore = _getTokenBalance(vars.svAsset, address(this));

        ISuperHook(address(vars.hookContract)).setExecutionContext(
            address(this)
        );

        vars.executions = vars.hookContract.build(
            address(0),
            address(this),
            hookCalldata
        );
        for (uint256 j; j < vars.executions.length; ++j) {
            (vars.success, ) = vars.executions[j].target.call(
                vars.executions[j].callData
            );
            if (!vars.success) revert OPERATION_FAILED();
        }
        ISuperHook(address(vars.hookContract)).resetExecutionState(
            address(this)
        );

        vars.outAmount =
            _getTokenBalance(vars.svAsset, address(this)) -
            vars.balanceAssetBefore;

        if (vars.outAmount == 0) revert ZERO_OUTPUT_AMOUNT();
        if (
            vars.outAmount * BPS_PRECISION <
            expectedAssetOutput * (BPS_PRECISION - _getSlippageTolerance())
        ) {
            revert MINIMUM_OUTPUT_AMOUNT_ASSETS_NOT_MET();
        }
        emit FulfillHookExecuted(hook, vars.targetedYieldSource, hookCalldata);

        return vars.superVaultShares;
    }

    /// @notice Process redeem fulfillments for multiple controllers
    /// @param controllers Array of controller addresses
    /// @param controllersLength Length of controllers array
    /// @param processedShares Total shares processed
    /// @param currentPPS Current price per share
    function _processRedeemFulfillments(
        address[] calldata controllers,
        uint256 controllersLength,
        uint256 processedShares,
        uint256 currentPPS
    ) internal {
        for (uint256 i; i < controllersLength; ++i) {
            SuperVaultState storage state = superVaultState[controllers[i]];

            uint256 crtControllerRequestedAmount = state.pendingRedeemRequest;
            // Check for PPS slippage if there's a recorded request PPS and max slippage is set
            if (state.averageRequestPPS > 0 && _maxPPSSlippage > 0) {
                uint256 averageRequestPPS = state.averageRequestPPS;
                // Calculate the percentage decrease from request PPS to current PPS
                if (currentPPS < averageRequestPPS) {
                    uint256 decrease = (
                        (averageRequestPPS - currentPPS).mulDiv(
                            BPS_PRECISION,
                            averageRequestPPS,
                            Math.Rounding.Floor
                        )
                    );
                    // If decrease exceeds maximum allowed slippage, revert
                    if (decrease > _maxPPSSlippage) revert SLIPPAGE_EXCEEDED();
                }
            }

            uint256 currentAssets = _calculateHistoricalAssetsAndProcessFees(
                state,
                crtControllerRequestedAmount,
                currentPPS
            );

            // Update user state, no partial redeems allowed
            state.pendingRedeemRequest = 0;
            state.maxWithdraw += currentAssets;
            state.averageRequestPPS = 0; // Reset PPS value after fulfillment

            // Call vault callback
            _onRedeemClaimable(
                controllers[i],
                currentAssets,
                crtControllerRequestedAmount,
                state.averageWithdrawPrice,
                state.accumulatorShares,
                state.accumulatorCostBasis
            );
        }
    }

    /// @notice Calculate historical assets and process fees
    /// @param state User's vault state
    /// @param requestedShares Shares being redeemed
    /// @param currentPricePerShare Current price per share
    function _calculateHistoricalAssetsAndProcessFees(
        SuperVaultState storage state,
        uint256 requestedShares,
        uint256 currentPricePerShare
    ) private returns (uint256 currentAssets) {
        // Calculate cost basis based on requested shares
        uint256 historicalAssets = _calculateCostBasis(state, requestedShares);
        uint256 currentAssetsWithFees;
        // Process fees and get final assets
        (currentAssetsWithFees, currentAssets) = _processFees(
            requestedShares,
            currentPricePerShare,
            historicalAssets
        );

        // Update average withdraw price if needed
        if (requestedShares > 0) {
            _updateAverageWithdrawPrice(
                state,
                requestedShares,
                currentAssetsWithFees
            );
        }

        return currentAssets;
    }

    /// @notice Calculate cost basis for requested shares using weighted average approach
    /// @param state User's vault state
    /// @param requestedShares Shares being redeemed
    function _calculateCostBasis(
        SuperVaultState storage state,
        uint256 requestedShares
    ) private returns (uint256 costBasis) {
        if (requestedShares > state.accumulatorShares)
            revert INSUFFICIENT_SHARES();

        // Calculate cost basis proportionally
        costBasis = requestedShares.mulDiv(
            state.accumulatorCostBasis,
            state.accumulatorShares,
            Math.Rounding.Floor
        );

        // Update user's accumulator state
        state.accumulatorShares -= requestedShares;
        state.accumulatorCostBasis -= costBasis;

        return costBasis;
    }

    // --- Fee Processing ---
    /// @notice Calculate and transfer fees based on profit
    /// @param requestedShares Shares being redeemed
    /// @param currentPricePerShare Current price per share
    /// @param historicalAssets Historical value of shares in assets
    /// @return currentAssetsWithFees Current value of shares in assets (not net of fees)
    /// @return currentAssets Current assets after fee deduction
    function _processFees(
        uint256 requestedShares,
        uint256 currentPricePerShare,
        uint256 historicalAssets
    ) private returns (uint256 currentAssetsWithFees, uint256 currentAssets) {
        // Calculate current value of the shares at current price
        currentAssetsWithFees = requestedShares.mulDiv(
            currentPricePerShare,
            PRECISION,
            Math.Rounding.Floor
        );

        // Apply fees only on profit
        currentAssets = _calculateAndTransferFee(
            currentAssetsWithFees,
            historicalAssets
        );

        // Ensure we don't exceed available balance
        uint256 balanceOfStrategy = _getTokenBalance(
            address(_asset),
            address(this)
        );
        currentAssets = currentAssets > balanceOfStrategy
            ? balanceOfStrategy
            : currentAssets;

        return (currentAssetsWithFees, currentAssets);
    }

    /// @notice Calculate fee on profit and transfer to recipient
    /// @param currentAssetsWithFees Current value of shares in assets (not net of fees)
    /// @param historicalAssets Historical value of shares in assets
    /// @return currentAssets Current assets after fee deduction
    function _calculateAndTransferFee(
        uint256 currentAssetsWithFees,
        uint256 historicalAssets
    ) private returns (uint256 currentAssets) {
        currentAssets = currentAssetsWithFees;
        if (currentAssetsWithFees > historicalAssets) {
            uint256 profit = currentAssetsWithFees - historicalAssets;
            uint256 performanceFeeBps = feeConfig.performanceFeeBps;
            uint256 totalFee = profit.mulDiv(
                performanceFeeBps,
                BPS_PRECISION,
                Math.Rounding.Floor
            );
            if (totalFee > 0) {
                // Calculate Superform's portion of the fee using revenueShare from SuperGovernor
                uint256 superformFee = totalFee.mulDiv(
                    superGovernor.getFee(FeeType.SUPER_VAULT_PERFORMANCE_FEE),
                    BPS_PRECISION,
                    Math.Rounding.Floor
                );
                uint256 recipientFee = totalFee - superformFee;

                // Transfer fees
                if (superformFee > 0) {
                    // Get treasury address from SuperGovernor
                    address treasury = superGovernor.getAddress(
                        superGovernor.TREASURY()
                    );
                    _safeTokenTransfer(address(_asset), treasury, superformFee);
                    emit FeePaid(treasury, superformFee, performanceFeeBps);
                }

                if (recipientFee > 0) {
                    address recipient = feeConfig.recipient;
                    if (recipient == address(0)) revert ZERO_ADDRESS();
                    _safeTokenTransfer(
                        address(_asset),
                        recipient,
                        recipientFee
                    );
                    emit FeePaid(recipient, recipientFee, performanceFeeBps);
                }

                currentAssets -= totalFee;
            }
        }
        return currentAssets;
    }

    /// @notice Internal function to update the average withdraw price
    /// @param state Storage reference to the vault state
    /// @param requestedShares Number of shares requested
    /// @param currentAssetsWithFees Current assets with fees
    function _updateAverageWithdrawPrice(
        SuperVaultState storage state,
        uint256 requestedShares,
        uint256 currentAssetsWithFees
    ) private {
        uint256 existingShares;
        uint256 existingAssets;

        if (state.maxWithdraw > 0 && state.averageWithdrawPrice > 0) {
            existingShares = state.maxWithdraw.mulDiv(
                PRECISION,
                state.averageWithdrawPrice,
                Math.Rounding.Floor
            );
            existingAssets = state.maxWithdraw;
        }

        uint256 newTotalShares = existingShares + requestedShares;
        uint256 newTotalAssets = existingAssets + currentAssetsWithFees;

        if (newTotalShares > 0) {
            state.averageWithdrawPrice = newTotalAssets.mulDiv(
                PRECISION,
                newTotalShares,
                Math.Rounding.Floor
            );
        }
    }

    /// @notice Internal function to get the SuperVaultAggregator
    /// @return The SuperVaultAggregator
    function _getSuperVaultAggregator()
        internal
        view
        returns (ISuperVaultAggregator)
    {
        address aggregatorAddress = superGovernor.getAddress(
            superGovernor.SUPER_VAULT_AGGREGATOR()
        );

        return ISuperVaultAggregator(aggregatorAddress);
    }

    /// @notice Internal function to check if a manager is authorized
    /// @param manager_ The manager to check
    function _isManager(address manager_) internal view {
        if (!_getSuperVaultAggregator().isAnyManager(manager_, address(this))) {
            revert MANAGER_NOT_AUTHORIZED();
        }
    }

    /// @notice Internal function to check if a manager is the primary manager
    /// @param manager_ The manager to check
    function _isPrimaryManager(address manager_) internal view {
        if (
            !_getSuperVaultAggregator().isMainManager(manager_, address(this))
        ) {
            revert MANAGER_NOT_AUTHORIZED();
        }
    }

    /// @notice Internal function to manage a yield source
    /// @param source Address of the yield source
    /// @param oracle Address of the oracle
    /// @param actionType Type of action: 0=Add, 1=UpdateOracle, 2=Remove
    function _manageYieldSource(
        address source,
        address oracle,
        uint8 actionType
    ) internal {
        if (actionType == 0) {
            _addYieldSource(source, oracle);
        } else if (actionType == 1) {
            _updateYieldSourceOracle(source, oracle);
        } else if (actionType == 2) {
            _removeYieldSource(source);
        } else {
            revert ACTION_TYPE_DISALLOWED();
        }
    }

    /// @notice Internal function to add a yield source
    /// @param source Address of the yield source
    /// @param oracle Address of the oracle
    function _addYieldSource(address source, address oracle) internal {
        if (source == address(0) || oracle == address(0)) revert ZERO_ADDRESS();
        if (yieldSources[source] != address(0))
            revert YIELD_SOURCE_ALREADY_EXISTS();
        yieldSources[source] = oracle;
        if (!yieldSourcesList.add(source)) revert YIELD_SOURCE_ALREADY_EXISTS();

        emit YieldSourceAdded(source, oracle);
    }

    /// @notice Internal function to update a yield source's oracle
    /// @param source Address of the yield source
    /// @param oracle Address of the oracle
    function _updateYieldSourceOracle(address source, address oracle) internal {
        if (oracle == address(0)) revert ZERO_ADDRESS();
        address oldOracle = yieldSources[source];
        if (oldOracle == address(0)) revert YIELD_SOURCE_NOT_FOUND();
        yieldSources[source] = oracle;

        emit YieldSourceOracleUpdated(source, oldOracle, oracle);
    }

    /// @notice Internal function to remove a yield source
    /// @param source Address of the yield source
    function _removeYieldSource(address source) internal {
        if (yieldSources[source] == address(0)) revert YIELD_SOURCE_NOT_FOUND();

        // Remove from mapping
        delete yieldSources[source];

        // Remove from EnumerableSet
        if (!yieldSourcesList.remove(source)) revert YIELD_SOURCE_NOT_FOUND();

        emit YieldSourceRemoved(source);
    }

    /// @notice Internal function to propose an emergency withdraw
    function _proposeEmergencyWithdraw() internal {
        _isPrimaryManager(msg.sender);

        proposedEmergencyWithdrawable = true;
        emergencyWithdrawableEffectiveTime = block.timestamp + ONE_WEEK;
        emit EmergencyWithdrawableProposed(
            true,
            emergencyWithdrawableEffectiveTime
        );
    }

    /// @notice Internal function to execute an emergency withdraw
    function _executeEmergencyWithdrawActivation() internal {
        if (emergencyWithdrawableEffectiveTime == 0) revert NO_PROPOSAL();
        if (block.timestamp < emergencyWithdrawableEffectiveTime)
            revert INVALID_TIMESTAMP();
        emergencyWithdrawable = proposedEmergencyWithdrawable;
        proposedEmergencyWithdrawable = false;
        emergencyWithdrawableEffectiveTime = 0;
        emit EmergencyWithdrawableUpdated(emergencyWithdrawable);
    }

    /// @notice Internal function to cancel an emergency withdraw proposal
    function _cancelEmergencyWithdrawProposal() internal {
        _isPrimaryManager(msg.sender);

        if (emergencyWithdrawableEffectiveTime == 0) revert NO_PROPOSAL();
        proposedEmergencyWithdrawable = false;
        emergencyWithdrawableEffectiveTime = 0;
        emit EmergencyWithdrawableProposalCanceled();
    }

    /// @notice Internal function to perform an emergency withdraw
    /// @param recipient Address to receive the assets
    /// @param amount Amount of assets to withdraw
    function _performEmergencyWithdraw(
        address recipient,
        uint256 amount
    ) internal {
        _isPrimaryManager(msg.sender);

        if (!emergencyWithdrawable) revert INVALID_EMERGENCY_WITHDRAWAL();
        if (recipient == address(0)) revert ZERO_ADDRESS();
        uint256 freeAssets = _getTokenBalance(address(_asset), address(this));
        if (amount == 0 || amount > freeAssets) revert INSUFFICIENT_FUNDS();
        _safeTokenTransfer(address(_asset), recipient, amount);
        emit EmergencyWithdrawal(recipient, amount);
    }

    /// @notice Internal function to check if a hook is a fulfill requests hook
    /// @param hook Address of the hook
    /// @return True if the hook is a fulfill requests hook, false otherwise
    function _isFulfillRequestsHook(address hook) private view returns (bool) {
        return superGovernor.isFulfillRequestsHookRegistered(hook);
    }

    /// @notice Internal function to check if a hook is registered
    /// @param hook Address of the hook
    /// @return True if the hook is registered, false otherwise
    function _isRegisteredHook(address hook) private view returns (bool) {
        return superGovernor.isHookRegistered(hook);
    }

    /// @notice Internal function to decode a hook's use previous hook amount
    /// @param hook Address of the hook
    /// @param hookCalldata Call data for the hook
    /// @return True if the hook should use the previous hook amount, false otherwise
    function _decodeHookUsePrevHookAmount(
        address hook,
        bytes memory hookCalldata
    ) private pure returns (bool) {
        try
            ISuperHookContextAware(hook).decodeUsePrevHookAmount(hookCalldata)
        returns (bool usePrevHookAmount) {
            return usePrevHookAmount;
        } catch {
            return false;
        }
    }

    /// @notice Internal function to get the previous hook's output amount
    /// @param prevHook Address of the previous hook
    /// @return Output amount of the previous hook
    function _getPreviousHookOutAmount(
        address prevHook
    ) private view returns (uint256) {
        return ISuperHookResultOutflow(prevHook).getOutAmount(address(this));
    }

    /// @notice Internal function to handle a redeem claimable
    /// @param controller Address of the controller
    /// @param assetsFulfilled Amount of assets fulfilled
    /// @param sharesFulfilled Amount of shares fulfilled
    /// @param averageWithdrawPrice Average withdraw price
    /// @param accumulatorShares Accumulator shares
    /// @param accumulatorCostBasis Accumulator cost basis
    function _onRedeemClaimable(
        address controller,
        uint256 assetsFulfilled,
        uint256 sharesFulfilled,
        uint256 averageWithdrawPrice,
        uint256 accumulatorShares,
        uint256 accumulatorCostBasis
    ) private {
        ISuperVault(_vault).onRedeemClaimable(
            controller,
            assetsFulfilled,
            sharesFulfilled,
            averageWithdrawPrice,
            accumulatorShares,
            accumulatorCostBasis
        );
    }

    /// @notice Internal function to handle a redeem
    /// @param controller Address of the controller
    /// @param shares Amount of shares
    function _handleRequestRedeem(address controller, uint256 shares) private {
        if (shares == 0) revert INVALID_AMOUNT();
        if (controller == address(0)) revert ZERO_ADDRESS();
        SuperVaultState storage state = superVaultState[controller];

        // Defense-in-depth: assert controller has accumulator shares
        if (state.accumulatorShares == 0) revert INSUFFICIENT_SHARES();

        // Get current PPS from aggregator to use as baseline for slippage protection
        uint256 currentPPS = getStoredPPS();
        if (currentPPS == 0) revert INVALID_PPS();

        // Calculate weighted average of PPS if there's an existing request
        if (state.pendingRedeemRequest > 0) {
            // Calculate weighted average of PPS based on share amounts
            uint256 existingSharesInRequest = state.pendingRedeemRequest;
            uint256 newTotalSharesInRequest = existingSharesInRequest + shares;

            // Use weighted average formula: (existingShares * existingPPS + newShares * currentPPS) / totalShares
            state.averageRequestPPS =
                ((existingSharesInRequest * state.averageRequestPPS) +
                    (shares * currentPPS)) /
                newTotalSharesInRequest;

            // Update total shares
            state.pendingRedeemRequest = newTotalSharesInRequest;
        } else {
            // First request for this controller
            state.pendingRedeemRequest = shares;
            state.averageRequestPPS = currentPPS;
        }

        emit RedeemRequestPlaced(controller, controller, shares);
    }

    /// @notice Internal function to handle a redeem cancellation
    /// @param controller Address of the controller
    function _handleCancelRedeem(address controller) private {
        if (controller == address(0)) revert ZERO_ADDRESS();
        SuperVaultState storage state = superVaultState[controller];
        uint256 pendingShares = state.pendingRedeemRequest;
        if (pendingShares == 0) revert REQUEST_NOT_FOUND();
        // Only clear pending request metadata
        state.pendingRedeemRequest = 0;
        state.averageRequestPPS = 0;
        emit RedeemRequestCanceled(controller, pendingShares);
    }

    /// @notice Internal function to handle a redeem claim
    /// @param controller Address of the controller
    /// @param receiver Address of the receiver
    /// @param assetsToClaim Amount of assets to claim
    function _handleClaimRedeem(
        address controller,
        address receiver,
        uint256 assetsToClaim
    ) private {
        if (assetsToClaim == 0) revert INVALID_AMOUNT();
        if (controller == address(0)) revert ZERO_ADDRESS();
        SuperVaultState storage state = superVaultState[controller];

        // Handle dust collection for rounding errors
        uint256 actualAmountToClaim = assetsToClaim;
        uint256 remainingAssets = _asset.balanceOf(address(this));

        // If user is requesting slightly more than available due to rounding errors,
        // and the difference is small (dust), give them the remaining balance
        if (
            assetsToClaim > remainingAssets &&
            assetsToClaim - remainingAssets <= TOLERANCE_CONSTANT
        ) {
            actualAmountToClaim = remainingAssets;
        }

        if (state.maxWithdraw < actualAmountToClaim)
            revert INVALID_REDEEM_CLAIM();
        state.maxWithdraw -= actualAmountToClaim;
        _asset.safeTransfer(receiver, actualAmountToClaim);
        emit RedeemRequestFulfilled(
            receiver,
            controller,
            actualAmountToClaim,
            0
        );
    }

    /// @notice Internal function to safely transfer tokens
    /// @param token Address of the token
    /// @param recipient Address to receive the tokens
    /// @param amount Amount of tokens to transfer
    function _safeTokenTransfer(
        address token,
        address recipient,
        uint256 amount
    ) private {
        if (amount > 0) IERC20(token).safeTransfer(recipient, amount);
    }

    /// @notice Internal function to get the token balance of an account
    /// @param token Address of the token
    /// @param account Address of the account
    /// @return Token balance of the account
    function _getTokenBalance(
        address token,
        address account
    ) private view returns (uint256) {
        return IERC20(token).balanceOf(account);
    }

    /// @notice Internal function to get the slippage tolerance
    /// @return Slippage tolerance
    function _getSlippageTolerance() private pure returns (uint256) {
        return SV_SLIPPAGE_TOLERANCE_BPS;
    }

    /// @notice Internal function to check if the caller is the vault
    /// @dev This is used to prevent unauthorized access to certain functions
    function _requireVault() internal view {
        if (msg.sender != _vault) revert ACCESS_DENIED();
    }

    /// @notice Checks if the strategy is currently paused
    /// @dev This calls SuperVaultAggregator.isStrategyPaused to determine pause status
    /// @return True if the strategy is paused, false otherwise
    function _isPaused() internal view returns (bool) {
        return _getSuperVaultAggregator().isStrategyPaused(address(this));
    }

    /// @notice Validates a hook using the Merkle root system
    /// @param hook Address of the hook to validate
    /// @param hookCalldata Calldata to be passed to the hook
    /// @param globalProof Merkle proof for the global root
    /// @param strategyProof Merkle proof for the strategy-specific root
    /// @return isValid True if the hook is valid, false otherwise
    function _validateHook(
        address hook,
        bytes memory hookCalldata,
        bytes32[] memory globalProof,
        bytes32[] memory strategyProof
    ) internal view returns (bool) {
        return
            _getSuperVaultAggregator().validateHook(
                address(this),
                ISuperVaultAggregator.ValidateHookArgs({
                    hookAddress: hook,
                    hookArgs: ISuperHookInspector(hook).inspect(hookCalldata),
                    globalProof: globalProof,
                    strategyProof: strategyProof
                })
            );
    }
}


0.0% src/interfaces/ISuperGovernor.sol

Lines covered: 0 / 0 (0.0%)

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.30;

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

/*//////////////////////////////////////////////////////////////
                                  ENUMS
    //////////////////////////////////////////////////////////////*/
/// @notice Enum representing different types of fees that can be managed
enum FeeType {
    REVENUE_SHARE,
    SUPER_VAULT_PERFORMANCE_FEE,
    SUPER_ASSET_SWAP_FEE
}
/// @title ISuperGovernor
/// @author Superform Labs
/// @notice Interface for the SuperGovernor contract
/// @dev Central registry for all deployed contracts in the Superform periphery

interface ISuperGovernor is IAccessControl {
    /*//////////////////////////////////////////////////////////////
                                  STRUCTS
    //////////////////////////////////////////////////////////////*/

    /// @notice Structure containing Merkle root data for a hook
    struct HookMerkleRootData {
        bytes32 currentRoot; // Current active Merkle root for the hook
        bytes32 proposedRoot; // Proposed new Merkle root (zero if no proposal exists)
        uint256 effectiveTime; // Timestamp when the proposed root becomes effective
    }

    struct GasInfo {
        // `batchForwardPPS` base gas
        uint256 baseGasBatch;
        // `batchForwardPPS` gas increase per entry
        uint256 gasIncreasePerEntryBatch;
    }

    /*//////////////////////////////////////////////////////////////
                                  ERRORS
    //////////////////////////////////////////////////////////////*/
    /// @notice Thrown when a function that should only be called by governor is called by someone else
    error ONLY_GOVERNOR();
    /// @notice Thrown when trying to register a contract that is already registered
    error CONTRACT_ALREADY_REGISTERED();
    /// @notice Thrown when trying to access a contract that is not registered
    error CONTRACT_NOT_FOUND();
    /// @notice Thrown when providing an invalid address (typically zero address)
    error INVALID_ADDRESS();
    /// @notice Thrown when providing an invalid chain ID
    error INVALID_CHAIN_ID();
    /// @notice Thrown when a hook is already approved
    error HOOK_ALREADY_APPROVED();
    /// @notice Thrown when a hook is not approved but expected to be
    error HOOK_NOT_APPROVED();
    /// @notice Thrown when a fulfill requests hook is already registered
    error FULFILL_REQUESTS_HOOK_ALREADY_REGISTERED();
    /// @notice Thrown when a fulfill requests hook is not registered but expected to be
    error FULFILL_REQUESTS_HOOK_NOT_REGISTERED();
    /// @notice Thrown when provided revenue share is invalid (exceeds 100%)
    error INVALID_REVENUE_SHARE();
    /// @notice Thrown when an invalid fee value is proposed (must be <= BPS_MAX)
    error INVALID_FEE_VALUE();
    /// @notice Thrown when no proposed fee exists but one is expected
    error NO_PROPOSED_FEE(FeeType feeType);
    /// @notice Thrown when timelock period has not expired
    error TIMELOCK_NOT_EXPIRED();
    /// @notice Thrown when a validator is not registered
    error VALIDATOR_NOT_REGISTERED();
    /// @notice Thrown when a validator is already registered
    error VALIDATOR_ALREADY_REGISTERED();
    /// @notice Thrown when trying to change active PPS oracle directly
    error MUST_USE_TIMELOCK_FOR_CHANGE();
    /// @notice Thrown when a SuperBank hook Merkle root is not registered but expected to be
    error INVALID_TIMESTAMP();
    /// @notice Thrown when attempting to set an invalid quorum value (typically zero)
    error INVALID_QUORUM();
    /// @notice Thrown when no active PPS oracle is set but one is required
    error NO_ACTIVE_PPS_ORACLE();
    /// @notice Thrown when no proposed PPS oracle exists but one is expected
    error NO_PROPOSED_PPS_ORACLE();
    /// @notice Error thrown when manager takeovers are frozen
    error MANAGER_TAKEOVERS_FROZEN();
    /// @notice Thrown when no proposed Merkle root exists but one is expected
    error NO_PROPOSED_MERKLE_ROOT();
    /// @notice Thrown when no proposed Merkle root exists but one is expected
    error ZERO_PROPOSED_MERKLE_ROOT();
    /// @notice Thrown when no proposed minimum staleness exists but one is expected
    error NO_PROPOSED_MIN_STALENESS();
    /// @notice Thrown when the provided maxStaleness is less than the minimum required staleness
    error MAX_STALENESS_TOO_LOW();
    /// @notice Thrown when a relayer is not registered
    error RELAYER_NOT_REGISTERED();
    /// @notice Thrown when a relayer is already registered
    error RELAYER_ALREADY_REGISTERED();
    /// @notice Thrown when an executor is not registered
    error EXECUTOR_NOT_REGISTERED();
    /// @notice Thrown when an executor is already registered
    error EXECUTOR_ALREADY_REGISTERED();
    /// @notice Thrown when there's no pending change but one is expected
    error NO_PENDING_CHANGE();
    /// @notice Thrown when a manager is not registered
    error MANAGER_NOT_REGISTERED();
    /// @notice Thrown when a manager is already registered
    error MANAGER_ALREADY_REGISTERED();
    /// @notice Thrown when a token is already whitelisted
    error TOKEN_ALREADY_WHITELISTED();
    /// @notice Thrown when a token is not proposed for whitelisting but expected to be
    error NOT_PROPOSED_INCENTIVE_TOKEN();
    /// @notice Thrown when a token is not whitelisted but expected to be
    error NOT_WHITELISTED_INCENTIVE_TOKEN();
    /// @notice Thrown when trying to register a keeper that is already registered
    error KEEPER_ALREADY_REGISTERED();
    /// @notice Thrown when trying to unregister a keeper that is not registered
    error KEEPER_NOT_REGISTERED();
    /// @notice Thrown when the price is not found
    error PRICE_NOT_FOUND();
    /// @notice Thrown when the price is stale
    error STALE_ORACLE_PRICE();
    /// @notice Thrown when the super oracle is not found
    error SUPER_ORACLE_NOT_FOUND();
    /// @notice Thrown when the up token is not found
    error UP_NOT_FOUND();
    /// @notice Thrown when the gas info is invalid
    error INVALID_GAS_INFO();

    /*//////////////////////////////////////////////////////////////
                                  EVENTS
    //////////////////////////////////////////////////////////////*/
    /// @notice Emitted when an address is set in the registry
    /// @param key The key used to reference the address
    /// @param value The address value
    event AddressSet(bytes32 indexed key, address indexed value);

    /// @notice Emitted when a hook is approved
    /// @param hook The address of the approved hook
    event HookApproved(address indexed hook);

    /// @notice Emitted when a hook is removed
    /// @param hook The address of the removed hook
    event HookRemoved(address indexed hook);

    /// @notice Emitted when a fulfill requests hook is registered
    /// @param hook The address of the registered fulfill requests hook
    event FulfillRequestsHookRegistered(address indexed hook);

    /// @notice Emitted when a fulfill requests hook is unregistered
    /// @param hook The address of the unregistered fulfill requests hook
    event FulfillRequestsHookUnregistered(address indexed hook);

    /// @notice Emitted when a validator is registered
    /// @param validator The address of the registered validator
    event ValidatorAdded(address indexed validator);

    /// @notice Emitted when a validator is removed
    /// @param validator The address of the removed validator
    event ValidatorRemoved(address indexed validator);

    /// @notice Emitted when revenue share is updated
    /// @param share The new revenue share percentage
    event RevenueShareUpdated(uint256 share);

    /// @notice Emitted when a new fee is proposed
    /// @param feeType The type of fee being proposed
    /// @param value The proposed fee value (in basis points)
    /// @param effectiveTime The timestamp when the fee will be effective
    event FeeProposed(FeeType indexed feeType, uint256 value, uint256 effectiveTime);

    /// @notice Emitted when a fee is updated
    /// @param feeType The type of fee being updated
    /// @param value The new fee value (in basis points)
    event FeeUpdated(FeeType indexed feeType, uint256 value);

    /// @notice Emitted when a new SuperBank hook Merkle root is proposed
    /// @param hook The hook address for which the Merkle root is being proposed
    /// @param newRoot The new Merkle root
    /// @param effectiveTime The timestamp when the new root will be effective
    event SuperBankHookMerkleRootProposed(address indexed hook, bytes32 newRoot, uint256 effectiveTime);

    /// @notice Emitted when the SuperBank hook Merkle root is updated.
    /// @param hook The address of the hook for which the Merkle root was updated.
    /// @param newRoot The new Merkle root.
    event SuperBankHookMerkleRootUpdated(address indexed hook, bytes32 newRoot);

    /// @notice Emitted when the VaultBank hook Merkle root is proposed
    /// @param hook The hook address for which the Merkle root is being proposed
    /// @param newRoot The new Merkle root
    /// @param effectiveTime The timestamp when the new root will be effective
    event VaultBankHookMerkleRootProposed(address indexed hook, bytes32 newRoot, uint256 effectiveTime);

    /// @notice Emitted when the VaultBank hook Merkle root is updated.
    /// @param hook The address of the hook for which the Merkle root was updated.
    /// @param newRoot The new Merkle root.
    event VaultBankHookMerkleRootUpdated(address indexed hook, bytes32 newRoot);

    /// @notice Emitted when the active PPS Oracle's quorum requirement is updated
    /// @param quorum The new quorum value
    event PPSOracleQuorumUpdated(uint256 quorum);

    /// @notice Emitted when an active PPS oracle is initially set
    /// @param oracle The address of the set oracle
    event ActivePPSOracleSet(address indexed oracle);

    /// @notice Emitted when a new PPS oracle is proposed
    /// @param oracle The address of the proposed oracle
    /// @param effectiveTime The timestamp when the proposal will be effective
    event ActivePPSOracleProposed(address indexed oracle, uint256 effectiveTime);

    /// @notice Emitted when the active PPS oracle is changed
    /// @param oldOracle The address of the previous oracle
    /// @param newOracle The address of the new oracle
    event ActivePPSOracleChanged(address indexed oldOracle, address indexed newOracle);

    /// @notice Event emitted when manager takeovers are permanently frozen
    event ManagerTakeoversFrozen();

    /// @notice Emitted when a relayer is added
    /// @param relayer The address of the added relayer
    event RelayerAdded(address indexed relayer);

    /// @notice Emitted when a relayer is removed
    /// @param relayer The address of the removed relayer
    event RelayerRemoved(address indexed relayer);

    /// @notice Emitted when a vault bank is added
    /// @param chainId The chain ID of the added vault bank
    /// @param vaultBank The address of the added vault bank
    event VaultBankAddressAdded(uint64 indexed chainId, address indexed vaultBank);

    /// @notice Emitted when an executor is added
    /// @param executor The address of the added executor
    event ExecutorAdded(address indexed executor);

    /// @notice Emitted when an executor is removed
    /// @param executor The address of the removed executor
    event ExecutorRemoved(address indexed executor);

    /// @notice Emitted when a prover is set
    /// @param prover The address of the prover
    event ProverSet(address indexed prover);

    /// @notice Emitted when a change to upkeep payments status is proposed
    /// @param enabled The proposed status (enabled/disabled)
    /// @param effectiveTime The timestamp when the status change will be effective
    event UpkeepPaymentsChangeProposed(bool enabled, uint256 effectiveTime);

    /// @notice Emitted when upkeep payments status is changed
    /// @param enabled The new status (enabled/disabled)
    event UpkeepPaymentsChanged(bool enabled);

    /// @notice Emitted when a new minimum staleness is proposed
    /// @param newMinStaleness The proposed minimum staleness value
    /// @param effectiveTime The timestamp when the new value will be effective
    event MinStalenesProposed(uint256 newMinStaleness, uint256 effectiveTime);

    /// @notice Emitted when the minimum staleness is changed
    /// @param newMinStaleness The new minimum staleness value
    event MinStalenesChanged(uint256 newMinStaleness);

    /// @notice Emitted when a superform manager is added
    /// @param manager The address of the added manager
    event SuperformManagerAdded(address indexed manager);

    /// @notice Emitted when a superform manager is removed
    /// @param manager The address of the removed manager
    event SuperformManagerRemoved(address indexed manager);

    /// @notice Emitted when incentive tokens are proposed for whitelisting
    /// @param tokens The addresses of the proposed tokens
    /// @param effectiveTime The timestamp when the proposal will be effective
    event WhitelistedIncentiveTokensProposed(address[] tokens, uint256 effectiveTime);

    /// @notice Emitted when whitelisted incentive tokens are added
    /// @param tokens The addresses of the added tokens
    event WhitelistedIncentiveTokensAdded(address[] tokens);

    /// @notice Emitted when whitelisted incentive tokens are removed
    /// @param tokens The addresses of the removed tokens
    event WhitelistedIncentiveTokensRemoved(address[] tokens);

    /// @notice Emitted when a protected keeper is registered
    /// @param keeper Address of the keeper being registered
    event ProtectedKeeperRegistered(address indexed keeper);

    /// @notice Emitted when a protected keeper is unregistered
    /// @param keeper Address of the keeper being unregistered
    event ProtectedKeeperUnregistered(address indexed keeper);

    /// @notice Emitted when gas info is set
    /// @param oracle The address of the oracle
    /// @param baseGasBatch The base gas for the oracle
    /// @param gasIncreasePerEntryBatch The gas increase per entry for the oracle
    event GasInfoSet(address indexed oracle, uint256 baseGasBatch, uint256 gasIncreasePerEntryBatch);

    /*//////////////////////////////////////////////////////////////
                       CONTRACT REGISTRY FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    /// @notice Sets an address in the registry
    /// @param key The key to associate with the address
    /// @param value The address value
    function setAddress(bytes32 key, address value) external;

    /*//////////////////////////////////////////////////////////////
                        PERIPHERY CONFIGURATIONS
    //////////////////////////////////////////////////////////////*/
    /// @notice Sets the prover address
    /// @param prover The address of the prover
    function setProver(address prover) external;

    /// @notice Change the primary manager for a strategy
    /// @dev Only SuperGovernor can call this function directly
    /// @param strategy The strategy address
    /// @param newManager The new primary manager address
    function changePrimaryManager(address strategy, address newManager) external;

    /// @notice Permanently freezes all manager takeovers globally
    function freezeManagerTakeover() external;

    /// @notice Changes the hooks root update timelock duration
    /// @param newTimelock New timelock duration in seconds
    function changeHooksRootUpdateTimelock(uint256 newTimelock) external;

    /// @notice Proposes a new global hooks Merkle root
    /// @dev Only GOVERNOR_ROLE can call this function
    /// @param newRoot New Merkle root for global hooks validation
    function proposeGlobalHooksRoot(bytes32 newRoot) external;

    /// @notice Sets veto status for global hooks Merkle root
    /// @dev Only GUARDIAN_ROLE can call this function
    /// @param vetoed Whether to veto (true) or unveto (false) the global hooks root
    function setGlobalHooksRootVetoStatus(bool vetoed) external;

    /// @notice Sets veto status for a strategy-specific hooks Merkle root
    /// @dev Only GUARDIAN_ROLE can call this function
    /// @param strategy Address of the strategy to affect
    /// @param vetoed Whether to veto (true) or unveto (false) the strategy hooks root
    function setStrategyHooksRootVetoStatus(address strategy, bool vetoed) external;

    /// @notice Sets the superasset manager for a superasset
    /// @param superAsset The superasset address
    /// @param superAssetManager The new superasset manager address
    function setSuperAssetManager(address superAsset, address superAssetManager) external;

    /// @notice Adds an ICC to the whitelist
    /// @param icc The ICC address to add
    function addICCToWhitelist(address icc) external;

    /// @notice Removes an ICC from the whitelist
    /// @param icc The ICC address to remove
    function removeICCFromWhitelist(address icc) external;

    /// @notice Sets the maximum staleness period for all oracle feeds
    /// @param newMaxStaleness The new maximum staleness period in seconds
    function setOracleMaxStaleness(uint256 newMaxStaleness) external;

    /// @notice Sets the maximum staleness period for a specific oracle feed
    /// @param feed The address of the feed to set staleness for
    /// @param newMaxStaleness The new maximum staleness period in seconds
    function setOracleFeedMaxStaleness(address feed, uint256 newMaxStaleness) external;

    /// @notice Sets the maximum staleness periods for multiple oracle feeds in batch
    /// @param feeds The addresses of the feeds to set staleness for
    /// @param newMaxStalenessList The new maximum staleness periods in seconds
    function setOracleFeedMaxStalenessBatch(
        address[] calldata feeds,
        uint256[] calldata newMaxStalenessList
    )
        external;

    /// @notice Queues an oracle update for execution after timelock period
    /// @param bases Base asset addresses
    /// @param quotes Quote asset addresses
    /// @param providers Provider identifiers
    /// @param feeds Feed addresses
    function queueOracleUpdate(
        address[] calldata bases,
        address[] calldata quotes,
        bytes32[] calldata providers,
        address[] calldata feeds
    )
        external;

    /// @notice Queues a provider removal for execution after timelock period
    /// @param providers The providers to remove
    function queueOracleProviderRemoval(bytes32[] calldata providers) external;

    /// @notice Sets uptime feeds for multiple data oracles in batch (Layer 2 only)
    /// @param dataOracles Array of data oracle addresses to set uptime feeds for
    /// @param uptimeOracles Array of uptime feed addresses to set
    /// @param gracePeriods Array of grace periods in seconds after sequencer restart
    function batchSetOracleUptimeFeed(
        address[] calldata dataOracles,
        address[] calldata uptimeOracles,
        uint256[] calldata gracePeriods
    )
        external;

    /// @notice Sets the emergency price for a token
    /// @param token The address of the token
    /// @param price The emergency price to set
    function setEmergencyPrice(address token, uint256 price) external;

    /// @notice Sets the emergency price for multiple tokens o
    /// @param tokens Array of token addresses
    /// @param prices Array of emergency prices
    function batchSetEmergencyPrices(address[] calldata tokens, uint256[] calldata prices) external;

    /*//////////////////////////////////////////////////////////////
                          HOOK MANAGEMENT
    //////////////////////////////////////////////////////////////*/
    /// @notice Registers a hook for use in SuperVaults
    /// @param hook The address of the hook to register
    /// @param isFulfillRequestsHook Whether the hook is a fulfill requests hook
    function registerHook(address hook, bool isFulfillRequestsHook) external;

    /// @notice Unregisters a hook from the approved list
    /// @param hook The address of the hook to unregister
    function unregisterHook(address hook) external;

    /*//////////////////////////////////////////////////////////////
                        EXECUTOR MANAGEMENT
    //////////////////////////////////////////////////////////////*/
    /// @notice Adds an executor to the approved list
    /// @param executor The address of the executor to add
    function addExecutor(address executor) external;

    /// @notice Removes an executor from the approved list
    /// @param executor The address of the executor to remove
    function removeExecutor(address executor) external;

    /*//////////////////////////////////////////////////////////////
                        RELAYER MANAGEMENT
    //////////////////////////////////////////////////////////////*/
    /// @notice Adds a relayer to the approved list
    /// @param relayer The address of the relayer to add
    function addRelayer(address relayer) external;

    /// @notice Removes a relayer from the approved list
    /// @param relayer The address of the relayer to remove
    function removeRelayer(address relayer) external;

    /*//////////////////////////////////////////////////////////////
                      VALIDATOR MANAGEMENT
    //////////////////////////////////////////////////////////////*/
    /// @notice Adds a validator to the approved list
    /// @param validator The address of the validator to add
    function addValidator(address validator) external;

    /// @notice Removes a validator from the approved list
    /// @param validator The address of the validator to remove
    function removeValidator(address validator) external;

    /*//////////////////////////////////////////////////////////////
                       PPS ORACLE MANAGEMENT
    //////////////////////////////////////////////////////////////*/
    /// @notice Sets the active PPS oracle (only if there is no active oracle yet)
    /// @param oracle Address of the PPS oracle to set as active
    function setActivePPSOracle(address oracle) external;

    /// @notice Proposes a new active PPS oracle (when there is already an active one)
    /// @param oracle Address of the PPS oracle to propose as active
    function proposeActivePPSOracle(address oracle) external;

    /// @notice Executes a previously proposed PPS oracle change after timelock has expired
    function executeActivePPSOracleChange() external;

    /// @notice Sets the quorum requirement for the active PPS Oracle
    /// @param quorum The new quorum value
    function setPPSOracleQuorum(uint256 quorum) external;

    /*//////////////////////////////////////////////////////////////
                      REVENUE SHARE MANAGEMENT
    //////////////////////////////////////////////////////////////*/
    /// @notice Proposes a new fee value
    /// @param feeType The type of fee to propose
    /// @param value The proposed fee value (in basis points)
    function proposeFee(FeeType feeType, uint256 value) external;

    /// @notice Executes a previously proposed fee update after timelock has expired
    /// @param feeType The type of ffee to execute the update for
    function executeFeeUpdate(FeeType feeType) external;

    /// @notice Executes an upkeep claim on `SuperVaultAggregator`
    /// @param amount The amount to claim
    function executeUpkeepClaim(uint256 amount) external;

    /*//////////////////////////////////////////////////////////////
                      UPKEEP COST MANAGEMENT
    //////////////////////////////////////////////////////////////*/
    /// @notice Sets gas info for an oracle
    /// @param oracle The address of the oracle
    /// @param baseGasBatch The base gas for the oracle
    /// @param gasIncreasePerEntryBatch The gas increase per entry for the oracle
    function setGasInfo(address oracle, uint256 baseGasBatch, uint256 gasIncreasePerEntryBatch) external;

    /// @notice Proposes a change to upkeep payments enabled status
    /// @param enabled The proposed enabled status
    function proposeUpkeepPaymentsChange(bool enabled) external;

    /// @notice Executes a previously proposed upkeep payments status change
    function executeUpkeepPaymentsChange() external;

    /*//////////////////////////////////////////////////////////////
                        MIN STALENESS MANAGEMENT
    //////////////////////////////////////////////////////////////*/
    /// @notice Proposes a new minimum staleness value to prevent maxStaleness from being set too low
    /// @param newMinStaleness The proposed new minimum staleness value in seconds
    function proposeMinStaleness(uint256 newMinStaleness) external;

    /// @notice Executes a previously proposed minimum staleness change after timelock has expired
    function executeMinStalenesChange() external;

    /*//////////////////////////////////////////////////////////////
                        SUPERFORM MANAGER MANAGEMENT
    //////////////////////////////////////////////////////////////*/

    /// @notice Adds a manager to the superform managers list
    /// @param manager Address of the manager to add
    function addSuperformManager(address manager) external;

    /// @notice Removes a manager from the superform managers list
    /// @param manager Address of the manager to remove
    function removeSuperformManager(address manager) external;

    /*//////////////////////////////////////////////////////////////
                           VAULT HOOKS MGMT
    //////////////////////////////////////////////////////////////*/
    /// @notice Proposes a new Merkle root for a specific hook's allowed targets.
    /// @param hook The address of the hook to update the Merkle root for.
    /// @param proposedRoot The proposed new Merkle root.
    function proposeVaultBankHookMerkleRoot(address hook, bytes32 proposedRoot) external;

    /// @notice Executes a previously proposed Merkle root update for a specific hook if the effective time has passed.
    /// @param hook The address of the hook to execute the update for.
    function executeVaultBankHookMerkleRootUpdate(address hook) external;

    /*//////////////////////////////////////////////////////////////
                           SUPERBANK HOOKS MGMT
    //////////////////////////////////////////////////////////////*/
    /// @notice Proposes a new Merkle root for a specific hook's allowed targets.
    /// @param hook The address of the hook to update the Merkle root for.
    /// @param proposedRoot The proposed new Merkle root.
    function proposeSuperBankHookMerkleRoot(address hook, bytes32 proposedRoot) external;

    /// @notice Executes a previously proposed Merkle root update for a specific hook if the effective time has passed.
    /// @param hook The address of the hook to execute the update for.
    function executeSuperBankHookMerkleRootUpdate(address hook) external;

    /*//////////////////////////////////////////////////////////////
                        VAULT BANK MANAGEMENT
    //////////////////////////////////////////////////////////////*/
    /// @notice Adds a vault bank address for a specific chain ID
    /// @param chainId The chain ID to add the vault bank for
    /// @param vaultBank The address of the vault bank to add
    function addVaultBank(uint64 chainId, address vaultBank) external;

    /*//////////////////////////////////////////////////////////////
                        INCENTIVE TOKEN MANAGEMENT
    //////////////////////////////////////////////////////////////*/
    /// @notice Proposes whitelisted incentive tokens
    /// @param tokens The addresses of the tokens to add
    function proposeAddIncentiveTokens(address[] memory tokens) external;

    /// @notice Executes a previously proposed whitelisted incentive token update after timelock has expired
    function executeAddIncentiveTokens() external;

    /// @notice Proposes a new whitelisted incentive token
    /// @param tokens The addresses of the tokens to add
    function proposeRemoveIncentiveTokens(address[] memory tokens) external;

    /// @notice Executes a previously proposed whitelisted incentive tokens removal after timelock has expired
    function executeRemoveIncentiveTokens() external;

    /*//////////////////////////////////////////////////////////////
                        EXTERNAL VIEW FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    /// @notice The identifier of the role that grants access to critical governance functions
    function SUPER_GOVERNOR_ROLE() external view returns (bytes32);

    /// @notice The identifier of the role that grants access to daily operations like hooks and validators
    function GOVERNOR_ROLE() external view returns (bytes32);

    /// @notice The identifier of the role that grants access to bank management functions
    function BANK_MANAGER_ROLE() external view returns (bytes32);

    /// @notice The identifier of the role that grants access to gas management functions
    function GAS_MANAGER_ROLE() external view returns (bytes32);

    /// @notice The identifier of the role that grants access to guardian functions
    function GUARDIAN_ROLE() external view returns (bytes32);

    /// @notice The identifier of the role that grants access to superasset factory
    function SUPER_ASSET_FACTORY() external view returns (bytes32);

    /// @notice Gets an address from the registry
    /// @param key The key of the address to get
    /// @return The address value
    function getAddress(bytes32 key) external view returns (address);

    /// @notice Checks if manager takeovers are frozen
    /// @return True if manager takeovers are frozen, false otherwise
    function isManagerTakeoverFrozen() external view returns (bool);

    /// @notice Gets the vault bank address for a specific chain ID
    /// @param chainId The chain ID to get the vault bank for
    /// @return The vault bank address
    function getVaultBank(uint64 chainId) external view returns (address);

    /// @notice Checks if a hook is registered
    /// @param hook The address of the hook to check
    /// @return True if the hook is registered, false otherwise
    function isHookRegistered(address hook) external view returns (bool);

    /// @notice Checks if a hook is registered as a fulfill requests hook
    /// @param hook The address of the hook to check
    /// @return True if the hook is registered as a fulfill requests hook, false otherwise
    function isFulfillRequestsHookRegistered(address hook) external view returns (bool);

    /// @notice Gets all registered hooks
    /// @return An array of registered hook addresses
    function getRegisteredHooks() external view returns (address[] memory);

    /// @notice Gets all registered fulfill requests hooks
    /// @return An array of registered fulfill requests hook addresses
    function getRegisteredFulfillRequestsHooks() external view returns (address[] memory);

    /// @notice Checks if an address is an approved validator
    /// @param validator The address to check
    /// @return True if the address is an approved validator, false otherwise
    function isValidator(address validator) external view returns (bool);

    /// @notice Checks if an address has the guardian role
    /// @param guardian Address to check
    /// @return true if the address has the GUARDIAN_ROLE
    function isGuardian(address guardian) external view returns (bool);

    /// @notice Checks if an address is an approved relayer
    /// @param relayer The address to check
    /// @return True if the address is an approved relayer, false otherwise
    function isRelayer(address relayer) external view returns (bool);

    /// @notice Checks if an address is an approved executor
    /// @param executor The address to check
    /// @return True if the address is an approved executor, false otherwise
    function isExecutor(address executor) external view returns (bool);

    /// @notice Returns all registered validators
    /// @return List of validator addresses
    function getValidators() external view returns (address[] memory);

    /// @notice Returns all registered relayers
    /// @return List of relayer addresses
    function getRelayers() external view returns (address[] memory);

    /// @notice Returns all registered executors
    /// @return List of executor addresses
    function getExecutors() external view returns (address[] memory);

    /// @notice Gets the proposed active PPS oracle and its effective time
    /// @return proposedOracle The proposed oracle address
    /// @return effectiveTime The timestamp when the proposed oracle will become effective
    function getProposedActivePPSOracle() external view returns (address proposedOracle, uint256 effectiveTime);

    /// @notice Gets the current quorum requirement for the active PPS Oracle
    /// @return The current quorum requirement
    function getPPSOracleQuorum() external view returns (uint256);

    /// @notice Gets the active PPS oracle
    /// @return The active PPS oracle address
    function getActivePPSOracle() external view returns (address);

    /// @notice Checks if an address is the current active PPS oracle
    /// @param oracle The address to check
    /// @return True if the address is the active PPS oracle, false otherwise
    function isActivePPSOracle(address oracle) external view returns (bool);

    /// @notice Gets the current fee value for a specific fee type
    /// @param feeType The type of fee to get
    /// @return The current fee value (in basis points)
    function getFee(FeeType feeType) external view returns (uint256);

    /// @notice Gets the current upkeep cost per batch update for PPS updates
    /// @param oracle The address of the PPS oracle
    /// @param chargeableEntries The number of chargeable entries
    /// @return The current upkeep cost per batch update in UP tokens
    function getUpkeepCostPerBatchUpdate(address oracle, uint256 chargeableEntries) external view returns (uint256);

    /// @notice Gets the proposed upkeep cost per update and its effective time
    /// @notice Gets the current minimum staleness value
    /// @return The current minimum staleness value in seconds
    function getMinStaleness() external view returns (uint256);

    /// @notice Gets the proposed minimum staleness value and its effective time
    /// @return proposedMinStaleness The proposed new minimum staleness value
    /// @return effectiveTime The timestamp when the new value will become effective
    function getProposedMinStaleness() external view returns (uint256 proposedMinStaleness, uint256 effectiveTime);

    /// @notice Returns the current Merkle root for a specific hook's allowed targets.
    /// @param hook The address of the hook to get the Merkle root for.
    /// @return The Merkle root for the hook's allowed targets.
    function getSuperBankHookMerkleRoot(address hook) external view returns (bytes32);

    /// @notice Returns the current Merkle root for a specific hook's allowed targets.
    /// @param hook The address of the hook to get the Merkle root for.
    /// @return The Merkle root for the hook's allowed targets.
    function getVaultBankHookMerkleRoot(address hook) external view returns (bytes32);

    /// @notice Gets the proposed Merkle root and its effective time for a specific hook.
    /// @param hook The address of the hook to get the proposed Merkle root for.
    /// @return proposedRoot The proposed Merkle root.
    /// @return effectiveTime The timestamp when the proposed root will become effective.
    function getProposedSuperBankHookMerkleRoot(address hook)
        external
        view
        returns (bytes32 proposedRoot, uint256 effectiveTime);

    /// @notice Gets the proposed Merkle root and its effective time for a specific hook.
    /// @param hook The address of the hook to get the proposed Merkle root for.
    /// @return proposedRoot The proposed Merkle root.
    /// @return effectiveTime The timestamp when the proposed root will become effective.
    function getProposedVaultBankHookMerkleRoot(address hook)
        external
        view
        returns (bytes32 proposedRoot, uint256 effectiveTime);

    /// @notice Checks if a token is whitelisted as an incentive token
    /// @param token The address of the token to check
    /// @return True if the token is whitelisted as an incentive token, false otherwise
    function isWhitelistedIncentiveToken(address token) external view returns (bool);

    /// @notice Gets the prover address
    /// @return The address of the prover
    function getProver() external view returns (address);

    /// @notice Checks if upkeep payments are currently enabled
    /// @return enabled True if upkeep payments are enabled
    function isUpkeepPaymentsEnabled() external view returns (bool);

    /// @notice Gets the proposed upkeep payments status and effective time
    /// @return enabled The proposed status
    /// @return effectiveTime The timestamp when the change becomes effective
    function getProposedUpkeepPaymentsStatus() external view returns (bool enabled, uint256 effectiveTime);

    /// @notice Checks if an address is a registered superform manager
    /// @param manager The address to check
    /// @return isSuperform True if the address is a superform manager
    function isSuperformManager(address manager) external view returns (bool);

    /// @notice Gets the list of all superform managers
    /// @return managers The list of all superform manager addresses
    function getAllSuperformManagers() external view returns (address[] memory);

    /// @notice Returns up to `limit` superform managers starting from `cursor`
    /// @param cursor The index to start reading from (0 … len-1)
    /// @param limit The maximum number of records to return
    /// @return chunkOfManagers The array slice [cursor … cursor+limit-1]
    /// @return next The next cursor value the caller should use, or 0 to indicate done
    function getManagersPaginated(
        uint256 cursor,
        uint256 limit
    )
        external
        view
        returns (address[] memory chunkOfManagers, uint256 next);

    /// @notice Gets the number of superform managers
    /// @return The number of superform managers
    function getSuperformManagersCount() external view returns (uint256);

    /// @notice Gets the SUP ID
    /// @return The ID of the SUP token
    function SUP() external view returns (bytes32);

    /// @notice Gets the UP ID
    /// @return The ID of the UP token
    function UP() external view returns (bytes32);

    /// @notice Gets the Treasury ID
    /// @return The ID for the Treasury in the registry
    function TREASURY() external view returns (bytes32);

    /// @notice Gets the SuperOracle ID
    /// @return The ID for the SuperOracle in the registry
    function SUPER_ORACLE() external view returns (bytes32);

    /// @notice Gets the ECDSA PPS Oracle ID
    /// @return The ID for the ECDSA PPS Oracle in the registry
    function ECDSAPPSORACLE() external view returns (bytes32);

    /// @notice Gets the SuperVaultAggregator ID
    /// @return The ID for the SuperVaultAggregator in the registry
    function SUPER_VAULT_AGGREGATOR() external view returns (bytes32);

    /// @notice Gets the SuperBank ID
    /// @return The ID for the SuperBank in the registry
    function SUPER_BANK() external view returns (bytes32);

    /// @notice Registers a keeper that cannot be added as authorized caller by managers
    /// @dev Only governance can register protected keepers
    /// @param keeper Address of the keeper to register
    function registerProtectedKeeper(address keeper) external;

    /// @notice Unregisters a protected keeper
    /// @dev Only governance can unregister protected keepers
    /// @param keeper Address of the keeper to unregister
    function unregisterProtectedKeeper(address keeper) external;

    /// @notice Checks if an address is a registered protected keeper
    /// @param keeper Address to check
    /// @return True if the address is a registered protected keeper
    function isProtectedKeeper(address keeper) external view returns (bool);

    /// @notice Gets all registered protected keepers
    /// @return Array of all registered protected keeper addresses
    function getProtectedKeepers() external view returns (address[] memory);

    /// @notice Gets the number of registered protected keepers
    /// @return The number of registered protected keepers
    function getProtectedKeepersCount() external view returns (uint256);

    /// @notice Gets the gas info for a specific SuperVault PPS Oracle
    /// @param oracle_ The address of the oracle to get gas info for
    /// @return The gas info for the specified oracle
    function getGasInfo(address oracle_) external view returns (GasInfo memory);
}


0.0% src/interfaces/SuperAsset/ISuperAssetFactory.sol

Lines covered: 0 / 0 (0.0%)

// SPDX-License-Identifier: MIT
pragma solidity 0.8.30;

/**
 * @title ISuperAssetFactory
 * @notice Interface for the SuperAssetFactory contract which deploys SuperAsset and its dependencies
 */
interface ISuperAssetFactory {
    /*//////////////////////////////////////////////////////////////
                            EVENTS
    //////////////////////////////////////////////////////////////*/

    /// @notice Emitted when a new SuperAsset and its dependencies are created
    /// @param superAsset Address of the deployed SuperAsset contract
    /// @param incentiveFund Address of the deployed IncentiveFundContract
    /// @param incentiveCalc Address of the deployed IncentiveCalculationContract
    /// @param name Name of the SuperAsset token
    /// @param symbol Symbol of the SuperAsset token
    event SuperAssetCreated(
        address indexed superAsset, address indexed incentiveFund, address incentiveCalc, string name, string symbol
    );

    /*//////////////////////////////////////////////////////////////
                            ERRORS
    //////////////////////////////////////////////////////////////*/

    /// @notice Thrown when an address parameter is zero
    error ZERO_ADDRESS();

    /// @notice Thrown when the caller is not authorized
    error UNAUTHORIZED();

    /// @notice Thrown when ICC is not whitelisted
    error ICC_NOT_WHITELISTED();

    /*//////////////////////////////////////////////////////////////
                            STRUCTS
    //////////////////////////////////////////////////////////////*/

    /// @notice Parameters required for creating a new SuperAsset
    /// @param name Name of the SuperAsset token
    /// @param symbol Symbol of the SuperAsset token
    /// @param swapFeeInPercentage Initial swap fee percentage for deposits
    /// @param swapFeeOutPercentage Initial swap fee percentage for redemptions
    /// @param asset Address of the primary asset
    /// @param superAssetManager Address of the manager
    /// @param superAssetStrategist Address of the strategist
    /// @param incentiveFundManager Address of the incentive fund manager
    /// @param incentiveCalculationContract Address of the incentive calculation contract
    /// @param tokenInIncentive Address of the token for incoming incentives
    /// @param tokenOutIncentive Address of the token for outgoing incentives
    struct AssetCreationParams {
        string name;
        string symbol;
        uint256 swapFeeInPercentage;
        uint256 swapFeeOutPercentage;
        address asset;
        address superAssetManager;
        address superAssetStrategist;
        address incentiveFundManager;
        address incentiveCalculationContract;
        address tokenInIncentive;
        address tokenOutIncentive;
    }

    /// @notice Data for a SuperAsset
    /// @param superAssetStrategist Address of the strategist
    /// @param superAssetManager Address of the manager
    /// @param incentiveFundManager Address of the incentive fund manager
    /// @param incentiveCalculationContract Address of the incentive calculation contract
    /// @param incentiveFundContract Address of the incentive fund contract
    struct SuperAssetData {
        address superAssetStrategist;
        address superAssetManager;
        address incentiveFundManager;
        address incentiveCalculationContract;
        address incentiveFundContract;
    }

    /*//////////////////////////////////////////////////////////////
                            EXTERNAL METHODS
    //////////////////////////////////////////////////////////////*/

    /// @notice Sets the manager for a SuperAsset
    /// @param superAsset Address of the SuperAsset contract
    /// @param _superAssetManager Address of the manager
    function setSuperAssetManager(address superAsset, address _superAssetManager) external;

    /// @notice Sets the strategist for a SuperAsset
    /// @param superAsset Address of the SuperAsset contract
    /// @param _superAssetStrategist Address of the strategist
    function setSuperAssetStrategist(address superAsset, address _superAssetStrategist) external;

    /// @notice Sets the incentive fund manager for a SuperAsset
    /// @param superAsset Address of the SuperAsset contract
    /// @param _incentiveFundManager Address of the incentive fund manager
    function setIncentiveFundManager(address superAsset, address _incentiveFundManager) external;

    /// @notice Sets the incentive calculation contract for a SuperAsset
    /// @param superAsset Address of the SuperAsset contract
    /// @param incentiveCalculationContract Address of the incentive calculation contract
    function setIncentiveCalculationContract(address superAsset, address incentiveCalculationContract) external;

    /// @notice Gets the manager for a SuperAsset
    /// @param superAsset Address of the SuperAsset contract
    /// @return superAssetManager Address of the manager
    function getSuperAssetManager(address superAsset) external view returns (address);

    /// @notice Gets the strategist for a SuperAsset
    /// @param superAsset Address of the SuperAsset contract
    /// @return superAssetStrategist Address of the strategist
    function getSuperAssetStrategist(address superAsset) external view returns (address);

    /// @notice Gets the incentive fund manager for a SuperAsset
    /// @param superAsset Address of the SuperAsset contract
    /// @return incentiveFundManager Address of the incentive fund manager
    function getIncentiveFundManager(address superAsset) external view returns (address);

    /// @notice Gets the incentive calculation contract for a SuperAsset
    /// @param superAsset Address of the SuperAsset contract
    /// @return incentiveCalculationContract Address of the incentive calculation contract
    function getIncentiveCalculationContract(address superAsset) external view returns (address);

    /// @notice Gets the incentive fund contract for a SuperAsset
    /// @param superAsset Address of the SuperAsset contract
    /// @return incentiveFundContract Address of the incentive fund contract
    function getIncentiveFundContract(address superAsset) external view returns (address);

    /// @notice Adds an Incentive Calculation Contract to the whitelist
    /// @param icc Address of the Incentive Calculation Contract
    function addICCToWhitelist(address icc) external;

    /// @notice Removes an Incentive Calculation Contract from the whitelist
    /// @param icc Address of the Incentive Calculation Contract
    function removeICCFromWhitelist(address icc) external;

    /// @notice Checks if an Incentive Calculation Contract is whitelisted
    /// @param icc Address of the Incentive Calculation Contract
    /// @return isValid Whether the Incentive Calculation Contract is whitelisted
    function isICCWhitelisted(address icc) external view returns (bool);

    /// @notice Creates a new SuperAsset instance with its dependencies
    /// @param params Parameters for creating the SuperAsset
    /// @return superAsset Address of the deployed SuperAsset contract
    /// @return incentiveFund Address of the deployed IncentiveFundContract
    function createSuperAsset(AssetCreationParams calldata params)
        external
        returns (address superAsset, address incentiveFund);
}


0.0% src/interfaces/SuperVault/ISuperVault.sol

Lines covered: 0 / 0 (0.0%)

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.30;

/// @title ISuperVault
/// @notice Interface for SuperVault core contract that manages share minting
/// @author Superform Labs
interface ISuperVault {
    /*//////////////////////////////////////////////////////////////
                                ERRORS
    //////////////////////////////////////////////////////////////*/
    error INVALID_ASSET();
    error INVALID_STRATEGY();
    error INVALID_ESCROW();
    error ZERO_ADDRESS();
    error ZERO_AMOUNT();
    error INVALID_OWNER_OR_OPERATOR();
    error INVALID_AMOUNT();
    error REQUEST_NOT_FOUND();
    error UNAUTHORIZED();
    error DEADLINE_PASSED();
    error INVALID_SIGNATURE();
    error NOT_IMPLEMENTED();
    error INVALID_NONCE();
    error INVALID_WITHDRAW_PRICE();
    error TRANSFER_FAILED();
    error CAP_EXCEEDED();
    error INVALID_PPS();
    error INVALID_CONTROLLER();
    error CONTROLLER_MUST_EQUAL_OWNER();

    /*//////////////////////////////////////////////////////////////
                                EVENTS
    //////////////////////////////////////////////////////////////*/

    event RedeemClaimable(
        address indexed user,
        uint256 indexed requestId,
        uint256 assets,
        uint256 shares,
        uint256 averageWithdrawPrice,
        uint256 accumulatorShares,
        uint256 accumulatorCostBasis
    );

    event NonceInvalidated(address indexed sender, bytes32 indexed nonce);

    event RedeemRequestCancelled(address indexed controller, address indexed sender);

    event SuperGovernorSet(address indexed superGovernor);

    /*//////////////////////////////////////////////////////////////
                            EXTERNAL METHODS
    //////////////////////////////////////////////////////////////*/

    function cancelRedeem(address controller) external;

    /// @notice Burn shares, only callable by strategy
    /// @param amount The amount of shares to burn
    function burnShares(uint256 amount) external;

    /// @notice Callback function for when a redeem becomes claimable
    /// @param user The user whose redeem is claimable
    /// @param assets The amount of assets to be received
    /// @param shares The amount of shares redeemed
    /// @param averageWithdrawPrice The average price of the redeem
    /// @param accumulatorShares The amount of shares in the accumulator
    /// @param accumulatorCostBasis The cost basis of the accumulator
    function onRedeemClaimable(
        address user,
        uint256 assets,
        uint256 shares,
        uint256 averageWithdrawPrice,
        uint256 accumulatorShares,
        uint256 accumulatorCostBasis
    )
        external;
}


0.0% src/interfaces/SuperVault/ISuperVaultAggregator.sol

Lines covered: 0 / 0 (0.0%)

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.30;

import { EnumerableSet } from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import { ISuperVaultStrategy } from "../SuperVault/ISuperVaultStrategy.sol";

/// @title ISuperVaultAggregator
/// @author Superform Labs
/// @notice Interface for the SuperVaultAggregator contract
/// @dev Registry and PPS oracle for all SuperVaults
interface ISuperVaultAggregator {
    /*//////////////////////////////////////////////////////////////
                                 STRUCTS
    //////////////////////////////////////////////////////////////*/
    /// @notice Arguments for forwarding PPS updates to avoid stack too deep errors
    /// @param strategy Address of the strategy being updated
    /// @param isExempt Whether the update is exempt from paying upkeep
    /// @param pps New price-per-share value
    /// @param ppsStdev Standard deviation of the price-per-share
    /// @param validatorSet Number of validators who calculated this PPS
    /// @param totalValidators Total number of validators in the network
    /// @param timestamp Timestamp when the value was generated
    /// @param upkeepCost Amount of upkeep tokens to charge if not exempt
    struct PPSUpdateData {
        address strategy;
        bool isExempt;
        uint256 pps;
        uint256 ppsStdev;
        uint256 validatorSet;
        uint256 totalValidators;
        uint256 timestamp;
        uint256 upkeepCost;
    }

    /// @notice Local variables for vault creation to avoid stack too deep
    /// @param currentNonce Current vault creation nonce
    /// @param salt Salt for deterministic proxy creation
    /// @param success Whether asset decimals retrieval was successful
    /// @param assetDecimals Decimals of the underlying asset
    /// @param underlyingDecimals Final decimals to use (18 if retrieval failed)
    /// @param initialPPS Initial price-per-share value
    struct VaultCreationLocalVars {
        uint256 currentNonce;
        bytes32 salt;
        bool success;
        uint8 assetDecimals;
        uint8 underlyingDecimals;
        uint256 initialPPS;
    }

    /// @notice Strategy configuration and state data
    /// @param pps Current price-per-share value
    /// @param lastUpdateTimestamp Last time PPS was updated
    /// @param minUpdateInterval Minimum time interval between PPS updates
    /// @param maxStaleness Maximum time allowed between PPS updates before staleness
    /// @param isPaused Whether the strategy is paused
    /// @param mainManager Address of the primary manager controlling the strategy
    /// @param secondaryManagers Set of secondary managers that can manage the strategy
    /// @param authorizedCallers List of callers authorized to update PPS without paying upkeep
    struct StrategyData {
        uint256 pps;
        uint256 ppsStdev;
        uint256 lastUpdateTimestamp;
        uint256 minUpdateInterval;
        uint256 maxStaleness;
        bool isPaused;
        address mainManager;
        EnumerableSet.AddressSet secondaryManagers;
        EnumerableSet.AddressSet authorizedCallers;
        // Manager change proposal data
        address proposedManager;
        uint256 managerChangeEffectiveTime;
        // Hook validation data
        bytes32 managerHooksRoot;
        // Hook root update proposal data
        bytes32 proposedHooksRoot;
        uint256 hooksRootEffectiveTime;
        // Veto status
        bool hooksRootVetoed;
        // PPS Verification thresholds
        uint256 dispersionThreshold; // Threshold for standard deviation / mean
        uint256 deviationThreshold; // Threshold for abs(new - current) / current
        uint256 mnThreshold; // Threshold for validatorSet / totalValidators ratio, scaled by 1e18
        // Banned global leaves mapping
        mapping(bytes32 => bool) bannedLeaves; // Mapping of leaf hash to banned status
    }

    /// @notice Parameters for creating a new SuperVault trio
    /// @param asset Address of the underlying asset
    /// @param name Name of the vault token
    /// @param symbol Symbol of the vault token
    /// @param mainManager Address of the vault mainManager
    /// @param minUpdateInterval Minimum time interval between PPS updates
    /// @param maxStaleness Maximum time allowed between PPS updates before staleness
    /// @param feeConfig Fee configuration for the vault
    struct VaultCreationParams {
        address asset;
        string name;
        string symbol;
        address mainManager;
        address[] secondaryManagers;
        uint256 minUpdateInterval;
        uint256 maxStaleness;
        ISuperVaultStrategy.FeeConfig feeConfig;
    }

    /// @notice Struct to hold cached hook validation state variables to avoid stack too deep
    /// @param globalHooksRootVetoed Cached global hooks root veto status
    /// @param globalHooksRoot Cached global hooks root
    /// @param strategyHooksRootVetoed Cached strategy hooks root veto status
    /// @param strategyRoot Cached strategy hooks root
    struct HookValidationCache {
        bool globalHooksRootVetoed;
        bytes32 globalHooksRoot;
        bool strategyHooksRootVetoed;
        bytes32 strategyRoot;
    }

    /// @notice Arguments for validating a hook to avoid stack too deep
    /// @param hookAddress Address of the hook contract
    /// @param hookArgs Encoded arguments for the hook operation
    /// @param globalProof Merkle proof for the global root
    /// @param strategyProof Merkle proof for the strategy-specific root
    struct ValidateHookArgs {
        address hookAddress;
        bytes hookArgs;
        bytes32[] globalProof;
        bytes32[] strategyProof;
    }

    /*//////////////////////////////////////////////////////////////
                                 EVENTS
    //////////////////////////////////////////////////////////////*/
    /// @notice Emitted when a new vault trio is created
    /// @param vault Address of the created SuperVault
    /// @param strategy Address of the created SuperVaultStrategy
    /// @param escrow Address of the created SuperVaultEscrow
    /// @param asset Address of the underlying asset
    /// @param name Name of the vault token
    /// @param symbol Symbol of the vault token
    /// @param nonce The nonce used for vault creation
    event VaultDeployed(
        address indexed vault,
        address indexed strategy,
        address escrow,
        address asset,
        string name,
        string symbol,
        uint256 indexed nonce
    );

    /// @notice Emitted when a PPS value is updated
    /// @param strategy Address of the strategy
    /// @param pps New price-per-share value
    /// @param ppsStdev Standard deviation of price-per-share value
    /// @param validatorSet Number of validators who calculated this PPS
    /// @param totalValidators Total number of validators in the network
    /// @param timestamp Timestamp of the update
    event PPSUpdated(
        address indexed strategy,
        uint256 pps,
        uint256 ppsStdev,
        uint256 validatorSet,
        uint256 totalValidators,
        uint256 timestamp
    );

    /// @notice Emitted when a strategy is paused due to missed updates
    /// @param strategy Address of the paused strategy
    event StrategyPaused(address indexed strategy);

    /// @notice Emitted when a strategy is unpaused
    /// @param strategy Address of the unpaused strategy
    event StrategyUnpaused(address indexed strategy);

    /// @notice Emitted when a strategy validation check fails but execution continues
    /// @param strategy Address of the strategy that failed the check
    /// @param reason String description of which check failed
    event StrategyCheckFailed(address indexed strategy, string reason);

    /// @notice Emitted when upkeep tokens are deposited
    /// @param manager Address of the manager
    /// @param amount Amount of UP tokens deposited
    event UpkeepDeposited(address indexed manager, uint256 amount);

    /// @notice Emitted when upkeep tokens are withdrawn
    /// @param manager Address of the manager
    /// @param amount Amount of UP tokens withdrawn
    event UpkeepWithdrawn(address indexed manager, uint256 amount);

    /// @notice Emitted when upkeep tokens are spent for validation
    /// @param manager Address of the manager
    /// @param amount Amount of UP tokens spent
    event UpkeepSpent(address indexed manager, uint256 amount);

    /// @notice Emitted when stake tokens are deposited
    /// @param manager Address of the manager
    /// @param amount Amount of UP tokens deposited as stake
    event StakeDeposited(address indexed manager, uint256 amount);

    /// @notice Emitted when stake tokens are withdrawn
    /// @param manager Address of the manager
    /// @param amount Amount of UP tokens withdrawn from stake
    event StakeWithdrawn(address indexed manager, uint256 amount);

    /// @notice Emitted when a manager's stake is slashed
    /// @param manager The manager whose stake was slashed
    /// @param amount The amount of UP tokens slashed
    event StakeSlashed(address indexed manager, uint256 amount);

    /// @notice Emitted when an authorized caller is added for a strategy
    /// @param strategy Address of the strategy
    /// @param caller Address of the authorized caller
    event AuthorizedCallerAdded(address indexed strategy, address indexed caller);

    /// @notice Emitted when an authorized caller is removed for a strategy
    /// @param strategy Address of the strategy
    /// @param caller Address of the removed caller
    event AuthorizedCallerRemoved(address indexed strategy, address indexed caller);

    /// @notice Emitted when a secondary manager is added to a strategy
    /// @param strategy Address of the strategy
    /// @param manager Address of the manager added
    event SecondaryManagerAdded(address indexed strategy, address indexed manager);

    /// @notice Emitted when a secondary manager is removed from a strategy
    /// @param strategy Address of the strategy
    /// @param manager Address of the manager removed
    event SecondaryManagerRemoved(address indexed strategy, address indexed manager);

    /// @notice Emitted when a primary manager is changed
    /// @param strategy Address of the strategy
    /// @param oldManager Address of the old primary manager
    /// @param newManager Address of the new primary manager
    event PrimaryManagerChanged(
        address indexed strategy, address indexed oldManager, address indexed newManager
    );

    /// @notice Emitted when a primary manager is changed to a superform manager
    /// @param strategy Address of the strategy
    /// @param oldManager Address of the old primary manager
    /// @param newManager Address of the new primary manager (superform manager)
    event PrimaryManagerChangedToSuperform(
        address indexed strategy, address indexed oldManager, address indexed newManager
    );

    /// @notice Emitted when a change to primary manager is proposed by a secondary manager
    /// @param strategy Address of the strategy
    /// @param proposer Address of the secondary manager who made the proposal
    /// @param newManager Address of the proposed new primary manager
    /// @param effectiveTime Timestamp when the proposal can be executed
    event PrimaryManagerChangeProposed(
        address indexed strategy, address indexed proposer, address indexed newManager, uint256 effectiveTime
    );

    /// @notice Emitted when a PPS update is stale (Validators could get slashed for innactivity)
    /// @param strategy Address of the strategy
    /// @param updateAuthority Address of the update authority
    /// @param timestamp Timestamp of the stale update
    event StaleUpdate(address indexed strategy, address indexed updateAuthority, uint256 timestamp);

    /// @notice Emitted when the upkeep cost per update is changed
    /// @param oldCost Previous upkeep cost per update
    /// @param newCost New upkeep cost per update
    event UpkeepCostUpdated(uint256 oldCost, uint256 newCost);

    /// @notice Emitted when the global hooks Merkle root is being updated
    /// @param root New root value
    /// @param effectiveTime Timestamp when the root becomes effective
    event GlobalHooksRootUpdateProposed(bytes32 indexed root, uint256 effectiveTime);

    /// @notice Emitted when the global hooks Merkle root is updated
    /// @param oldRoot Previous root value
    /// @param newRoot New root value
    event GlobalHooksRootUpdated(bytes32 indexed oldRoot, bytes32 newRoot);

    /// @notice Emitted when a strategy-specific hooks Merkle root is updated
    /// @param strategy Address of the strategy
    /// @param oldRoot Previous root value (may be zero)
    /// @param newRoot New root value
    event StrategyHooksRootUpdated(address indexed strategy, bytes32 oldRoot, bytes32 newRoot);

    /// @notice Emitted when a strategy-specific hooks Merkle root is proposed
    /// @param strategy Address of the strategy
    /// @param proposer Address of the account proposing the new root
    /// @param root New root value
    /// @param effectiveTime Timestamp when the root becomes effective
    event StrategyHooksRootUpdateProposed(
        address indexed strategy, address indexed proposer, bytes32 root, uint256 effectiveTime
    );

    /// @notice Emitted when a proposed global hooks root update is vetoed by SuperGovernor
    /// @param vetoed Whether the root is being vetoed (true) or unvetoed (false)
    /// @param root The root value affected
    event GlobalHooksRootVetoStatusChanged(bool vetoed, bytes32 indexed root);

    /// @notice Emitted when a strategy's hooks Merkle root veto status changes
    /// @param strategy Address of the strategy
    /// @param vetoed Whether the root is being vetoed (true) or unvetoed (false)
    /// @param root The root value affected
    event StrategyHooksRootVetoStatusChanged(address indexed strategy, bool vetoed, bytes32 indexed root);

    /// @notice Emitted when a strategy's PPS verification thresholds are updated
    /// @param strategy Address of the strategy
    /// @param dispersionThreshold New dispersion threshold (stddev/mean)
    /// @param deviationThreshold New deviation threshold (abs diff/current)
    /// @param mnThreshold New M/N threshold (validatorSet/totalValidators)
    event PPSVerificationThresholdsUpdated(
        address indexed strategy, uint256 dispersionThreshold, uint256 deviationThreshold, uint256 mnThreshold
    );

    /// @notice Emitted when the hooks root update timelock is changed
    /// @param newTimelock New timelock duration in seconds
    event HooksRootUpdateTimelockChanged(uint256 newTimelock);

    /// @notice Emitted when global leaves status is changed for a strategy
    /// @param strategy Address of the strategy
    /// @param leaves Array of leaf hashes that had their status changed
    /// @param statuses Array of new banned statuses (true = banned, false = allowed)
    event GlobalLeavesStatusChanged(address indexed strategy, bytes32[] leaves, bool[] statuses);

    /// @notice Emitted when a proposed global hooks root update is vetoed by a guardian
    /// @param guardian Address of the guardian who vetoed the update
    /// @param root The vetoed root value
    event GlobalHooksRootVetoed(address indexed guardian, bytes32 indexed root);

    /// @notice Emitted when a proposed strategy hooks root update is vetoed by a guardian
    /// @param guardian Address of the guardian who vetoed the update
    /// @param strategy Address of the strategy whose root update was vetoed
    /// @param root The vetoed root value
    event StrategyHooksRootVetoed(address indexed guardian, address indexed strategy, bytes32 indexed root);

    /// @notice Emitted when upkeep is claimed
    /// @param superBank Address of the superBank
    /// @param amount Amount of upkeep claimed
    event UpkeepClaimed(address indexed superBank, uint256 amount);

    /// @notice Emitted when PPS update is too frequent (before minUpdateInterval)
    event UpdateTooFrequent();

    /// @notice Emitted when PPS update timestamp is not monotonically increasing
    event TimestampNotMonotonic();

    /// @notice Emitted when a manager does not have enough upkeep balance
    event InsufficientUpkeep(address indexed strategy, address indexed manager, uint256 balance, uint256 cost);

    /// @notice Emitted when the provided timestamp is too large
    event ProvidedTimestampExceedsBlockTimestamp(address indexed strategy, uint256 argsTimestamp, uint256 blockTimestamp);

    /// @notice Emitted when a strategy is unknown
    event UnknownStrategy(address indexed strategy);

    /// @notice Emitted when a strategy is managed by Superform
    event SuperformManager(address indexed strategy, address indexed manager);

    /// @notice Emitted when the caller is authorized
    event AuthorizedCaller(address indexed strategy, address indexed caller);

    /*///////////////////////////////////////////////////////////////
                                 ERRORS
    //////////////////////////////////////////////////////////////*/
    /// @notice Thrown when address provided is zero
    error ZERO_ADDRESS();
    /// @notice Thrown when amount provided is zero
    error ZERO_AMOUNT();
    /// @notice Thrown when array length is zero
    error ZERO_ARRAY_LENGTH();
    /// @notice Thrown when array length is zero
    error ARRAY_LENGTH_MISMATCH();
    /// @notice Thrown when asset is invalid
    error INVALID_ASSET();
    /// @notice Thrown when insufficient upkeep balance for operation
    error INSUFFICIENT_UPKEEP();
    /// @notice Thrown when vault is paused but operation requires active state
    error VAULT_PAUSED();
    /// @notice Thrown when caller is not an approved PPS oracle
    error UNAUTHORIZED_PPS_ORACLE();
    /// @notice Thrown when PPS update is too stale (after maxStaleness)
    error UPDATE_TOO_STALE();
    /// @notice Thrown when caller is not authorized for update
    error UNAUTHORIZED_UPDATE_AUTHORITY();
    /// @notice Thrown when strategy address is not a known SuperVault strategy
    error UNKNOWN_STRATEGY();
    /// @notice Thrown when withdrawing more upkeep than available
    error INSUFFICIENT_UPKEEP_BALANCE();
    /// @notice Thrown when withdrawing more stake than available
    error INSUFFICIENT_STAKE_BALANCE();
    /// @notice Thrown when caller is already authorized
    error CALLER_ALREADY_AUTHORIZED();
    /// @notice Thrown when caller is not authorized
    error CALLER_NOT_AUTHORIZED();
    /// @notice Thrown when array index is out of bounds
    error INDEX_OUT_OF_BOUNDS();
    /// @notice Thrown when attempting to remove the last manager
    error CANNOT_REMOVE_LAST_MANAGER();
    /// @notice Thrown when attempting to add a manager that already exists
    error MANAGER_ALREADY_EXISTS();
    /// @notice Thrown when there is no pending global hooks root change
    error NO_PENDING_GLOBAL_ROOT_CHANGE();
    /// @notice Thrown when attempting to execute an in-progress manager change before timelock elapsed
    error MANAGER_CHANGE_NOT_READY();
    /// @notice Thrown when attempting to execute a hooks root change before timelock has elapsed
    error ROOT_UPDATE_NOT_READY();
    /// @notice Thrown when a provided hook fails Merkle proof validation
    error HOOK_VALIDATION_FAILED();
    /// @notice Thrown when a non-guardian tries to veto a root update
    error NOT_A_GUARDIAN();
    /// @notice Thrown when trying to veto a root update that doesn't exist
    error NO_PENDING_ROOT_UPDATE();
    /// @notice Thrown when manager is not found
    error MANAGER_NOT_FOUND();
    /// @notice Thrown when there is no pending manager change proposal
    error NO_PENDING_MANAGER_CHANGE();
    /// @notice Thrown when caller is not authorized to update settings
    error UNAUTHORIZED_CALLER();
    /// @notice Thrown when the timelock for a proposed change has not expired
    error TIMELOCK_NOT_EXPIRED();
    /// @notice Thrown when an array length is invalid
    error INVALID_ARRAY_LENGTH();
    /// @notice Thrown when trying to add a protected keeper as an authorized caller
    error CANNOT_ADD_PROTECTED_KEEPER();
    /// @notice Thrown when the provided maxStaleness is less than the minimum required staleness
    error MAX_STALENESS_TOO_LOW();
    /// @notice Thrown when arrays have mismatched lengths
    error MISMATCHED_ARRAY_LENGTHS();
    /// @notice Thrown when timestamp is invalid
    error INVALID_TIMESTAMP(uint256 index);
    /// @notice Thrown when too many secondary managers are added
    error TOO_MANY_SECONDARY_MANAGERS();
    /// @notice Thrown when the number of strategies exceeds the maximum allowed
    error MAX_STRATEGIES_EXCEEDED();
    /// @notice Thrown when provided timestamp is too large
    error TIMESTAMP_EXCEEDS_BLOCK();

    /*//////////////////////////////////////////////////////////////
                            VAULT CREATION
    //////////////////////////////////////////////////////////////*/
    /// @notice Creates a new SuperVault trio (SuperVault, SuperVaultStrategy, SuperVaultEscrow)
    /// @param params Parameters for the new vault creation
    /// @return superVault Address of the created SuperVault
    /// @return strategy Address of the created SuperVaultStrategy
    /// @return escrow Address of the created SuperVaultEscrow
    function createVault(VaultCreationParams calldata params)
        external
        returns (address superVault, address strategy, address escrow);

    /*//////////////////////////////////////////////////////////////
                          PPS UPDATE FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    /// @notice Arguments for batch forwarding PPS updates
    /// @param strategies Array of strategy addresses
    /// @param ppss Array of price-per-share values
    /// @param ppsStdevs Array of standard deviations of price-per-share values
    /// @param validatorSets Array of numbers of validators who calculated each PPS
    /// @param totalValidators Total number of validators in the network
    /// @param timestamps Array of timestamps when values were generated
    struct ForwardPPSArgs {
        address[] strategies;
        uint256[] ppss;
        uint256[] ppsStdevs;
        uint256[] validatorSets;
        uint256[] totalValidators;
        uint256[] timestamps;
        address updateAuthority;
    }

    /// @notice Batch forwards validated PPS updates to multiple strategies
    /// @param args Struct containing all batch PPS update parameters
    function forwardPPS(ForwardPPSArgs calldata args) external;

    /*//////////////////////////////////////////////////////////////
                        UPKEEP MANAGEMENT
    //////////////////////////////////////////////////////////////*/

    /// @notice Deposits UP tokens for manager upkeep
    /// @param manager Address of the manager to deposit for
    /// @param amount Amount of UP tokens to deposit
    function depositUpkeep(address manager, uint256 amount) external;

    /// @notice Withdraws UP tokens from manager upkeep balance
    /// @param amount Amount of UP tokens to withdraw
    function withdrawUpkeep(uint256 amount) external;

    /// @notice Claims upkeep tokens from the contract
    /// @param amount Amount of UP tokens to claim
    function claimUpkeep(uint256 amount) external;

    /*//////////////////////////////////////////////////////////////
                        STAKE MANAGEMENT
    //////////////////////////////////////////////////////////////*/

    /// @notice Deposits UP tokens as stake for manager economic security
    /// @param manager Address of the manager to deposit stake for
    /// @param amount Amount of UP tokens to deposit as stake
    function depositStake(address manager, uint256 amount) external;

    /// @notice Withdraws UP tokens from manager stake balance
    /// @param amount Amount of UP tokens to withdraw from stake
    function withdrawStake(uint256 amount) external;

    /// @notice Slashes a manager's stake balance by a specified amount
    /// @param manager The manager whose stake will be slashed
    /// @param amount The amount of UP tokens to slash from the manager's stake balance
    function slashStake(address manager, uint256 amount) external;

    /*//////////////////////////////////////////////////////////////
                        AUTHORIZED CALLER MANAGEMENT
    //////////////////////////////////////////////////////////////*/

    /// @notice Adds an authorized caller for a strategy
    /// @param strategy Address of the strategy
    /// @param caller Address of the caller to authorize
    function addAuthorizedCaller(address strategy, address caller) external;

    /// @notice Removes an authorized caller for a strategy
    /// @param strategy Address of the strategy
    /// @param caller Address of the caller to remove
    function removeAuthorizedCaller(address strategy, address caller) external;

    /*//////////////////////////////////////////////////////////////
                       MANAGER MANAGEMENT FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    /// @notice Adds a secondary manager to a strategy
    /// @notice A manager can either be secondary or primary
    /// @param strategy Address of the strategy
    /// @param manager Address of the manager to add
    function addSecondaryManager(address strategy, address manager) external;

    /// @notice Removes a secondary manager from a strategy
    /// @param strategy Address of the strategy
    /// @param manager Address of the manager to remove
    function removeSecondaryManager(address strategy, address manager) external;

    /// @notice Changes the primary manager of a strategy immediately (only callable by SuperGovernor)
    /// @notice A manager can either be secondary or primary
    /// @param strategy Address of the strategy
    /// @param newManager Address of the new primary manager
    function changePrimaryManager(address strategy, address newManager) external;

    /// @notice Proposes a change to the primary manager (callable by secondary managers)
    /// @notice A manager can either be secondary or primary
    /// @param strategy Address of the strategy
    /// @param newManager Address of the proposed new primary manager
    function proposeChangePrimaryManager(address strategy, address newManager) external;

    /// @notice Executes a previously proposed change to the primary manager after timelock
    /// @param strategy Address of the strategy
    function executeChangePrimaryManager(address strategy) external;

    /*//////////////////////////////////////////////////////////////
                        HOOK VALIDATION FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    /// @notice Sets a new hooks root update timelock duration
    /// @param newTimelock The new timelock duration in seconds
    function setHooksRootUpdateTimelock(uint256 newTimelock) external;

    /// @notice Proposes an update to the global hooks Merkle root
    /// @dev Only callable by SUPER_GOVERNOR
    /// @param newRoot New Merkle root for global hooks validation
    function proposeGlobalHooksRoot(bytes32 newRoot) external;

    /// @notice Executes a previously proposed global hooks root update after timelock period
    /// @dev Can be called by anyone after the timelock period has elapsed
    function executeGlobalHooksRootUpdate() external;

    /// @notice Proposes an update to a strategy-specific hooks Merkle root
    /// @dev Only callable by the main manager for the strategy
    /// @param strategy Address of the strategy
    /// @param newRoot New Merkle root for strategy-specific hooks
    function proposeStrategyHooksRoot(address strategy, bytes32 newRoot) external;

    /// @notice Executes a previously proposed strategy hooks root update after timelock period
    /// @dev Can be called by anyone after the timelock period has elapsed
    /// @param strategy Address of the strategy whose root update to execute
    function executeStrategyHooksRootUpdate(address strategy) external;

    /// @notice Set veto status for the global hooks root
    /// @dev Only callable by SuperGovernor
    /// @param vetoed Whether to veto (true) or unveto (false) the global hooks root
    function setGlobalHooksRootVetoStatus(bool vetoed) external;

    /// @notice Set veto status for a strategy-specific hooks root
    /// @notice Sets the veto status of a strategy's hooks Merkle root
    /// @param strategy Address of the strategy
    /// @param vetoed Whether to veto (true) or unveto (false)
    function setStrategyHooksRootVetoStatus(address strategy, bool vetoed) external;

    /// @notice Updates the PPS verification thresholds for a strategy
    /// @param strategy Address of the strategy
    /// @param dispersionThreshold_ New dispersion threshold (stddev/mean ratio, scaled by 1e18)
    /// @param deviationThreshold_ New deviation threshold (abs diff/current ratio, scaled by 1e18)
    /// @param mnThreshold_ New M/N threshold (validatorSet/totalValidators ratio, scaled by 1e18)
    function updatePPSVerificationThresholds(
        address strategy,
        uint256 dispersionThreshold_,
        uint256 deviationThreshold_,
        uint256 mnThreshold_
    )
        external;

    /// @notice Changes the banned status of global leaves for a specific strategy
    /// @dev Only callable by the primary manager of the strategy
    /// @param leaves Array of leaf hashes to change status for
    /// @param statuses Array of banned statuses (true = banned, false = allowed)
    /// @param strategy Address of the strategy to change banned leaves for
    function changeGlobalLeavesStatus(
        bytes32[] memory leaves,
        bool[] memory statuses,
        address strategy
    )
        external;

    /*//////////////////////////////////////////////////////////////
                              VIEW FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    /// @notice Returns the current vault creation nonce
    /// @dev This nonce is incremented every time a new vault is created
    /// @return Current vault creation nonce
    function getCurrentNonce() external view returns (uint256);

    /// @notice Check if the global hooks root is currently vetoed
    /// @return vetoed True if the global hooks root is vetoed
    function isGlobalHooksRootVetoed() external view returns (bool vetoed);

    /// @notice Check if a strategy hooks root is currently vetoed
    /// @param strategy Address of the strategy to check
    /// @return vetoed True if the strategy hooks root is vetoed
    function isStrategyHooksRootVetoed(address strategy) external view returns (bool vetoed);

    /// @notice Gets the current hooks root update timelock duration
    /// @return The current timelock duration in seconds
    function getHooksRootUpdateTimelock() external view returns (uint256);

    /// @notice Gets the current PPS (price-per-share) for a strategy
    /// @param strategy Address of the strategy
    /// @return pps Current price-per-share value
    function getPPS(address strategy) external view returns (uint256 pps);

    /// @notice Gets the current PPS and its standard deviation for a strategy
    /// @param strategy Address of the strategy
    /// @return pps Current price-per-share value
    /// @return ppsStdev Standard deviation of price-per-share value
    function getPPSWithStdDev(address strategy) external view returns (uint256 pps, uint256 ppsStdev);

    /// @notice Gets the last update timestamp for a strategy's PPS
    /// @param strategy Address of the strategy
    /// @return timestamp Last update timestamp
    function getLastUpdateTimestamp(address strategy) external view returns (uint256 timestamp);

    /// @notice Gets the minimum update interval for a strategy
    /// @param strategy Address of the strategy
    /// @return interval Minimum time between updates
    function getMinUpdateInterval(address strategy) external view returns (uint256 interval);

    /// @notice Gets the maximum staleness period for a strategy
    /// @param strategy Address of the strategy
    /// @return staleness Maximum time allowed between updates
    function getMaxStaleness(address strategy) external view returns (uint256 staleness);

    /// @notice Gets the PPS verification thresholds for a strategy
    /// @param strategy Address of the strategy
    /// @return dispersionThreshold The current dispersion threshold (stddev/mean ratio, scaled by 1e18)
    /// @return deviationThreshold The current deviation threshold (abs diff/current ratio, scaled by 1e18)
    /// @return mnThreshold The current M/N threshold (validatorSet/totalValidators ratio, scaled by 1e18)
    function getPPSVerificationThresholds(address strategy)
        external
        view
        returns (uint256 dispersionThreshold, uint256 deviationThreshold, uint256 mnThreshold);

    /// @notice Checks if a strategy is currently paused
    /// @param strategy Address of the strategy
    /// @return isPaused True if paused, false otherwise
    function isStrategyPaused(address strategy) external view returns (bool isPaused);

    /// @notice Gets the current upkeep balance for a manager
    /// @param manager Address of the manager
    /// @return balance Current upkeep balance in UP tokens
    function getUpkeepBalance(address manager) external view returns (uint256 balance);

    /// @notice Gets the current stake balance for a manager
    /// @param manager Address of the manager
    /// @return balance Current stake balance in UP tokens
    function getStakeBalance(address manager) external view returns (uint256 balance);

    /// @notice Gets all authorized callers for a strategy
    /// @param strategy Address of the strategy
    /// @return callers Array of authorized callers
    function getAuthorizedCallers(address strategy) external view returns (address[] memory callers);

    /// @notice Gets the main manager for a strategy
    /// @param strategy Address of the strategy
    /// @return manager Address of the main manager
    function getMainManager(address strategy) external view returns (address manager);

    /// @notice Checks if an address is the main manager for a strategy
    /// @param manager Address of the manager
    /// @param strategy Address of the strategy
    /// @return isMainManager True if the address is the main manager, false otherwise
    function isMainManager(address manager, address strategy) external view returns (bool isMainManager);

    /// @notice Gets all secondary managers for a strategy
    /// @param strategy Address of the strategy
    /// @return secondaryManagers Array of secondary manager addresses
    function getSecondaryManagers(address strategy) external view returns (address[] memory secondaryManagers);

    /// @notice Checks if an address is a secondary manager for a strategy
    /// @param manager Address of the manager
    /// @param strategy Address of the strategy
    /// @return isSecondaryManager True if the address is a secondary manager, false otherwise
    function isSecondaryManager(
        address manager,
        address strategy
    )
        external
        view
        returns (bool isSecondaryManager);

    /// @dev Internal helper function to check if an address is any kind of manager (primary or secondary)
    /// @param manager Address to check
    /// @param strategy The strategy to check against
    /// @return True if the address is either the primary manager or a secondary manager
    function isAnyManager(address manager, address strategy) external view returns (bool);

    /// @notice Gets all created SuperVaults
    /// @return Array of SuperVault addresses
    function getAllSuperVaults() external view returns (address[] memory);

    /// @notice Gets a SuperVault by index
    /// @param index The index of the SuperVault
    /// @return The SuperVault address at the given index
    function superVaults(uint256 index) external view returns (address);

    /// @notice Gets all created SuperVaultStrategies
    /// @return Array of SuperVaultStrategy addresses
    function getAllSuperVaultStrategies() external view returns (address[] memory);

    /// @notice Gets a SuperVaultStrategy by index
    /// @param index The index of the SuperVaultStrategy
    /// @return The SuperVaultStrategy address at the given index
    function superVaultStrategies(uint256 index) external view returns (address);

    /// @notice Gets all created SuperVaultEscrows
    /// @return Array of SuperVaultEscrow addresses
    function getAllSuperVaultEscrows() external view returns (address[] memory);

    /// @notice Gets a SuperVaultEscrow by index
    /// @param index The index of the SuperVaultEscrow
    /// @return The SuperVaultEscrow address at the given index
    function superVaultEscrows(uint256 index) external view returns (address);

    /// @notice Validates a hook against both global and strategy-specific Merkle roots
    /// @param strategy Address of the strategy
    /// @param args Arguments for hook validation
    /// @return isValid True if the hook is valid against either root
    function validateHook(
        address strategy,
        ValidateHookArgs calldata args
    )
        external
        view
        returns (bool isValid);

    /// @notice Batch validates multiple hooks against Merkle roots
    /// @param strategy Address of the strategy
    /// @param argsArray Array of hook validation arguments
    /// @return validHooks Array of booleans indicating which hooks are valid
    function validateHooks(
        address strategy,
        ValidateHookArgs[] calldata argsArray
    )
        external
        view
        returns (bool[] memory validHooks);

    /// @notice Gets the current global hooks Merkle root
    /// @return root The current global hooks Merkle root
    function getGlobalHooksRoot() external view returns (bytes32 root);

    /// @notice Gets the proposed global hooks root and effective time
    /// @return root The proposed global hooks Merkle root
    /// @return effectiveTime The timestamp when the proposed root becomes effective
    function getProposedGlobalHooksRoot() external view returns (bytes32 root, uint256 effectiveTime);

    /// @notice Checks if the global hooks root is active (timelock period has passed)
    /// @return isActive True if the global hooks root is active
    function isGlobalHooksRootActive() external view returns (bool);

    /// @notice Gets the hooks Merkle root for a specific strategy
    /// @param strategy Address of the strategy
    /// @return root The strategy-specific hooks Merkle root
    function getStrategyHooksRoot(address strategy) external view returns (bytes32 root);

    /// @notice Gets the proposed strategy hooks root and effective time
    /// @param strategy Address of the strategy
    /// @return root The proposed strategy hooks Merkle root
    /// @return effectiveTime The timestamp when the proposed root becomes effective
    function getProposedStrategyHooksRoot(address strategy)
        external
        view
        returns (bytes32 root, uint256 effectiveTime);
}


0.0% src/interfaces/SuperVault/ISuperVaultEscrow.sol

Lines covered: 0 / 0 (0.0%)

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.30;

/// @title ISuperVaultEscrow
/// @notice Interface for SuperVault escrow contract that holds shares during request/claim process
/// @author Superform Labs
interface ISuperVaultEscrow {
    /*//////////////////////////////////////////////////////////////
                                ERRORS
    //////////////////////////////////////////////////////////////*/
    error ALREADY_INITIALIZED();
    error UNAUTHORIZED();
    error ZERO_ADDRESS();

    /*//////////////////////////////////////////////////////////////
                            INITIALIZATION
    //////////////////////////////////////////////////////////////*/

    /// @notice Initialize the escrow with required parameters
    /// @param vaultAddress The vault contract address
    /// @param strategyAddress The strategy contract address
    function initialize(address vaultAddress, address strategyAddress) external;

    /*//////////////////////////////////////////////////////////////
                            VAULT FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    /// @notice Transfer shares from user to escrow during redeem request
    /// @param from The address to transfer shares from
    /// @param amount The amount of shares to transfer
    function escrowShares(address from, uint256 amount) external;

    /// @notice Return shares from escrow to user during redeem cancellation
    /// @param to The address to return shares to
    /// @param amount The amount of shares to return
    function returnShares(address to, uint256 amount) external;
}


0.0% src/interfaces/SuperVault/ISuperVaultStrategy.sol

Lines covered: 0 / 0 (0.0%)

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.30;

import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { ISuperHook, Execution } from "@superform-v2-core/src/interfaces/ISuperHook.sol";

/// @title ISuperVaultStrategy
/// @author Superform Labs
/// @notice Interface for SuperVault strategy implementation that manages yield sources and executes strategies
interface ISuperVaultStrategy {
    /*//////////////////////////////////////////////////////////////
                                ERRORS
    //////////////////////////////////////////////////////////////*/

    error ZERO_LENGTH();
    error INVALID_HOOK();
    error ZERO_ADDRESS();
    error ACCESS_DENIED();
    error INVALID_AMOUNT();
    error INVALID_MANAGER();
    error OPERATION_FAILED();
    error INVALID_TIMESTAMP();
    error REQUEST_NOT_FOUND();
    error INVALID_HOOK_ROOT();
    error INVALID_HOOK_TYPE();
    error INSUFFICIENT_FUNDS();
    error ZERO_OUTPUT_AMOUNT();
    error INSUFFICIENT_SHARES();
    error ZERO_EXPECTED_VALUE();
    error INVALID_ARRAY_LENGTH();
    error ACTION_TYPE_DISALLOWED();
    error YIELD_SOURCE_NOT_FOUND();
    error INVALID_EMERGENCY_ADMIN();
    error INVALID_PERIPHERY_REGISTRY();
    error YIELD_SOURCE_ALREADY_EXISTS();
    error INVALID_PERFORMANCE_FEE_BPS();
    error INVALID_EMERGENCY_WITHDRAWAL();
    error ASYNC_REQUEST_BLOCKING();
    error MINIMUM_PREVIOUS_HOOK_OUT_AMOUNT_NOT_MET();
    error MINIMUM_OUTPUT_AMOUNT_ASSETS_NOT_MET();
    error INVALID_REDEEM_CLAIM();
    error MANAGER_NOT_AUTHORIZED();
    error PPS_UPDATE_RATE_LIMITED();
    error PPS_OUT_OF_BOUNDS();
    error CALCULATION_BLOCK_TOO_OLD();
    error INVALID_PPS();
    error INVALID_REDEEM_FILL();
    error SLIPPAGE_EXCEEDED();
    error INVALID_VAULT();
    error STAKE_TOO_LOW();
    error OPERATIONS_BLOCKED_BY_VETO();
    error HOOK_VALIDATION_FAILED();
    error STRATEGY_PAUSED();
    error INVALID_MAX_SLIPPAGE_BPS();
    error NO_PROPOSAL();

    /*//////////////////////////////////////////////////////////////
                                EVENTS
    //////////////////////////////////////////////////////////////*/

    event SuperGovernorSet(address indexed superGovernor);
    event Initialized(address indexed vault);
    event YieldSourceAdded(address indexed source, address indexed oracle);
    event YieldSourceOracleUpdated(address indexed source, address indexed oldOracle, address indexed newOracle);
    event YieldSourceRemoved(address indexed source);

    event HookRootUpdated(bytes32 newRoot);
    event HookRootProposed(bytes32 proposedRoot, uint256 effectiveTime);
    event EmergencyWithdrawableProposed(bool newWithdrawable, uint256 effectiveTime);
    event EmergencyWithdrawableUpdated(bool withdrawable);
    event EmergencyWithdrawableProposalCanceled();
    event EmergencyWithdrawal(address indexed recipient, uint256 assets);
    event VaultFeeConfigUpdated(uint256 performanceFeeBps, uint256 managementFeeBps, address indexed recipient);
    event VaultFeeConfigProposed(
        uint256 performanceFeeBps, uint256 managementFeeBps, address indexed recipient, uint256 effectiveTime
    );
    event MaxPPSSlippageUpdated(uint256 maxSlippageBps);
    event HooksExecuted(address[] hooks);
    event RedeemRequestPlaced(address indexed controller, address indexed owner, uint256 shares);
    event RedeemRequestFulfilled(address indexed controller, address indexed receiver, uint256 assets, uint256 shares);
    event RedeemRequestCanceled(address indexed controller, uint256 shares);
    event HookExecuted(
        address indexed hook,
        address indexed prevHook,
        address indexed targetedYieldSource,
        bool usePrevHookAmount,
        bytes hookCalldata
    );
    event FulfillHookExecuted(address indexed hook, address indexed targetedYieldSource, bytes hookCalldata);

    event PPSUpdated(uint256 newPPS, uint256 calculationBlock);

    event RedeemRequestsFulfilled(address[] hooks, address[] controllers, uint256 processedShares, uint256 currentPPS);

    event FeePaid(address indexed recipient, uint256 amount, uint256 performanceFeeBps);
    event ManagementFeePaid(address indexed controller, address indexed recipient, uint256 feeAssets, uint256 feeBps);
    event DepositHandled(address indexed controller, uint256 assets, uint256 shares);

    /*//////////////////////////////////////////////////////////////
                                STRUCTS
    //////////////////////////////////////////////////////////////*/

    struct FeeConfig {
        uint256 performanceFeeBps; // On profit at fulfill time
        uint256 managementFeeBps; // Entry fee on deposit/mint (asset-side)
        address recipient; // Fee sink (entry + performance)
    }

    /// @notice Structure for hook execution arguments
    struct ExecuteArgs {
        /// @notice Array of hooks to execute
        address[] hooks;
        /// @notice Calldata for each hook (must match hooks array length)
        bytes[] hookCalldata;
        /// @notice Expected output amounts or output shares
        uint256[] expectedAssetsOrSharesOut;
        /// @notice Global Merkle proofs for hook validation (must match hooks array length)
        bytes32[][] globalProofs;
        /// @notice Strategy-specific Merkle proofs for hook validation (must match hooks array length)
        bytes32[][] strategyProofs;
    }

    struct FulfillArgs {
        address[] controllers;
        address[] hooks;
        bytes[] hookCalldata;
        uint256[] expectedAssetsOrSharesOut;
        bytes32[][] globalProofs;
        bytes32[][] strategyProofs;
    }

    struct YieldSource {
        address oracle; // Associated yield source oracle address
    }

    /// @notice Comprehensive information about a yield source including its address and configuration
    struct YieldSourceInfo {
        address sourceAddress; // Address of the yield source
        address oracle; // Associated yield source oracle address
    }

    /// @notice State specific to asynchronous redeem requests
    struct SuperVaultState {
        uint256 pendingRedeemRequest; // Shares requested
        uint256 maxWithdraw; // Assets claimable after fulfillment
        uint256 averageRequestPPS; // Average PPS at the time of redeem request
        // Accumulators needed for fee calculation on redeem
        uint256 accumulatorShares;
        uint256 accumulatorCostBasis;
        uint256 averageWithdrawPrice; // Average price for claimable assets
    }

    struct ExecutionVars {
        bool success;
        address targetedYieldSource;
        uint256 outAmount;
        ISuperHook hookContract;
        Execution[] executions;
    }

    struct OutflowExecutionVars {
        bool success;
        address targetedYieldSource;
        address svAsset;
        uint256 outAmount;
        uint256 superVaultShares;
        uint256 amountOfAssets;
        uint256 amountConvertedToUnderlyingShares;
        uint256 balanceAssetBefore;
        Execution[] executions;
        ISuperHook hookContract;
        ISuperHook.HookType hookType;
    }

    /*//////////////////////////////////////////////////////////////
                                ENUMS
    //////////////////////////////////////////////////////////////*/
    enum Operation {
        Deposit,
        RedeemRequest,
        CancelRedeem,
        ClaimRedeem,
        Claim,
        UpdateDepositAccumulators
    }

    /*//////////////////////////////////////////////////////////////
                        CORE STRATEGY OPERATIONS
    //////////////////////////////////////////////////////////////*/

    /// @notice Initializes the strategy with required parameters
    /// @param vaultAddress Address of the associated SuperVault
    /// @param feeConfigData Fee configuration
    function initialize(address vaultAddress, FeeConfig memory feeConfigData) external;

    /// @notice Execute a 4626 deposit by processing assets.
    /// @param controller The controller address
    /// @param assetsGross The amount of gross assets user has to deposit
    /// @return sharesNet The amount of net shares to mint
    function handleOperations4626Deposit(
        address controller,
        uint256 assetsGross
    )
        external
        returns (uint256 sharesNet);

    /// @notice Execute a 4626 mint by processing shares.
    /// @param controller The controller address
    /// @param sharesNet The amount of shares to mint
    /// @param assetsGross The amount of gross assets user has to deposit
    /// @param assetsNet The amount of net assets that strategy will receive
    function handleOperations4626Mint(
        address controller,
        uint256 sharesNet,
        uint256 assetsGross,
        uint256 assetsNet
    )
        external;

    /// @notice Quotes the amount of assets that will be received for a given amount of shares.
    /// @param shares The amount of shares to mint
    /// @return assetsGross The amount of gross assets that will be received
    /// @return assetsNet The amount of net assets that will be received
    function quoteMintAssetsGross(uint256 shares) external view returns (uint256 assetsGross, uint256 assetsNet);

    /// @notice Execute async redeem requests (redeem, cancel, claim).
    /// @param op The operation type (RedeemRequest, CancelRedeem, ClaimRedeem)
    /// @param controller The controller address
    /// @param receiver The receiver address
    /// @param amount The amount of assets or shares
    function handleOperations7540(Operation op, address controller, address receiver, uint256 amount) external;

    /*//////////////////////////////////////////////////////////////
                MANAGER EXTERNAL ACCESS FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    /// @notice Execute hooks for general strategy management (rebalancing, etc.).
    /// @param args Execution arguments containing hooks, calldata, proofs, expectations.
    function executeHooks(ExecuteArgs calldata args) external payable;

    /// @notice Fulfills pending redeem requests by executing specific fulfill hooks.
    /// @param args Execution arguments containing fulfill hooks, calldata, and expected outputs (proofs ignored).
    function fulfillRedeemRequests(FulfillArgs calldata args) external;

    /*//////////////////////////////////////////////////////////////
                        YIELD SOURCE MANAGEMENT
    //////////////////////////////////////////////////////////////*/

    /// @notice Manage a single yield source: add, update oracle, or remove
    /// @param source Address of the yield source
    /// @param oracle Address of the oracle (used for adding/updating, ignored for removal)
    /// @param actionType Type of action: 0=Add, 1=UpdateOracle, 2=Remove
    function manageYieldSource(address source, address oracle, uint8 actionType) external;

    /// @notice Batch manage multiple yield sources in a single transaction
    /// @param sources Array of yield source addresses
    /// @param oracles Array of oracle addresses (used for adding/updating, ignored for removal)
    /// @param actionTypes Array of action types: 0=Add, 1=UpdateOracle, 2=Remove
    function manageYieldSources(
        address[] calldata sources,
        address[] calldata oracles,
        uint8[] calldata actionTypes
    )
        external;

    /// @notice Propose or execute a hook root update
    /// @notice Propose changes to vault-specific fee configuration
    /// @param performanceFeeBps New performance fee in basis points
    /// @param managementFeeBps New management fee in basis points
    /// @param recipient New fee recipient
    function proposeVaultFeeConfigUpdate(
        uint256 performanceFeeBps,
        uint256 managementFeeBps,
        address recipient
    )
        external;

    /// @notice Execute the proposed vault fee configuration update after timelock
    function executeVaultFeeConfigUpdate() external;

    /// @notice Update the maximum allowed PPS slippage for redemptions
    /// @param maxSlippageBps Maximum slippage in basis points (e.g., 100 = 1%)
    function updateMaxPPSSlippage(uint256 maxSlippageBps) external;

    /// @notice Manage emergency withdrawals
    /// @param action Type of action: 1=Propose, 2=ExecuteActivation, 3=Withdraw, 4=CancelProposal
    /// @param recipient The recipient of the withdrawn assets (for action 3)
    /// @param amount The amount of assets to withdraw (for action 3)
    function manageEmergencyWithdraw(uint8 action, address recipient, uint256 amount) external;

    /*//////////////////////////////////////////////////////////////
                        ACCOUNTING MANAGEMENT
    //////////////////////////////////////////////////////////////*/
    /// @notice Move accumulator shares and cost basis pro-rata during share transfers
    /// @param from The address transferring shares
    /// @param to The address receiving shares
    /// @param shares The amount of shares being transferred
    function moveAccumulatorOnTransfer(address from, address to, uint256 shares) external;

    /*//////////////////////////////////////////////////////////////
                            VIEW FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    /// @notice Get the vault info
    function getVaultInfo() external view returns (address vault, address asset, uint8 vaultDecimals);

    /// @notice Get the fee configurations
    function getConfigInfo() external view returns (FeeConfig memory feeConfig);

    /// @notice Returns the currently stored PPS value.
    function getStoredPPS() external view returns (uint256);

    /// @notice Get a yield source's configuration
    function getYieldSource(address source) external view returns (YieldSource memory);

    /// @notice Get all yield sources with their information
    /// @return Array of YieldSourceInfo structs
    function getYieldSourcesList() external view returns (YieldSourceInfo[] memory);

    /// @notice Get all yield source addresses
    /// @return Array of yield source addresses
    function getYieldSources() external view returns (address[] memory);

    /// @notice Get the count of yield sources
    /// @return Number of yield sources
    function getYieldSourcesCount() external view returns (uint256);

    /// @notice Check if a yield source exists
    /// @param source Address of the yield source
    /// @return True if the yield source exists
    function containsYieldSource(address source) external view returns (bool);

    /// @notice Get the average withdraw price for a controller
    /// @param controller The controller address
    /// @return averageWithdrawPrice The average withdraw price
    function getAverageWithdrawPrice(address controller) external view returns (uint256 averageWithdrawPrice);

    /// @notice Get the super vault state for a controller
    /// @param controller The controller address
    /// @return state The super vault state
    function getSuperVaultState(address controller) external view returns (SuperVaultState memory state);

    /// @notice Previews the fee that would be taken for redeeming a specific amount of shares
    /// @param controller The address of the controller requesting the redemption
    /// @param sharesToRedeem The number of shares to redeem
    /// @return totalFee The estimated fee that would be taken in asset terms
    /// @return superformFee The portion of the fee that would go to Superform treasury
    /// @return recipientFee The portion of the fee that would go to the fee recipient
    function previewPerformanceFee(
        address controller,
        uint256 sharesToRedeem
    )
        external
        view
        returns (uint256 totalFee, uint256 superformFee, uint256 recipientFee);

    /// @notice Get the pending redeem request amount (shares) for a controller
    /// @param controller The controller address
    /// @return pendingShares The amount of shares pending redemption
    function pendingRedeemRequest(address controller) external view returns (uint256 pendingShares);

    /// @notice Get the claimable withdraw amount (assets) for a controller
    /// @param controller The controller address
    /// @return claimableAssets The amount of assets claimable
    function claimableWithdraw(address controller) external view returns (uint256 claimableAssets);
}


0.0% src/interfaces/oracles/IECDSAPPSOracle.sol

Lines covered: 0 / 0 (0.0%)

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.30;

/// @title ECDSAPPSOracle
/// @author Superform Labs
/// @notice Interface for PPS oracles that provide price-per-share updates
/// @dev All PPS oracle implementations must conform to this interface
interface IECDSAPPSOracle {
    /*//////////////////////////////////////////////////////////////
                                 ERRORS
    //////////////////////////////////////////////////////////////*/
    /// @notice Thrown when the proof is invalid or cannot be verified
    error INVALID_PROOF();
    /// @notice Thrown when a validator is not registered or authorized
    error INVALID_VALIDATOR();
    /// @notice Thrown when the quorum of validators is not met
    error QUORUM_NOT_MET();
    /// @notice Thrown when the input arrays have different lengths
    error ARRAY_LENGTH_MISMATCH();
    /// @notice Thrown when the input array is empty
    error ZERO_LENGTH_ARRAY();
    /// @notice Thrown when the timestamp in the proof is invalid
    error INVALID_TIMESTAMP();
    /// @notice Thrown when the strategy address in the proof does not match
    error STRATEGY_MISMATCH();
    /// @notice Thrown when the pps value in the proof does not match
    error PPS_MISMATCH();
    /// @notice Thrown when the oracle is not set as the active PPS Oracle in SuperGovernor
    error NOT_ACTIVE_PPS_ORACLE();
    /// @notice Thrown when the dispersion (standard deviation / mean) is too high
    error HIGH_PPS_DISPERSION();
    /// @notice Thrown when the deviation from previous PPS is too high
    error HIGH_PPS_DEVIATION();
    /// @notice Thrown when too few validators participated in the round
    error INSUFFICIENT_VALIDATOR_PARTICIPATION();
    /// @notice Thrown when the reported validator count doesn't match the actual number of valid signatures
    error VALIDATOR_COUNT_MISMATCH();
    /// @notice Thrown when the validatorSet doesn't match the actual number of valid signatures  
    error INVALID_VALIDATOR_SET();
    /// @notice Thrown when the totalValidators doesn't match the actual total number of validators
    error INVALID_TOTAL_VALIDATORS();

    /*//////////////////////////////////////////////////////////////
                                 EVENTS
    //////////////////////////////////////////////////////////////*/
    /// @notice Emitted when a PPS update is validated and forwarded
    /// @param strategy Address of the strategy
    /// @param pps The validated price-per-share value
    /// @param ppsStdev The standard deviation of the price-per-share
    /// @param validatorSet Number of validators who calculated the PPS
    /// @param totalValidators Total number of validators in the network
    /// @param timestamp Timestamp when the value was generated
    /// @param sender Address that submitted the update
    event PPSValidated(
        address indexed strategy,
        uint256 pps,
        uint256 ppsStdev,
        uint256 validatorSet,
        uint256 totalValidators,
        uint256 timestamp,
        address indexed sender
    );

    /// @notice Emitted when proof validation failed
    /// @param strategy Address of the strategy
    /// @param reason Revert reason
    event ProofValidationFailed(address indexed strategy, string reason);

    /// @notice Emitted when proof validation failed
    /// @param strategy Address of the strategy
    /// @param data Revert encoded data
    event ProofValidationFailedLowLevel(address indexed strategy, bytes data);

    /// @notice Emitted when batch forward PPS failed
    /// @param reason Revert reason
    event BatchForwardPPSFailed(string reason);

    /// @notice Emitted when batch forward PPS failed
    /// @param lowLevelData Revert encoded data
    event BatchForwardPPSFailedLowLevel(bytes lowLevelData);

    /*//////////////////////////////////////////////////////////////
                            STRUCTS
    //////////////////////////////////////////////////////////////*/
    /// @notice Parameters for validating PPS proofs
    /// @param strategy Address of the strategy
    /// @param proofs Array of cryptographic proofs
    /// @param pps Price-per-share value (mean)
    /// @param ppsStdev Standard deviation of the price-per-share
    /// @param validatorSet Number of validators who calculated this PPS
    /// @param totalValidators Total number of validators in the network
    /// @param timestamp Timestamp when the value was generated
    struct ValidationParams {
        address strategy;
        bytes[] proofs;
        uint256 pps;
        uint256 ppsStdev;
        uint256 validatorSet;
        uint256 totalValidators;
        uint256 timestamp;
    }

    /// @notice Arguments for batch updating PPS for multiple strategies
    /// @param strategies Array of strategy addresses
    /// @param proofsArray Array of arrays of cryptographic proofs (one array of proofs per strategy)
    /// @param ppss Array of price-per-share values (means)
    /// @param ppsStdevs Array of standard deviations of price-per-share values
    /// @param validatorSets Array of numbers of validators who calculated each PPS
    /// @param totalValidators Array of total number of validators in the network for each update
    /// @param timestamps The time and therefore the blockchain(s) state(s) (plural important) this PPS refers to
    struct UpdatePPSArgs {
        address[] strategies;
        bytes[][] proofsArray;
        uint256[] ppss;
        uint256[] ppsStdevs;
        uint256[] validatorSets;
        uint256[] totalValidators;
        uint256[] timestamps;
    }

    /*//////////////////////////////////////////////////////////////
                              VIEW FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    /// @notice Returns the current nonce
    /// @param strategy_ Address of the strategy
    /// @return The current nonce
    function noncePerStrategy(address strategy_) external view returns (uint256);

    /// @notice Returns the domain separator for the contract
    /// @return The domain separator
    function domainSeparator() external view returns (bytes32);

    /// @notice Returns the signature typehash
    /// @return The typehash
    function UPDATE_PPS_TYPEHASH() external view returns (bytes32);

    /// @notice Validates an array of proofs for a strategy's PPS update
    /// @param params Validation parameters
    /// @dev Reverts immediately if duplicate signers are found or quorum is not met
    function validateProofs(IECDSAPPSOracle.ValidationParams memory params) external view;

    /*//////////////////////////////////////////////////////////////
                            EXTERNAL FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    /// @notice Updates the PPS for multiple strategies in a batch
    /// @param args Struct containing all parameters for batch PPS update
    function updatePPS(UpdatePPSArgs calldata args) external;
}


0.0% src/interfaces/oracles/ISuperOracle.sol

Lines covered: 0 / 0 (0.0%)

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.30;

/// @title ISuperOracle
/// @author Superform Labs
/// @notice Interface for SuperOracle
interface ISuperOracle {
    /*//////////////////////////////////////////////////////////////
                                ERRORS
    //////////////////////////////////////////////////////////////*/
    /// @notice Error when address is zero
    error ZERO_ADDRESS();

    /// @notice Error when array length is zero
    error ZERO_ARRAY_LENGTH();

    /// @notice Error when oracle provider index is invalid
    error INVALID_ORACLE_PROVIDER();

    /// @notice Error when no oracles are configured for base asset
    error NO_ORACLES_CONFIGURED();

    /// @notice Error when no valid reported prices are found
    error NO_VALID_REPORTED_PRICES();

    /// @notice Error when caller is not admin
    error NOT_ADMIN();

    /// @notice Error when arrays have mismatched lengths
    error ARRAY_LENGTH_MISMATCH();

    /// @notice Error when timelock period has not elapsed
    error TIMELOCK_NOT_ELAPSED();

    /// @notice Error when there is already a pending update
    error PENDING_UPDATE_EXISTS();

    /// @notice Error when oracle data is untrusted
    error ORACLE_UNTRUSTED_DATA();

    /// @notice Error when provider max staleness period is not set
    error NO_PENDING_UPDATE();

    /// @notice Error when quote is not supported (only USD is supported)
    error UNSUPPORTED_QUOTE();

    /// @notice Error when provider max staleness period is exceeded
    error MAX_STALENESS_EXCEEDED();

    /// @notice Error when no prices are reported
    error NO_PRICES();

    /// @notice Error when average provider is not allowed
    error AVERAGE_PROVIDER_NOT_ALLOWED();

    /// @notice Error when provider is zero
    error ZERO_PROVIDER();

    /// @notice Error when caller is not authorized to update
    error UNAUTHORIZED_UPDATE_AUTHORITY();

    /// @notice Error when oracle decimals call fails
    error ORACLE_DECIMALS_CALL_FAIL(address oracle);

    /// @notice Error when oracle round data call fails 
    error ORACLE_ROUND_DATA_CALL_FAIL(address oracle);

    /*//////////////////////////////////////////////////////////////
                                EVENTS
    //////////////////////////////////////////////////////////////*/
    /// @notice Emitted when oracles are configured
    /// @param bases Array of base assets
    /// @param providers Array of provider indexes
    /// @param feeds Array of oracle addresses
    event OraclesConfigured(address[] bases, address[] quotes, bytes32[] providers, address[] feeds);

    /// @notice Emitted when oracle update is queued
    /// @param bases Array of base assets
    /// @param providers Array of provider indexes
    /// @param feeds Array of oracle addresses
    /// @param timestamp Timestamp when update was queued
    event OracleUpdateQueued(
        address[] bases, address[] quotes, bytes32[] providers, address[] feeds, uint256 timestamp
    );

    /// @notice Emitted when oracle update is executed
    /// @param bases Array of base assets
    /// @param providers Array of provider indexes
    /// @param feeds Array of oracle addresses
    event OracleUpdateExecuted(address[] bases, address[] quotes, bytes32[] providers, address[] feeds);

    /// @notice Emitted when provider max staleness period is updated
    /// @param feed Feed address
    /// @param newMaxStaleness New maximum staleness period in seconds
    event FeedMaxStalenessUpdated(address feed, uint256 newMaxStaleness);

    /// @notice Emitted when max staleness period is updated
    /// @param newMaxStaleness New maximum staleness period in seconds
    event MaxStalenessUpdated(uint256 newMaxStaleness);

    /// @notice Emitted when provider removal is queued
    /// @param providers Array of provider ids to remove
    /// @param timestamp Timestamp when removal was queued
    event ProviderRemovalQueued(bytes32[] providers, uint256 timestamp);

    /// @notice Emitted when provider removal is executed
    /// @param providers Array of provider ids that were removed
    event ProviderRemovalExecuted(bytes32[] providers);

    /// @notice Emitted when emergency price is updated
    /// @param token Token address
    /// @param price Emergency price
    event EmergencyPriceUpdated(address token, uint256 price);

    /*//////////////////////////////////////////////////////////////
                                STRUCTS
    //////////////////////////////////////////////////////////////*/
    /// @notice Struct for pending oracle update
    struct PendingUpdate {
        address[] bases;
        address[] quotes;
        bytes32[] providers;
        address[] feeds;
        uint256 timestamp;
    }

    /// @notice Struct for pending provider removal
    struct PendingRemoval {
        bytes32[] providers;
        uint256 timestamp;
    }

    /*//////////////////////////////////////////////////////////////
                            EXTERNAL FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    /// @notice Get oracle address for a base asset and provider
    /// @param base Base asset address
    /// @param quote Quote asset address
    /// @param provider Provider id
    /// @return oracle Oracle address
    function getOracleAddress(address base, address quote, bytes32 provider) external view returns (address oracle);

    /// @notice Get quote from specified oracle provider
    /// @param baseAmount Amount of base asset
    /// @param base Base asset address
    /// @param quote Quote asset address
    /// @param oracleProvider Id of oracle provider to use
    /// @return quoteAmount The quote amount
    function getQuoteFromProvider(
        uint256 baseAmount,
        address base,
        address quote,
        bytes32 oracleProvider
    )
        external
        view
        returns (uint256 quoteAmount, uint256 deviation, uint256 totalProviders, uint256 availableProviders);

    /// @notice Queue oracle update for timelock
    /// @param bases Array of base assets
    /// @param providers Array of provider ids
    /// @param quotes Array of quote assets
    /// @param feeds Array of oracle addresses
    function queueOracleUpdate(
        address[] calldata bases,
        address[] calldata quotes,
        bytes32[] calldata providers,
        address[] calldata feeds
    )
        external;

    /// @notice Execute queued oracle update after timelock period
    function executeOracleUpdate() external;

    /// @notice Queue provider removal for timelock
    /// @param providers Array of provider ids to remove
    function queueProviderRemoval(bytes32[] calldata providers) external;

    /// @notice Execute queued provider removal after timelock period
    function executeProviderRemoval() external;

    /// @notice Set the maximum staleness period for a specific provider
    /// @param feed Feed address
    /// @param newMaxStaleness New maximum staleness period in seconds
    function setFeedMaxStaleness(address feed, uint256 newMaxStaleness) external;

    /// @notice Set the maximum staleness period for all providers
    /// @param newMaxStaleness New maximum staleness period in seconds
    function setMaxStaleness(uint256 newMaxStaleness) external;

    /// @notice Set the maximum staleness period for multiple providers
    /// @param feeds Array of feed addresses
    /// @param newMaxStalenessList Array of new maximum staleness periods in seconds
    function setFeedMaxStalenessBatch(address[] calldata feeds, uint256[] calldata newMaxStalenessList) external;

    /// @notice Get all active provider ids
    /// @return Array of active provider ids
    function getActiveProviders() external view returns (bytes32[] memory);

    /// @notice Get the emergency price for a token
    /// @param token Token address
    /// @return Emergency price
    function getEmergencyPrice(address token) external view returns (uint256);

    /// @notice Set the emergency price for a token
    /// @param token Token address
    /// @param price Emergency price
    function setEmergencyPrice(address token, uint256 price) external;

    /// @notice Set the emergency price for multiple tokens in a batch
    /// @param tokens Array of token addresses
    /// @param prices Array of emergency prices
    function batchSetEmergencyPrice(address[] calldata tokens, uint256[] calldata prices) external;
}


0.0% src/interfaces/oracles/ISuperOracleL2.sol

Lines covered: 0 / 0 (0.0%)

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.30;

/// @title ISuperOracleL2
/// @author Superform Labs
/// @notice Interface for Layer 2 Oracle for Superform
interface ISuperOracleL2 {
    /*//////////////////////////////////////////////////////////////
                            ERRORS
    //////////////////////////////////////////////////////////////*/
    /// @notice Error when no uptime feed is configured for the data oracle
    error NO_UPTIME_FEED();

    /// @notice Error when the L2 sequencer is down
    error SEQUENCER_DOWN();

    /// @notice Error when the grace period after sequencer restart is not over
    error GRACE_PERIOD_NOT_OVER();

    /*//////////////////////////////////////////////////////////////
                            EVENTS
    //////////////////////////////////////////////////////////////*/
    /// @notice Emitted when an uptime feed is set for a data oracle
    /// @param dataOracle The data oracle address
    /// @param uptimeOracle The uptime feed address
    event UptimeFeedSet(address dataOracle, address uptimeOracle);

    /// @notice Emitted when a grace period is set for an uptime oracle
    /// @param uptimeOracle The uptime oracle address
    /// @param gracePeriod The grace period in seconds
    event GracePeriodSet(address uptimeOracle, uint256 gracePeriod);

    /*//////////////////////////////////////////////////////////////
                            EXTERNAL FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    /// @notice Set uptime feeds for multiple data oracles in batch
    /// @param dataOracles Array of data oracle addresses to set uptime feeds for
    /// @param uptimeOracles Array of uptime feed addresses to set
    /// @param gracePeriods Array of grace periods in seconds after sequencer restart
    function batchSetUptimeFeed(
        address[] calldata dataOracles,
        address[] calldata uptimeOracles,
        uint256[] calldata gracePeriods
    ) external;
}


90.0% src/libraries/AssetMetadataLib.sol

Lines covered: 9 / 10 (90.0%)

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.30;

import { IERC20Metadata } from "@openzeppelin/contracts/interfaces/IERC20Metadata.sol";

/// @title AssetMetadataLib
/// @author Superform Labs
/// @notice Library for handling ERC20 metadata operations
library AssetMetadataLib {
    error INVALID_ASSET();

    /**
     * @notice Attempts to fetch an asset's decimals
     * @dev A return value of false indicates that the attempt failed in some way
     * @param asset_ The address of the token to query
     * @return ok Boolean indicating if the operation was successful
     * @return assetDecimals The token's decimals if successful, 0 otherwise
     */
    function tryGetAssetDecimals(address asset_) internal view returns (bool ok, uint8 assetDecimals) {
        if(asset_.code.length == 0) revert INVALID_ASSET();
        
        (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);
    }
}


0.0% src/vendor/standards/ERC7540/IERC7540Vault.sol

Lines covered: 0 / 0 (0.0%)

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

import { IERC7741 } from "../ERC7741/IERC7741.sol";

interface IERC7540Operator {
    /**
     * @dev The event emitted when an operator is set.
     *
     * @param controller The address of the controller.
     * @param operator The address of the operator.
     * @param approved The approval status.
     */
    event OperatorSet(address indexed controller, address indexed operator, bool approved);

    /**
     * @dev Sets or removes an operator for the caller.
     *
     * @param operator The address of the operator.
     * @param approved The approval status.
     * @return Whether the call was executed successfully or not
     */
    function setOperator(address operator, bool approved) external returns (bool);

    /**
     * @dev Returns `true` if the `operator` is approved as an operator for an `controller`.
     *
     * @param controller The address of the controller.
     * @param operator The address of the operator.
     * @return status The approval status
     */
    function isOperator(address controller, address operator) external view returns (bool status);
}

interface IERC7540Deposit is IERC7540Operator {
    event DepositRequest(
        address indexed controller, address indexed owner, uint256 indexed requestId, address sender, uint256 assets
    );
    /**
     * @dev Transfers assets from sender into the Vault and submits a Request for asynchronous deposit.
     *
     * - MUST support ERC-20 approve / transferFrom on asset as a deposit Request flow.
     * - MUST revert if all of assets cannot be requested for deposit.
     * - owner MUST be msg.sender unless some unspecified explicit approval is given by the caller,
     *    approval of ERC-20 tokens from owner to sender is NOT enough.
     *
     * @param assets the amount of deposit assets to transfer from owner
     * @param controller the controller of the request who will be able to operate the request
     * @param owner the source of the deposit assets
     *
     * NOTE: most implementations will require pre-approval of the Vault with the Vault's underlying asset token.
     */

    function requestDeposit(uint256 assets, address controller, address owner) external returns (uint256 requestId);

    /**
     * @dev Returns the amount of requested assets in Pending state.
     *
     * - MUST NOT include any assets in Claimable state for deposit or mint.
     * - MUST NOT show any variations depending on the caller.
     * - MUST NOT revert unless due to integer overflow caused by an unreasonably large input.
     */
    function pendingDepositRequest(
        uint256 requestId,
        address controller
    )
        external
        view
        returns (uint256 pendingAssets);

    /**
     * @dev Returns the amount of requested assets in Claimable state for the controller to deposit or mint.
     *
     * - MUST NOT include any assets in Pending state.
     * - MUST NOT show any variations depending on the caller.
     * - MUST NOT revert unless due to integer overflow caused by an unreasonably large input.
     */
    function claimableDepositRequest(
        uint256 requestId,
        address controller
    )
        external
        view
        returns (uint256 claimableAssets);

    /**
     * @dev Mints shares Vault shares to receiver by claiming the Request of the controller.
     *
     * - MUST emit the Deposit event.
     * - controller MUST equal msg.sender unless the controller has approved the msg.sender as an operator.
     */
    function deposit(uint256 assets, address receiver, address controller) external returns (uint256 shares);

    /**
     * @dev Mints exactly shares Vault shares to receiver by claiming the Request of the controller.
     *
     * - MUST emit the Deposit event.
     * - controller MUST equal msg.sender unless the controller has approved the msg.sender as an operator.
     */
    function mint(uint256 shares, address receiver, address controller) external returns (uint256 assets);
}

interface IERC7540Redeem is IERC7540Operator {
    event RedeemRequest(
        address indexed controller, address indexed owner, uint256 indexed requestId, address sender, uint256 assets
    );

    /**
     * @dev Assumes control of shares from sender into the Vault and submits a Request for asynchronous redeem.
     *
     * - MUST support a redeem Request flow where the control of shares is taken from sender directly
     *   where msg.sender has ERC-20 approval over the shares of owner.
     * - MUST revert if all of shares cannot be requested for redeem.
     *
     * @param shares the amount of shares to be redeemed to transfer from owner
     * @param controller the controller of the request who will be able to operate the request
     * @param owner the source of the shares to be redeemed
     *
     * NOTE: most implementations will require pre-approval of the Vault with the Vault's share token.
     */
    function requestRedeem(uint256 shares, address controller, address owner) external returns (uint256 requestId);

    /**
     * @dev Returns the amount of requested shares in Pending state.
     *
     * - MUST NOT include any shares in Claimable state for redeem or withdraw.
     * - MUST NOT show any variations depending on the caller.
     * - MUST NOT revert unless due to integer overflow caused by an unreasonably large input.
     */
    function pendingRedeemRequest(
        uint256 requestId,
        address controller
    )
        external
        view
        returns (uint256 pendingShares);

    /**
     * @dev Returns the amount of requested shares in Claimable state for the controller to redeem or withdraw.
     *
     * - MUST NOT include any shares in Pending state for redeem or withdraw.
     * - MUST NOT show any variations depending on the caller.
     * - MUST NOT revert unless due to integer overflow caused by an unreasonably large input.
     */
    function claimableRedeemRequest(
        uint256 requestId,
        address controller
    )
        external
        view
        returns (uint256 claimableShares);
}

interface IERC7540CancelDeposit {
    event CancelDepositRequest(address indexed controller, uint256 indexed requestId, address sender);
    event CancelDepositClaim(
        address indexed receiver, address indexed controller, uint256 indexed requestId, address sender, uint256 assets
    );

    /**
     * @dev Submits a Request for cancelling the pending deposit Request
     *
     * - controller MUST be msg.sender unless some unspecified explicit approval is given by the caller,
     *    approval of ERC-20 tokens from controller to sender is NOT enough.
     * - MUST set pendingCancelDepositRequest to `true` for the returned requestId after request
     * - MUST increase claimableCancelDepositRequest for the returned requestId after fulfillment
     * - SHOULD be claimable using `claimCancelDepositRequest`
     * Note: while `pendingCancelDepositRequest` is `true`, `requestDeposit` cannot be called
     */
    function cancelDepositRequest(uint256 requestId, address controller) external;

    /**
     * @dev Returns whether the deposit Request is pending cancelation
     *
     * - MUST NOT show any variations depending on the caller.
     */
    function pendingCancelDepositRequest(
        uint256 requestId,
        address controller
    )
        external
        view
        returns (bool isPending);

    /**
     * @dev Returns the amount of assets that were canceled from a deposit Request, and can now be claimed.
     *
     * - MUST NOT show any variations depending on the caller.
     */
    function claimableCancelDepositRequest(
        uint256 requestId,
        address controller
    )
        external
        view
        returns (uint256 claimableAssets);

    /**
     * @dev Claims the canceled deposit assets, and removes the pending cancelation Request
     *
     * - controller MUST be msg.sender unless some unspecified explicit approval is given by the caller,
     *    approval of ERC-20 tokens from controller to sender is NOT enough.
     * - MUST set pendingCancelDepositRequest to `false` for the returned requestId after request
     * - MUST set claimableCancelDepositRequest to 0 for the returned requestId after fulfillment
     */
    function claimCancelDepositRequest(
        uint256 requestId,
        address receiver,
        address controller
    )
        external
        returns (uint256 assets);
}

interface IERC7540CancelRedeem {
    event CancelRedeemRequest(address indexed controller, uint256 indexed requestId, address sender);
    event CancelRedeemClaim(
        address indexed receiver, address indexed controller, uint256 indexed requestId, address sender, uint256 shares
    );

    /**
     * @dev Submits a Request for cancelling the pending redeem Request
     *
     * - controller MUST be msg.sender unless some unspecified explicit approval is given by the caller,
     *    approval of ERC-20 tokens from controller to sender is NOT enough.
     * - MUST set pendingCancelRedeemRequest to `true` for the returned requestId after request
     * - MUST increase claimableCancelRedeemRequest for the returned requestId after fulfillment
     * - SHOULD be claimable using `claimCancelRedeemRequest`
     * Note: while `pendingCancelRedeemRequest` is `true`, `requestRedeem` cannot be called
     */
    function cancelRedeemRequest(uint256 requestId, address controller) external;

    /**
     * @dev Returns whether the redeem Request is pending cancelation
     *
     * - MUST NOT show any variations depending on the caller.
     */
    function pendingCancelRedeemRequest(uint256 requestId, address controller) external view returns (bool isPending);

    /**
     * @dev Returns the amount of shares that were canceled from a redeem Request, and can now be claimed.
     *
     * - MUST NOT show any variations depending on the caller.
     */
    function claimableCancelRedeemRequest(
        uint256 requestId,
        address controller
    )
        external
        view
        returns (uint256 claimableShares);

    /**
     * @dev Claims the canceled redeem shares, and removes the pending cancelation Request
     *
     * - controller MUST be msg.sender unless some unspecified explicit approval is given by the caller,
     *    approval of ERC-20 tokens from controller to sender is NOT enough.
     * - MUST set pendingCancelRedeemRequest to `false` for the returned requestId after request
     * - MUST set claimableCancelRedeemRequest to 0 for the returned requestId after fulfillment
     */
    function claimCancelRedeemRequest(
        uint256 requestId,
        address receiver,
        address controller
    )
        external
        returns (uint256 shares);
}

/**
 * @title  IERC7540
 * @dev    Fully async ERC7540 implementation according to the standard
 * @dev    Adapted from Centrifuge's IERC7540 implementation
 */
interface IERC7540 is IERC7540Deposit, IERC7540Redeem { }

/**
 * @title  IERC7540Vault
 * @dev    This is the specific set of interfaces used by the SuperVaults
 */
interface IERC7540Vault is IERC7540, IERC7741 {
    event DepositClaimable(address indexed controller, uint256 indexed requestId, uint256 assets, uint256 shares);
    event RedeemClaimable(address indexed controller, uint256 indexed requestId, uint256 assets, uint256 shares);
}


0.0% src/vendor/standards/ERC7575/IERC7575.sol

Lines covered: 0 / 0 (0.0%)

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

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

interface IERC7575 is IERC165 {
    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 address of the share token
     *
     * - MUST be an ERC-20 token contract.
     * - MUST NOT revert.
     */
    function share() external view returns (address shareTokenAddress);

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


0.0% src/vendor/standards/ERC7741/IERC7741.sol

Lines covered: 0 / 0 (0.0%)

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

interface IERC7741 {
    /**
     * @dev Grants or revokes permissions for `operator` to manage Requests on behalf of the
     *      `msg.sender`, using an [EIP-712](./eip-712.md) signature.
     */
    function authorizeOperator(
        address controller,
        address operator,
        bool approved,
        bytes32 nonce,
        uint256 deadline,
        bytes memory signature
    )
        external
        returns (bool);

    /**
     * @dev Revokes the given `nonce` for `msg.sender` as the `owner`.
     */
    function invalidateNonce(bytes32 nonce) external;

    /**
     * @dev Returns whether the given `nonce` has been used for the `controller`.
     */
    function authorizations(address controller, bytes32 nonce) external view returns (bool used);

    /**
     * @dev Returns the `DOMAIN_SEPARATOR` as defined according to EIP-712. The `DOMAIN_SEPARATOR
     *      should be unique to the contract and chain to prevent replay attacks from other domains,
     *      and satisfy the requirements of EIP-712, but is otherwise unconstrained.
     */
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}


0.0% test/mocks/MockYieldSourceOracle.sol

Lines covered: 0 / 53 (0.0%)

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

import { IYieldSourceOracle } from "@superform-v2-core/src/interfaces/accounting/IYieldSourceOracle.sol";

// Mock YieldSourceOracle implementation for testing
contract MockYieldSourceOracle is IYieldSourceOracle {
    uint256 public pricePerShare;
    uint256 public tvl;
    uint256 public tvlByOwner;
    bool public validity;
    mapping(address => bool) public validAssetMap;

    constructor(uint256 _pricePerShare, uint256 _tvl, uint256 _tvlByOwner, bool _validity) {
        pricePerShare = _pricePerShare;
        tvl = _tvl;
        tvlByOwner = _tvlByOwner;
        validity = _validity;
    }

    function setPricePerShare(uint256 _pricePerShare) external {
        pricePerShare = _pricePerShare;
    }

    function setTVL(uint256 _tvl) external {
        tvl = _tvl;
    }

    function setTVLByOwner(uint256 _tvlByOwner) external {
        tvlByOwner = _tvlByOwner;
    }

    function setValidity(bool _validity) external {
        validity = _validity;
    }

    function setValidAsset(address asset, bool isValid) external {
        validAssetMap[asset] = isValid;
    }

    function decimals(address) external pure returns (uint8) {
        return 18;
    }

    function getShareOutput(address, address, uint256 assetsIn) external pure returns (uint256) {
        return assetsIn;
    }

    function getAssetOutput(address, address, uint256 sharesIn) public pure returns (uint256) {
        return sharesIn;
    }

    function getAssetOutputWithFees(
        bytes32,
        address,
        address,
        address,
        uint256 sharesIn
    )
        public
        pure
        returns (uint256)
    {
        return sharesIn;
    }

    function getBalanceOfOwner(address, address) external view returns (uint256) {
        return tvlByOwner;
    }

    function getPricePerShare(address) external view returns (uint256) {
        return pricePerShare;
    }

    function getTVLByOwnerOfShares(address, address) external view returns (uint256) {
        return tvlByOwner;
    }

    function getTVL(address) external view returns (uint256) {
        return tvl;
    }

    function getPricePerShareMultiple(address[] memory) external view returns (uint256[] memory) {
        uint256[] memory prices = new uint256[](1);
        prices[0] = pricePerShare;
        return prices;
    }

    function getTVLByOwnerOfSharesMultiple(
        address[] memory yieldSources,
        address[][] memory
    )
        external
        view
        returns (uint256[][] memory)
    {
        uint256[][] memory result = new uint256[][](yieldSources.length);
        for (uint256 i = 0; i < yieldSources.length; i++) {
            result[i] = new uint256[](1);
            result[i][0] = tvlByOwner;
        }
        return result;
    }

    function getTVLMultiple(address[] memory) external view returns (uint256[] memory) {
        uint256[] memory tvls = new uint256[](1);
        tvls[0] = tvl;
        return tvls;
    }

    function isValidUnderlyingAsset(address, address asset) external view returns (bool) {
        return validAssetMap[asset];
    }

    function isValidUnderlyingAssets(address[] memory, address[] memory) external view returns (bool[] memory) {
        bool[] memory validities = new bool[](1);
        validities[0] = validity;
        return validities;
    }
}


100.0% test/recon/BeforeAfter.sol

Lines covered: 86 / 86 (100.0%)

// SPDX-License-Identifier: GPL-2.0
pragma solidity ^0.8.0;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IERC4626} from "@openzeppelin/contracts/interfaces/IERC4626.sol";
import {MockERC20} from "@recon/MockERC20.sol";

import {ISuperVaultStrategy} from "src/interfaces/SuperVault/ISuperVaultStrategy.sol";

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

enum OpType {
    DEFAULT,
    ADD,
    REMOVE,
    FULFILL,
    REQUEST,
    TRANSFER,
    CANCEL
}

// ghost variables for tracking state variable values before and after function calls
abstract contract BeforeAfter is Setup {
    struct Vars {
        mapping(address user => uint256 pendingAsAssets) pendingUserAssets;
        mapping(address user => uint256 claimableAsAssets) claimableUserAssets;
        mapping(address user => ISuperVaultStrategy.SuperVaultState) state;
        mapping(address user => uint256 shares) superVaultShares;
        uint256 oraclePPS;
        uint256 naivePPS;
        uint256 summedTotalShares;
        uint256 summedAccumulatorShares;
        uint256 summedAccumulatorCostBasis;
        uint256 summedTotalAssets;
        uint256 strategyAssetBalance;
        uint256 summedPendingRedeem;
    }

    Vars internal _before;
    Vars internal _after;
    OpType internal _currentOp;

    modifier updateGhosts() {
        _currentOp = OpType.DEFAULT;
        __before();
        _;
        __after();
    }

    modifier updateGhostsWithOpType(OpType op) {
        _currentOp = op;
        __before();
        _;
        __after();
    }

    function __before() internal {
        (
            _before.summedAccumulatorShares,
            _before.summedAccumulatorCostBasis
        ) = _sumSuperVaultValues();
        _before.naivePPS = _calculateNaivePPS();
        _before.summedTotalShares = _sumTotalShares();
        _before.summedTotalAssets = _sumStrategyAssets();
        _before.summedPendingRedeem = _sumRequestedRedemptions();

        _before.pendingUserAssets[_getActor()] = _getPendingAsAssets();
        _before.claimableUserAssets[_getActor()] = _getClaimableAsAssets();
        _before.state[_getActor()] = superVaultStrategy.getSuperVaultState(
            _getActor()
        );
        _before.superVaultShares[_getActor()] = superVault.balanceOf(
            _getActor()
        );

        _before.strategyAssetBalance = MockERC20(superVault.asset()).balanceOf(
            address(superVaultStrategy)
        );
        _before.oraclePPS = superVaultAggregator.getPPS(
            address(superVaultStrategy)
        );
    }

    function __after() internal {
        (
            _after.summedAccumulatorShares,
            _after.summedAccumulatorCostBasis
        ) = _sumSuperVaultValues();
        _after.naivePPS = _calculateNaivePPS();
        _after.summedTotalShares = _sumTotalShares();
        _after.summedTotalAssets = _sumStrategyAssets();
        _after.summedPendingRedeem = _sumRequestedRedemptions();

        _after.pendingUserAssets[_getActor()] = _getPendingAsAssets();
        _after.claimableUserAssets[_getActor()] = _getClaimableAsAssets();
        _after.state[_getActor()] = superVaultStrategy.getSuperVaultState(
            _getActor()
        );
        _after.superVaultShares[_getActor()] = superVault.balanceOf(
            _getActor()
        );

        _after.strategyAssetBalance = MockERC20(superVault.asset()).balanceOf(
            address(superVaultStrategy)
        );
        _after.oraclePPS = superVaultAggregator.getPPS(
            address(superVaultStrategy)
        );
    }

    // Helpers

    /// @dev total shares in the system is the sum of shares in the escrow and held by all users
    function _sumTotalShares() internal returns (uint256) {
        address[] memory actors = _getActors();
        uint256 totalShares;

        totalShares += superVault.balanceOf(address(superVaultEscrow));
        for (uint256 i; i < actors.length; i++) {
            totalShares += superVault.balanceOf(actors[i]);
        }

        return totalShares;
    }

    /// @notice Calculates the naive price per share by summing all assets across strategy and yield sources
    /// @dev inspired by the share price calculation from BaseSuperVaultTest::_updateSuperVaultPPS
    /// @return naivePPS The calculated price per share (scaled by 1e18)
    function _calculateNaivePPS() internal returns (uint256 naivePPS) {
        // Get total supply of SuperVault shares
        uint256 totalSupply = superVault.totalSupply();

        // If no shares exist, PPS is 0
        if (totalSupply == 0) {
            return 0;
        }

        // Calculate total assets across all locations
        uint256 totalAssets = _sumStrategyAssets();

        // Calculate naive PPS: (totalAssets * PRECISION) / totalSupply
        // Using 1e18 as precision to match the system's PPS_DECIMALS
        naivePPS = (totalAssets * superVault.PRECISION()) / totalSupply;

        return naivePPS;
    }

    function _sumStrategyAssets() public view returns (uint256) {
        // Get the underlying asset
        address asset = superVault.asset();

        uint256 totalAssets;
        // 1. Assets held directly in SuperVaultStrategy
        totalAssets += IERC20(asset).balanceOf(address(superVaultStrategy));

        // 2. Loop through all yield sources and sum underlying asset balances
        address[] memory yieldSources = _getYieldSources();
        for (uint256 i = 0; i < yieldSources.length; i++) {
            if (yieldSources[i] != address(0)) {
                // Get the underlying asset balance held in each yield source
                totalAssets += IERC20(asset).balanceOf(yieldSources[i]);
            }
        }

        return totalAssets;
    }

    function _sumSuperVaultValues()
        internal
        view
        returns (uint256 sumAccumulatorShares, uint256 sumAccumulatorCostBasis)
    {
        address[] memory actors = _getActors();

        for (uint256 i; i < actors.length; i++) {
            sumAccumulatorShares += superVaultStrategy
                .getSuperVaultState(actors[i])
                .accumulatorShares;
            sumAccumulatorCostBasis += superVaultStrategy
                .getSuperVaultState(actors[i])
                .accumulatorCostBasis;
        }
    }

    function _sumRequestedRedemptions() internal returns (uint256) {
        address[] memory actors = _getActors();
        uint256 totalRequested;
        for (uint256 i; i < actors.length; i++) {
            totalRequested += superVault.pendingRedeemRequest(0, actors[i]);
        }

        return totalRequested;
    }

    function _getPendingAsAssets() internal returns (uint256) {
        uint256 pendingRedemptions = superVault.pendingRedeemRequest(
            0,
            _getActor()
        );
        uint256 pendingRedemptionsAsAssets = superVault.convertToAssets(
            pendingRedemptions
        );

        return pendingRedemptionsAsAssets;
    }

    function _getClaimableAsAssets() internal returns (uint256) {
        uint256 claimableRedemptions = superVault.claimableRedeemRequest(
            0,
            _getActor()
        );
        uint256 claimableRedemptionsAsAssets = superVault.convertToAssets(
            claimableRedemptions
        );

        return claimableRedemptionsAsAssets;
    }
}


100.0% test/recon/CryticTester.sol

Lines covered: 2 / 2 (100.0%)

// SPDX-License-Identifier: GPL-2.0
pragma solidity ^0.8.0;

import {CryticAsserts} from "@chimera/CryticAsserts.sol";

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

// echidna test/recon/CryticTester.sol --contract CryticTester --config echidna.yaml --format text --test-limit 1000000 --disable-slither
// medusa fuzz
contract CryticTester is TargetFunctions, CryticAsserts {
    constructor() payable {
        setup();
    }
}


95.0% test/recon/Properties.sol

Lines covered: 330 / 346 (95.0%)

// SPDX-License-Identifier: GPL-2.0
pragma solidity ^0.8.0;

import {Asserts} from "@chimera/Asserts.sol";
import {MockERC20} from "@recon/MockERC20.sol";
import {vm} from "@chimera/Hevm.sol";
import {ERC7540Properties} from "@properties-7540/ERC7540Properties.sol";
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";

import {ISuperVaultStrategy} from "src/interfaces/SuperVault/ISuperVaultStrategy.sol";

import {OpType} from "test/recon/BeforeAfter.sol";
import {BeforeAfter} from "./BeforeAfter.sol";

abstract contract Properties is BeforeAfter, Asserts, ERC7540Properties {
    using Math for uint256;
    uint256 internal TOLERANCE = 10;

    // `!!!`-prefixed reasons are load-bearing for cross-fuzzer bug dedup in the analysis
    // pipeline. Handler assertion failures surface natively on every fuzzer: as Panic(0x01)
    // under echidna/medusa/recon and as recorded assertion failures under Foundry
    // (`assertions_revert = false`, upstream handler-bug reporting).
    string constant ASSERTION_REDEEM_MAX_REDEEM_SHOULD_NOT_REVERT =
        "!!! redeeming maxRedeem should not revert";
    string constant ASSERTION_WITHDRAW_MAX_WITHDRAW_SHOULD_NOT_REVERT =
        "!!! withdraw of maxWithdraw should not revert";
    string constant ASSERTION_PREVIEW_DEPOSIT_EQUIVALENCE =
        "!!! previewDeposit and deposit equivalence";
    string constant ASSERTION_PREVIEW_MINT_EQUIVALENCE =
        "!!! previewMint and mint equivalence";
    string constant ASSERTION_MINT_REDEEM_SYMMETRICAL =
        "!!! user loses assets in mint/redeem flow";
    string constant ASSERTION_DEPOSIT_WITHDRAW_SYMMETRICAL =
        "!!! user loses assets in deposit/withdraw flow";
    string constant ASSERTION_MAX_REDEEM_RESETS_AFTER_FULL_REDEMPTION =
        "!!! maxRedeem should be reset to 0 after full redemption";
    string constant ASSERTION_MAX_WITHDRAW_RESETS_AFTER_FULL_WITHDRAWAL =
        "!!! maxWithdraw should be reset to 0 after full withdrawal";
    string constant ASSERTION_FULFILL_DOESNT_OVER_REDEEM_MULTIPLE_ACTORS =
        "!!! total shares redeemed must not exceed sum of requested shares";
    string constant ASSERTION_PRIMARY_MANAGER_ALWAYS_CHANGEABLE =
        "!!! Primary manager should always be changeable if not paused";
    string constant ASSERTION_ALL_USERS_CAN_WITHDRAW_WHEN_UNPAUSED =
        "!!! users should always be able to withdraw unless the system is paused";
    string constant ASSERTION_CANCEL_REDEEM_PENDING_REQUEST_ZERO =
        "!!! pendingRedeemRequests should be 0 after cancelling a redemption";
    string constant ASSERTION_CANCEL_REDEEM_AVG_REQUEST_PPS_ZERO =
        "!!! averageRequestPPS should be 0 after cancelling a redemption";
    string constant ASSERTION_CANCEL_REDEEM_NO_OVERPAY =
        "!!! user should not receive more than convertToAssets(pendingRedeemRequest) after cancelRedeem";
    string constant ASSERTION_PREVIEW_DEPOSIT_MATCHES_EXECUTION =
        "!!! previewDeposit returns the correct amount compared to executing a deposit";
    string constant ASSERTION_PREVIEW_MINT_MATCHES_EXECUTION =
        "!!! previewMint returns the correct amount compared to executing a mint";
    string constant ASSERTION_TRANSFER_SHARES_CONSERVED =
        "!!! shares are lost on transfer";
    string constant ASSERTION_TRANSFER_COST_BASIS_CONSERVED =
        "!!! cost basis is lost on transfer";
    string constant ASSERTION_REDEEM_SHOULD_NOT_REVERT_INVALID_REDEEM_CLAIM =
        "!!! Claiming redemptions should never revert with INVALID_REDEEM_CLAIM";
    string constant ASSERTION_UPDATE_SHOULD_NOT_REVERT_TRANSFER =
        "!!! _update should never revert in transfer";
    string constant ASSERTION_UPDATE_SHOULD_NOT_REVERT_TRANSFER_FROM =
        "!!! _update should never revert in transferFrom";
    string constant ASSERTION_STRATEGY_NO_LOSS_ON_FULFILLMENT =
        "!!! strategy incurs loss on fulfillment";
    string constant ASSERTION_GLOBAL_PREVIEW_EQUIVALENCE_FROM_SHARES =
        "!!! previewMint and previewDeposit equivalence (from shares)";
    string constant ASSERTION_GLOBAL_PREVIEW_EQUIVALENCE_FROM_ASSETS =
        "!!! previewMint and previewDeposit equivalence (from assets)";
    string constant ASSERTION_GLOBAL_PREVIEW_MINT_GTE_CONVERT_TO_ASSETS =
        "!!! previewMint is >= convertToAssets";
    string constant ASSERTION_GLOBAL_CONVERT_TO_SHARES_GTE_PREVIEW_DEPOSIT =
        "!!! convertToShares is >= previewDepositShares (equivalent without fees)";
    string constant ASSERTION_ERC7540_4_DEPOSIT =
        "!!! ERC7540-4: deposit with more than max should revert";
    string constant ASSERTION_ERC7540_4_MINT =
        "!!! ERC7540-4: mint with more than max should revert";
    string constant ASSERTION_ERC7540_4_WITHDRAW =
        "!!! ERC7540-4: withdraw with more than max should revert";
    string constant ASSERTION_ERC7540_4_REDEEM =
        "!!! ERC7540-4: redeem with more than max should revert";
    string constant ASSERTION_ERC7540_5 =
        "!!! ERC7540-5: requestRedeem should revert if insufficient share balance";
    string constant ASSERTION_ERC7540_7_WITHDRAW =
        "!!! ERC7540-7: withdraw should not revert when amount <= max";
    string constant ASSERTION_ERC7540_7_REDEEM =
        "!!! ERC7540-7: redeem should not revert when amount <= max";
    string constant ASSERTION_CANARY =
        "!!! canary assertion";
    string constant INVARIANT_CANARY_GLOBAL_INVARIANT_FAILURE =
        "Canary invariant";

    /// @dev Property: oracle PPS doesn't change on deposit/mint/redeem/withdraw
    function invariant_oraclePPSDoesntChangeOnAddOrRemove() public returns (bool) {
        if (_currentOp == OpType.ADD || _currentOp == OpType.REMOVE) {
            eq(
                _before.oraclePPS,
                _after.oraclePPS,
                "deposit/withdrawal changes oracle PPS"
            );
        }
        return true;
    }

    /// @dev Property: naive PPS doesn't change on deposit/mint
    // NOTE: removed because it's expected behavior that fulfillment burns shares but doesn't transfer assets to users so would change the naively calculated price
    // function property_naivePPSDoesntChangeOnDepositOrMint() public {
    //     if (
    //         (_currentOp == OpType.ADD) && _before.naivePPS != 0 // price starts as zero when no shares minted
    //     ) {
    //         gte(
    //             _after.naivePPS,
    //             _before.naivePPS,
    //             "deposit/mint cannot decrease naive PPS"
    //         );
    //     }
    // }

    /// @dev Property: naive PPS doesn't change on redeem/withdraw
    // NOTE: removed because it's expected behavior that fulfillment burns shares but doesn't transfer assets to users so would change the naively calculated price
    // function property_naivePPSDoesntChangeOnRedeemOrWithdraw() public {
    //     if (
    //         (_currentOp == OpType.REMOVE) && _before.naivePPS != 0 // price starts as zero when no shares minted
    //     ) {
    //         gte(
    //             _after.naivePPS,
    //             _before.naivePPS,
    //             "redeem/withdraw cannot decrease naive PPS"
    //         );
    //     }
    // }

    /// @dev Property: fulfillRedeemRequest doesn't change naive PPS
    // NOTE: removed because it's expected behavior that fulfillment burns shares but doesn't transfer assets to users so would change the naively calculated price
    // function property_naivePPSDoesntChangeOnRedeem() public {
    //     if (_currentOp == OpType.FULFILL) {
    //         eq(
    //             _before.naivePPS,
    //             _after.naivePPS,
    //             "fulfilling redemption changes naive PPS"
    //         );
    //     }
    // }

    /// @dev Property: maxRedeem and maxWithdraw should always be equivalent
    function invariant_maxRedeemMaxWithdrawSymmetry() public returns (bool) {
        uint256 maxWithdraw = superVault.maxWithdraw(_getActor());
        // convertToShares uses current price instead of avg from fulfillment
        uint256 withdrawPrice = superVaultStrategy.getAverageWithdrawPrice(
            _getActor()
        );
        uint256 maxWithdrawAsShares = maxWithdraw.mulDiv(
            superVault.PRECISION(),
            withdrawPrice,
            Math.Rounding.Floor
        );

        uint256 maxRedeem = superVault.maxRedeem(_getActor());

        eq(maxWithdrawAsShares, maxRedeem, "maxWithdrawAsShares != maxRedeem");
        return true;
    }

    /// @dev Property: requestRedeem should never reduce SuperVault shares
    function invariant_totalSharesDontDecreaseOnRedemptionRequest() public returns (bool) {
        if (_currentOp == OpType.REQUEST) {
            eq(
                _before.summedTotalShares,
                _after.summedTotalShares,
                "requestRedeem should never reduce SuperVault shares"
            );
        }
        return true;
    }

    /// @dev Property: `SuperVault::totalSupply` == SUM(user balances) + balanceOf(escrow)
    function invariant_shareSolvency() public returns (bool) {
        uint256 sumOfShares = _sumTotalShares();
        eq(superVault.totalSupply(), sumOfShares, "vault shares are insolvent");
        return true;
    }

    /// @dev Property: balanceOf(escrow) >= SUM(controllers.pendingRedeemRequest)
    function invariant_escrowBalance() public returns (bool) {
        address[] memory actors = _getActors();

        uint256 escrowBalance = superVault.balanceOf(address(superVaultEscrow));
        uint256 pendingActorShares;
        for (uint256 i; i < actors.length; i++) {
            pendingActorShares += superVault.pendingRedeemRequest(0, actors[i]);
        }

        gte(
            escrowBalance,
            pendingActorShares,
            "balanceOf(escrow) < SUM(controllers.pendingRedeemRequest)"
        );
        return true;
    }

    /// @dev Property: maxMint should be 0 when aggregator is paused
    function invariant_maxMintZeroWhenPaused() public returns (bool) {
        bool paused = superVaultAggregator.isStrategyPaused(
            address(superVaultStrategy)
        );
        uint256 maxMint = superVault.maxMint(_getActor());

        if (paused) {
            eq(maxMint, 0, "actor has nonzero maxMint when strategy is paused");
        }
        return true;
    }

    /// @dev Property: maxDeposit should be 0 when strategy is paused
    function invariant_maxDepositZeroWhenPaused() public returns (bool) {
        bool paused = superVaultAggregator.isStrategyPaused(
            address(superVaultStrategy)
        );
        uint256 maxDeposit = superVault.maxDeposit(_getActor());

        if (paused) {
            eq(
                maxDeposit,
                0,
                "actor has nonzero maxDeposit when strategy is paused"
            );
        }
        return true;
    }

    /// @dev Property: SUM(accumulatorShares) doesn't change on SuperVault share transfers
    function invariant_accumulatorSharesSolvency() public returns (bool) {
        if (_currentOp == OpType.TRANSFER) {
            eq(
                _before.summedAccumulatorShares,
                _after.summedAccumulatorShares, // TODO: think about way to handle transfer on recipient
                "SUM(accumulatorShares) changed on SuperVault share transfers"
            );
        }
        return true;
    }

    /// @dev Property: SUM(accumulatorCostBasis) doesn't change on SuperVault share transfers
    function invariant_accumulatorCostBasisSolvency() public returns (bool) {
        if (_currentOp == OpType.TRANSFER) {
            eq(
                _before.summedAccumulatorCostBasis,
                _after.summedAccumulatorCostBasis,
                "SUM(accumulatorCostBasis) changed on SuperVault share transfers"
            );
        }
        return true;
    }

    /// @dev Property: cancelRedeem should never alter the supply of SuperVault tokens
    function invariant_cancelDoesntChangeTotalSupply() public returns (bool) {
        if (_currentOp == OpType.CANCEL) {
            eq(
                _before.summedTotalShares,
                _after.summedTotalShares,
                "cancelRedeem should never alter the supply of SuperVault tokens"
            );
        }
        return true;
    }

    /// @dev Property: if totalSupply > 0, then totalAssets > 0
    function invariant_assetBacking() public returns (bool) {
        uint256 summedTotalAssets = _sumStrategyAssets();

        if (superVault.totalSupply() > 0) {
            gt(
                summedTotalAssets,
                0,
                "if totalSupply > 0, then totalAssets > 0"
            );
        }
        return true;
    }

    /// @dev Property: SUM(shares) * PPS == totalAssets
    function invariant_totalAssets() public returns (bool) {
        uint256 totalShares = _sumTotalShares();
        uint256 pps = superVaultAggregator.getPPS(address(superVaultStrategy));
        uint256 implicitTotalAssets = (totalShares * pps) /
            superVault.PRECISION();

        uint256 vaultTotalAssets = superVault.totalAssets();
        eq(
            implicitTotalAssets,
            vaultTotalAssets,
            "totalShares * pps != totalAssets"
        );
        return true;
    }

    /// @dev Property: When a user requests a redemption and the PPS is >= the user PPS, user averageRequestPPS must not decrease
    function invariant_avgPPSDoesntDecrease() public returns (bool) {
        uint256 currentPrice = _before.oraclePPS;
        uint256 beforeAvgPPS = _before.state[_getActor()].averageRequestPPS;
        uint256 afterAvgPPS = _after.state[_getActor()].averageRequestPPS;

        if (_currentOp == OpType.REQUEST && currentPrice >= beforeAvgPPS) {
            gte(
                afterAvgPPS,
                beforeAvgPPS,
                "when a user requests a redemption and the PPS is >= the user PPS, user averageRequestPPS must not decrease"
            );
        }
        return true;
    }

    /// @dev Property: previewMint and previewDeposit equivalence (from shares)
    function global_previewEquivalenceFromShares_ASSERTION_GLOBAL_PREVIEW_EQUIVALENCE_FROM_SHARES(uint256 shares) public {
        uint256 previewMintAssets = superVault.previewMint(shares);
        uint256 previewDepositShares = superVault.previewDeposit(
            previewMintAssets
        );
        uint256 price = superVaultStrategy.getStoredPPS();

        if (price > 0) {
            eq(
                shares,
                previewDepositShares,
                ASSERTION_GLOBAL_PREVIEW_EQUIVALENCE_FROM_SHARES
            );
        }
    }

    /// @dev Property: previewMint and previewDeposit equivalence (from assets)
    function global_previewEquivalenceFromAssets_ASSERTION_GLOBAL_PREVIEW_EQUIVALENCE_FROM_ASSETS(uint256 assets) public {
        uint256 previewDepositShares = superVault.previewDeposit(assets);
        uint256 previewMintAssets_under = superVault.previewMint(
            previewDepositShares
        );
        uint256 previewMintAssets_over = superVault.previewMint(
            previewDepositShares + 1
        );
        uint256 price = superVaultStrategy.getStoredPPS();

        if (price > 0) {
            gte(
                assets,
                previewMintAssets_under,
                ASSERTION_GLOBAL_PREVIEW_EQUIVALENCE_FROM_ASSETS
            );

            lte(
                assets,
                previewMintAssets_over,
                ASSERTION_GLOBAL_PREVIEW_EQUIVALENCE_FROM_ASSETS
            );
        }
    }

    /// @dev Property: previewMint is >= convertToAssets
    function global_comparePreviewMintAndConvertToAssets_ASSERTION_GLOBAL_PREVIEW_MINT_GTE_CONVERT_TO_ASSETS(
        uint256 shares
    ) public {
        uint256 previewMintAssets = superVault.previewMint(shares);
        uint256 convertToAssets = superVault.convertToAssets(shares);
        gte(
            previewMintAssets,
            convertToAssets,
            ASSERTION_GLOBAL_PREVIEW_MINT_GTE_CONVERT_TO_ASSETS
        );
    }

    /// @dev Property: convertToShares is >= previewDepositShares (equivalent without fees)
    function global_comparePreviewDepositAndConvertToShares_ASSERTION_GLOBAL_CONVERT_TO_SHARES_GTE_PREVIEW_DEPOSIT(
        uint256 assets
    ) public {
        uint256 previewDepositShares = superVault.previewDeposit(assets);
        uint256 convertToShares = superVault.convertToShares(assets);
        gte(
            convertToShares,
            previewDepositShares,
            ASSERTION_GLOBAL_CONVERT_TO_SHARES_GTE_PREVIEW_DEPOSIT
        );
    }

    // NOTE: Withdrawal properties are more nuanced, as we should ensure that no gain can be had and that losses are imputed to the controller receiving the assets

    /// @dev Property: After all redemptions are processed, the sum of all claimable is <= balance available
    function invariant_sumOfClaimable() public returns (bool) {
        address[] memory actors = _getActors();

        uint256 sumPending;
        uint256 sumClaimable;
        for (uint256 i; i < actors.length; i++) {
            sumPending += superVault.pendingRedeemRequest(0, actors[i]);
            sumClaimable += superVault.maxWithdraw(actors[i]);
        }

        uint256 strategyBalance = MockERC20(superVault.asset()).balanceOf(
            address(superVaultStrategy)
        );

        // precondition: all pending has been fulfilled
        if (sumPending == 0) {
            lte(
                sumClaimable,
                strategyBalance,
                "sum of all claimable is > balance available"
            );
        }
        return true;
    }

    /// @dev Property: If the sum of assets in SuperVaultStrategy and yield strategies is 0, maxWithdraw should be 0
    function invariant_sumOfAssetsMaxWithdrawable() public returns (bool) {
        uint256 summedTotalAssets = _sumStrategyAssets();

        if (summedTotalAssets == 0) {
            uint256 maxWithdraw = superVault.maxWithdraw(_getActor());
            eq(
                maxWithdraw,
                0,
                "if sum of assets in SuperVaultStrategy and yield strategies is 0, maxWithdraw should be 0"
            );
        }
        return true;
    }

    /// @dev Property: averageWithdrawPrice should never decrease when new redemptions are fulfilled at a higher PPS
    function invariant_avgPPSMonotonicity() public returns (bool) {
        if (
            _currentOp == OpType.FULFILL &&
            _before.oraclePPS > _before.state[_getActor()].averageRequestPPS && // fulfilled at a higher price
            _after.state[_getActor()].pendingRedeemRequest != 0 // redemptions have all been fulfilled/cancelled; avg gets reset to 0 in this case
        ) {
            gte(
                _after.state[_getActor()].averageRequestPPS,
                _before.state[_getActor()].averageRequestPPS,
                "averageWithdrawPrice should not decrease when fulfilled at a higher PPS"
            );
        }
        return true;
    }

    /// @dev Property: state.accumulatorShares >= superVaultState[controllers[i]].pendingRedeemRequest for each user
    function invariant_accumulatorSharesGtPendingRequests() public returns (bool) {
        address[] memory actors = _getActors();

        for (uint256 i; i < actors.length; i++) {
            ISuperVaultStrategy.SuperVaultState
                memory state = superVaultStrategy.getSuperVaultState(actors[i]);
            gte(
                state.accumulatorShares,
                state.pendingRedeemRequest,
                "state.accumulatorShares < state.pendingRedeemRequest"
            );
        }
        return true;
    }

    /// @dev Property: accumulatorShares is always accurately increased
    function invariant_accumulatorSharesIncrease() public returns (bool) {
        if (_currentOp == OpType.ADD) {
            uint256 accumulatorSharesBefore = _before
                .state[_getActor()]
                .accumulatorShares;
            uint256 accumulatorSharesAfter = _after
                .state[_getActor()]
                .accumulatorShares;
            uint256 actorSharesBefore = _before.superVaultShares[_getActor()];
            uint256 actorSharesAfter = _after.superVaultShares[_getActor()];
            eq(
                accumulatorSharesAfter - accumulatorSharesBefore,
                actorSharesAfter - actorSharesBefore,
                "accumulatorShares is always accurately updated"
            );
        }
        return true;
    }

    /// @dev Property: accumulatorCostBasis is always accurately increased
    function invariant_accumulatorCostBasisIncrease() public returns (bool) {
        if (_currentOp == OpType.ADD) {
            uint256 accumulatorCostBasisBefore = _before
                .state[_getActor()]
                .accumulatorCostBasis;
            uint256 accumulatorCostBasisAfter = _after
                .state[_getActor()]
                .accumulatorCostBasis;
            eq(
                accumulatorCostBasisAfter - accumulatorCostBasisBefore,
                _after.strategyAssetBalance - _before.strategyAssetBalance,
                "accumulatorShares is always accurately updated"
            );
        }
        return true;
    }

    /// @dev Property: redemptions only burn the requested amount of shares (within tolerance range)
    function invariant_fulfillOnlyBurnsRequestedAmount() public returns (bool) {
        uint256 TOLERANCE_CONSTANT = 10 wei; // taken from SuperVaultStrategy

        if (_currentOp == OpType.FULFILL) {
            uint256 pendingRedeemDelta = _before.summedPendingRedeem -
                _after.summedPendingRedeem;
            uint256 totalSupplyDelta = _before.summedTotalShares -
                _after.summedTotalShares;

            // Check that burned amount is within tolerance of requested amount
            if (totalSupplyDelta < pendingRedeemDelta) {
                // Burned less than requested - check within tolerance
                gte(
                    totalSupplyDelta,
                    pendingRedeemDelta - TOLERANCE_CONSTANT,
                    "burned less than requested beyond tolerance"
                );
            } else {
                // Burned more than requested - check within tolerance
                lte(
                    totalSupplyDelta,
                    pendingRedeemDelta + TOLERANCE_CONSTANT,
                    "burned more than requested beyond tolerance"
                );
            }
        }
        return true;
    }

    /// @dev Property: accumulatorShares decreases by the exact amounts requested when fulfilling redemptions
    function invariant_accumulatorSharesDecreaseOnFulfill_exact() public returns (bool) {
        if (_currentOp == OpType.FULFILL) {
            uint256 accumulatorSharesDelta = _before.summedAccumulatorShares -
                _after.summedAccumulatorShares;
            uint256 totalSharesDelta = _before.summedTotalShares -
                _after.summedTotalShares;
            eq(
                accumulatorSharesDelta,
                totalSharesDelta,
                "accumulatorShares decreases by the exact amounts requested when fulfilling redemptions"
            );
        }
        return true;
    }

    function invariant_accumulatorSharesDecreaseOnFulfill_with_tolerance()
        public returns (bool)
    {
        if (_currentOp == OpType.FULFILL) {
            uint256 accumulatorSharesDelta = _before.summedAccumulatorShares -
                _after.summedAccumulatorShares;
            uint256 totalSharesDelta = _before.summedTotalShares -
                _after.summedTotalShares;
            if (accumulatorSharesDelta >= totalSharesDelta) {
                lte(
                    accumulatorSharesDelta - totalSharesDelta,
                    TOLERANCE,
                    "accumulatorShares decreases by more than TOLERANCE when fulfilling redemptions"
                );
            } else {
                lte(
                    totalSharesDelta - accumulatorSharesDelta,
                    TOLERANCE,
                    "accumulatorShares decreases by less than TOLERANCE when fulfilling redemptions"
                );
            }
        }
        return true;
    }

    /// Optimization Setters

    function setpreviewAssetsGreater(uint256 shares) public {
        uint256 previewMintAssets = superVault.previewMint(shares);
        uint256 previewDepositAssets = superVault.previewDeposit(
            previewMintAssets
        );

        if (previewMintAssets > previewDepositAssets) {
            previewMintAssetsGreater = int256(previewMintAssets);
        } else {
            previewDepositAssetsGreater = int256(previewDepositAssets);
        }
    }

    function setPreviewSharesGreater(uint256 assets) public {
        uint256 previewDepositShares = superVault.previewDeposit(assets);
        uint256 previewMintShares = superVault.previewMint(
            previewDepositShares
        );

        if (previewDepositShares > previewMintShares) {
            previewDepositSharesGreater =
                int256(previewDepositShares) -
                int256(previewMintShares);
        } else {
            previewMintSharesGreater =
                int256(previewMintShares) -
                int256(previewDepositShares);
        }
    }

    function setFulfilledDifference() public {
        if (_currentOp == OpType.FULFILL) {
            uint256 pendingRedeemDelta = _before.summedPendingRedeem -
                _after.summedPendingRedeem;
            uint256 totalSupplyDelta = _before.summedTotalShares -
                _after.summedTotalShares;

            // Check that burned amount is within tolerance of requested amount
            if (totalSupplyDelta < pendingRedeemDelta) {
                // Burned less than requested
                int256 burnedLessThanRequested = int256(pendingRedeemDelta) -
                    int256(totalSupplyDelta);
            } else {
                // Burned more than requested
                int256 burnedMoreThanRequested = int256(totalSupplyDelta) -
                    int256(pendingRedeemDelta);
            }
        }
    }

    /// Optimization Tests

    /// @dev Optimize the difference between the amount of assets in the system and claimable assets
    function optimize_maxDustAccumulation() public view returns (int256) {
        address[] memory actors = _getActors();

        uint256 summedClaimableRedemptionsAsAssets;
        for (uint256 i; i < actors.length; i++) {
            uint256 claimableRedemptions = superVault.claimableRedeemRequest(
                0,
                actors[i]
            );
            summedClaimableRedemptionsAsAssets += superVault.convertToAssets(
                claimableRedemptions
            );
        }

        uint256 totalAssets = _sumStrategyAssets();

        return int256(totalAssets) - int256(summedClaimableRedemptionsAsAssets);
    }

    /// @dev Optimize the difference between the amount of claimable assets and assets in the system
    function optimize_moreClaimableThanHeldDifference()
        public
        view
        returns (int256)
    {
        address[] memory actors = _getActors();

        uint256 summedClaimableRedemptionsAsAssets;
        for (uint256 i; i < actors.length; i++) {
            summedClaimableRedemptionsAsAssets += superVault.maxWithdraw(
                actors[i]
            );
        }

        uint256 totalAssets = _sumStrategyAssets();

        if (summedClaimableRedemptionsAsAssets > totalAssets) {
            return
                int256(summedClaimableRedemptionsAsAssets) -
                int256(totalAssets);
        }
    }

    function optimize_burnMoreThanRequestedInRedemption()
        public
        view
        returns (int256)
    {
        return burnedMoreThanRequested;
    }

    function optimize_burnLessThanRequestedInRedemption()
        public
        view
        returns (int256)
    {
        return burnedLessThanRequested;
    }

    // function optimize_previewMintSharesGreater() public view returns (int256) {
    //     return previewMintSharesGreater;
    // }

    // function optimize_previewDepositSharesGreater()
    //     public
    //     view
    //     returns (int256)
    // {
    //     return previewDepositSharesGreater;
    // }

    // function optimize_previewMintAssetsGreater() public view returns (int256) {
    //     return previewMintAssetsGreater;
    // }

    // function optimize_previewDepositAssetsGreater()
    //     public
    //     view
    //     returns (int256)
    // {
    //     return previewDepositAssetsGreater;
    // }

    function optimize_assetBackingDifference() public view returns (int256) {
        uint256 summedTotalAssets = _sumStrategyAssets();
        uint256 totalSupply = superVault.totalSupply();

        if (summedTotalAssets == 0 && totalSupply > 0) {
            return int256(totalSupply);
        }
    }

    // Canaries

    /// @dev Canary assertion helper. A failing input is expected to be discovered during fuzzing.
    function assert_canary_ASSERTION_CANARY(uint256 entropy) public {
        t(entropy > 0, ASSERTION_CANARY);
    }

    /// @dev Canary global invariant expected to fail immediately.
    function invariant_canary() public returns (bool) {
        t(false, INVARIANT_CANARY_GLOBAL_INVARIANT_FAILURE);
        return true;
    }

    // ERC7540 Properties from erc7540-reusable-properties

    /// @dev Property 7540-1: convertToAssets(totalSupply) == totalAssets unless price is 0.0
    function invariant_erc7540_1() public returns (bool) {
        actor = _getActor();
        t(
            erc7540_1(address(superVault)),
            "ERC7540-1: convertToAssets(totalSupply) == totalAssets failed"
        );
        return true;
    }

    /// @dev Property 7540-2: convertToShares(totalAssets) == totalSupply unless price is 0.0
    function invariant_erc7540_2() public returns (bool) {
        actor = _getActor();
        t(
            erc7540_2(address(superVault)),
            "ERC7540-2: convertToShares(totalAssets) == totalSupply failed"
        );
        return true;
    }

    /// @dev Property 7540-3: max* never reverts
    function invariant_erc7540_3() public returns (bool) {
        actor = _getActor();
        t(
            erc7540_3(address(superVault)),
            "ERC7540-3: max* functions should never revert"
        );
        return true;
    }

    /// @dev Property 7540-4: claiming more than max always reverts
    function global_erc7540_4_deposit_ASSERTION_ERC7540_4_DEPOSIT(uint256 amt) public stateless {
        actor = _getActor();
        t(
            erc7540_4_deposit(address(superVault), amt),
            ASSERTION_ERC7540_4_DEPOSIT
        );
    }

    function global_erc7540_4_mint_ASSERTION_ERC7540_4_MINT(uint256 amt) public stateless {
        actor = _getActor();
        t(
            erc7540_4_mint(address(superVault), amt),
            ASSERTION_ERC7540_4_MINT
        );
    }

    function global_erc7540_4_withdraw_ASSERTION_ERC7540_4_WITHDRAW(uint256 amt) public stateless {
        actor = _getActor();
        t(
            erc7540_4_withdraw(address(superVault), amt),
            ASSERTION_ERC7540_4_WITHDRAW
        );
    }

    function global_erc7540_4_redeem_ASSERTION_ERC7540_4_REDEEM(uint256 amt) public stateless {
        actor = _getActor();
        t(
            erc7540_4_redeem(address(superVault), amt),
            ASSERTION_ERC7540_4_REDEEM
        );
    }

    /// @dev Property 7540-5: requestRedeem reverts if the share balance is less than amount
    function global_erc7540_5_ASSERTION_ERC7540_5(uint256 shares) public stateless {
        actor = _getActor();
        t(
            erc7540_5(address(superVault), address(superVault), shares),
            ASSERTION_ERC7540_5
        );
    }

    /// @dev Property 7540-6: preview* always reverts
    // NOTE: previewMint and previewDeposit don't revert because deposits are sync
    // function crytic_erc7540_6() public {
    //     actor = _getActor();
    //     t(
    //         erc7540_6(address(superVault)),
    //         "ERC7540-6: preview* functions should always revert"
    //     );
    // }

    /// @dev Property 7540-7: if max[method] > 0, then [method] (max) should not revert
    // NOTE: maxDeposit always returns type(uint256).max
    // function crytic_erc7540_7_deposit(uint256 amt) public {
    //     actor = _getActor();
    //     t(
    //         erc7540_7_deposit(address(superVault), amt),
    //         "ERC7540-7: deposit should not revert when amount <= max"
    //     );
    // }

    // NOTE: maxMint always returns type(uint256).max
    // function crytic_erc7540_7_mint(uint256 amt) public stateless {
    //     actor = _getActor();
    //     t(
    //         erc7540_7_mint(address(superVault), amt),
    //         "ERC7540-7: mint should not revert when amount <= max"
    //     );
    // }

    function global_erc7540_7_withdraw_ASSERTION_ERC7540_7_WITHDRAW(uint256 amt) public stateless {
        actor = _getActor();
        t(
            erc7540_7_withdraw(address(superVault), amt),
            ASSERTION_ERC7540_7_WITHDRAW
        );
    }

    // NOTE: this implements the check from ERC7540Properties directly because SuperVault logic implementation allows amt to be nonzero but round down to 0 when assets passed into redeem are calculated
    function global_erc7540_7_redeem_ASSERTION_ERC7540_7_REDEEM(uint256 amt) public stateless {
        actor = _getActor();

        uint256 maxRedeem = superVault.maxRedeem(actor);
        amt = between(amt, 0, maxRedeem);

        if (amt == 0) {
            return; // Skip
        }

        uint256 averageWithdrawPrice = superVaultStrategy
            .getAverageWithdrawPrice(actor);

        // calculates assets in the same way as redeem to confirm that a nonzero amount is being requested
        uint256 assets = amt.mulDiv(
            averageWithdrawPrice,
            superVault.PRECISION(),
            Math.Rounding.Floor
        );

        try superVault.redeem(amt, actor, actor) {} catch {
            if (amt > 0 && assets > 0) {
                t(
                    false,
                    ASSERTION_ERC7540_7_REDEEM
                );
            }
        }
    }
}


99.0% test/recon/Setup.sol

Lines covered: 158 / 159 (99.0%)

// SPDX-License-Identifier: GPL-2.0
pragma solidity ^0.8.0;

// External dependencies
import {BaseSetup} from "@chimera/BaseSetup.sol";
import {vm} from "@chimera/Hevm.sol";
import {ActorManager} from "@recon/ActorManager.sol";
import {AssetManager} from "@recon/AssetManager.sol";
import {Utils} from "@recon/Utils.sol";
// ERC4626 Hooks
import {Deposit4626VaultHook} from "lib/v2-core/src/hooks/vaults/4626/Deposit4626VaultHook.sol";
import {ApproveAndDeposit4626VaultHook} from "lib/v2-core/src/hooks/vaults/4626/ApproveAndDeposit4626VaultHook.sol";
import {Redeem4626VaultHook} from "lib/v2-core/src/hooks/vaults/4626/Redeem4626VaultHook.sol";

// ERC5115 Hooks
import {Deposit5115VaultHook} from "lib/v2-core/src/hooks/vaults/5115/Deposit5115VaultHook.sol";
import {ApproveAndDeposit5115VaultHook} from "lib/v2-core/src/hooks/vaults/5115/ApproveAndDeposit5115VaultHook.sol";
import {Redeem5115VaultHook} from "lib/v2-core/src/hooks/vaults/5115/Redeem5115VaultHook.sol";

// ERC7540 Hooks
import {Deposit7540VaultHook} from "lib/v2-core/src/hooks/vaults/7540/Deposit7540VaultHook.sol";
import {Redeem7540VaultHook} from "lib/v2-core/src/hooks/vaults/7540/Redeem7540VaultHook.sol";
import {RequestDeposit7540VaultHook} from "lib/v2-core/src/hooks/vaults/7540/RequestDeposit7540VaultHook.sol";
import {RequestRedeem7540VaultHook} from "lib/v2-core/src/hooks/vaults/7540/RequestRedeem7540VaultHook.sol";
import {ApproveAndRequestDeposit7540VaultHook} from "lib/v2-core/src/hooks/vaults/7540/ApproveAndRequestDeposit7540VaultHook.sol";
import {CancelDepositRequest7540Hook} from "lib/v2-core/src/hooks/vaults/7540/CancelDepositRequest7540Hook.sol";
import {CancelRedeemRequest7540Hook} from "lib/v2-core/src/hooks/vaults/7540/CancelRedeemRequest7540Hook.sol";
import {ClaimCancelDepositRequest7540Hook} from "lib/v2-core/src/hooks/vaults/7540/ClaimCancelDepositRequest7540Hook.sol";
import {ClaimCancelRedeemRequest7540Hook} from "lib/v2-core/src/hooks/vaults/7540/ClaimCancelRedeemRequest7540Hook.sol";
import {Withdraw7540VaultHook} from "lib/v2-core/src/hooks/vaults/7540/Withdraw7540VaultHook.sol";

// Super Vault Hooks
import {CancelRedeemHook} from "lib/v2-core/src/hooks/vaults/super-vault/CancelRedeemHook.sol";
import {Withdraw7540VaultHook as SuperVaultWithdraw7540VaultHook} from "lib/v2-core/src/hooks/vaults/super-vault/Withdraw7540VaultHook.sol";

// Source dependencies
import "src/SuperVault/SuperVault.sol";
import "src/SuperVault/SuperVaultAggregator.sol";
import "src/SuperVault/SuperVaultEscrow.sol";
import "src/SuperVault/SuperVaultStrategy.sol";
import "src/SuperGovernor.sol";
import {ISuperVaultAggregator} from "src/interfaces/SuperVault/ISuperVaultAggregator.sol";
import {ISuperVaultStrategy} from "src/interfaces/SuperVault/ISuperVaultStrategy.sol";
import {MockYieldSourceOracle} from "test/mocks/MockYieldSourceOracle.sol";

// Test suite dependencies
import {YieldManager, YieldSourceType} from "test/recon/managers/YieldManager.sol";
import {MerkleTestHelper} from "test/recon/helpers/MerkleTestHelper.sol";
import {UnsafeSuperVaultAggregator} from "test/recon/helpers/UnsafeSuperVaultAggregator.sol";
import {MockERC4626YieldSourceOracle} from "test/recon/mocks/MockERC4626YieldSourceOracle.sol";
import {MockERC5115YieldSourceOracle} from "test/recon/mocks/MockERC5115YieldSourceOracle.sol";
import {MockERC7540YieldSourceOracle} from "test/recon/mocks/MockERC7540YieldSourceOracle.sol";
import {MockECDSAPPSOracle} from "test/recon/mocks/MockECDSAPPSOracle.sol";

abstract contract Setup is
    BaseSetup,
    ActorManager,
    AssetManager,
    YieldManager,
    Utils
{
    // Configuration constants
    uint8 internal constant DECIMALS = 18;
    address asset;
    address feeRecipient = address(0xbeef);

    // Core contracts
    SuperGovernor superGovernor;
    SuperVault superVault;
    UnsafeSuperVaultAggregator superVaultAggregator;
    SuperVaultEscrow superVaultEscrow;
    SuperVaultStrategy superVaultStrategy;

    // Implementation contracts for aggregator
    SuperVault vaultImpl;
    SuperVaultStrategy strategyImpl;
    SuperVaultEscrow escrowImpl;

    // Helpers
    MerkleTestHelper merkleHelper;

    // ERC4626 Hooks
    ApproveAndDeposit4626VaultHook approveAndDeposit4626Hook;
    Deposit4626VaultHook deposit4626Hook;
    Redeem4626VaultHook redeem4626Hook;

    // ERC5115 Hooks
    ApproveAndDeposit5115VaultHook approveAndDeposit5115Hook;
    Deposit5115VaultHook deposit5115Hook;
    Redeem5115VaultHook redeem5115Hook;

    // ERC7540 Hooks
    Deposit7540VaultHook deposit7540Hook;
    Redeem7540VaultHook redeem7540Hook;
    RequestDeposit7540VaultHook requestDeposit7540Hook;
    RequestRedeem7540VaultHook requestRedeem7540Hook;
    ApproveAndRequestDeposit7540VaultHook approveAndRequestDeposit7540Hook;
    CancelDepositRequest7540Hook cancelDepositRequest7540Hook;
    CancelRedeemRequest7540Hook cancelRedeemRequest7540Hook;
    ClaimCancelDepositRequest7540Hook claimCancelDepositRequest7540Hook;
    ClaimCancelRedeemRequest7540Hook claimCancelRedeemRequest7540Hook;
    Withdraw7540VaultHook withdraw7540Hook;

    // Super Vault Hooks
    CancelRedeemHook cancelRedeemHook;
    SuperVaultWithdraw7540VaultHook superVaultWithdraw7540Hook;

    // Mocks
    MockERC4626YieldSourceOracle erc4626YieldSourceOracle;
    MockERC5115YieldSourceOracle erc5115YieldSourceOracle;
    MockERC7540YieldSourceOracle erc7540YieldSourceOracle;
    MockECDSAPPSOracle ECDSAPPSOracle;

    // Yield sources for different standards
    address erc4626YieldSource;
    address erc5115YieldSource;
    address erc7540YieldSource;

    // Ghosts
    bool hasUpdatedPPS;
    int256 burnedMoreThanRequested;
    int256 burnedLessThanRequested;
    int256 previewMintSharesGreater; // setPreviewSharesGreater
    int256 previewDepositSharesGreater; // setPreviewSharesGreater
    int256 previewMintAssetsGreater; // setpreviewAssetsGreater
    int256 previewDepositAssetsGreater; // setpreviewAssetsGreater

    // Canaries
    bool executeHooksClampedSuccess;
    bool executeHooksSuccess;
    bool fulfillRedeemRequestsSuccess;
    bool hasDeployedNewVault;

    /// === MODIFIERS === ///
    /// Prank admin and actor

    modifier asAdmin() {
        vm.prank(address(this));
        _;
    }

    modifier asActor() {
        vm.prank(address(_getActor()));
        _;
    }

    /// Makes a handler have no side effects
    /// The fuzzer will call this anyway, and because it reverts it will be removed from shrinking
    /// Replace the "withGhosts" with "stateless" to make the code clean
    ///
    /// Under Foundry with `assertions_revert = false` a failing t()/vm.assert* only records a
    /// journaled write to the global fail slot, which the trailing revert would erase — making
    /// every stateless assertion property invisible to the Foundry leg. Re-raise a failure
    /// recorded during this call as Panic(0x01), which Foundry classifies as an assertion
    /// failure; under echidna/medusa/recon a failing t() already reverted with Panic before
    /// reaching this point, so the extra check never fires there.
    modifier stateless() {
        bool preFailed = _foundryFailSlotSet();
        _;
        if (!preFailed && _foundryFailSlotSet()) assert(false);
        revert("stateless");
    }

    // bytes32("failed") — Foundry's GLOBAL_FAIL_SLOT on the cheatcode address, written
    // (journaled sstore of 1) by non-reverting vm.assert* failures.
    bytes32 internal constant _FOUNDRY_FAIL_SLOT =
        0x6661696c65640000000000000000000000000000000000000000000000000000;

    /// Probes the Foundry fail slot with a raw staticcall so fuzzers without the `load`
    /// cheatcode simply report "not set" instead of reverting.
    function _foundryFailSlotSet() internal view returns (bool) {
        (bool ok, bytes memory ret) = address(vm).staticcall(
            abi.encodeWithSignature("load(address,bytes32)", address(vm), _FOUNDRY_FAIL_SLOT)
        );
        return ok && ret.length >= 32 && abi.decode(ret, (bytes32)) != bytes32(0);
    }

    /// === Setup === ///
    /// This contains all calls to be performed in the tester constructor, both for Echidna and Foundry
    function setup() internal virtual override {
        // 1. Add additional actors
        _addActor(address(0x100)); // Actor 1
        _addActor(address(0x200)); // Actor 2

        // 2. Create assets using AssetManager
        _newAsset(DECIMALS); // Deploy token with 18 decimals
        _newAsset(DECIMALS); // UP token

        _switchAsset(0);

        // 3. Deploy all three types of yield sources using YieldManager
        // Deploy ERC4626 yield source (default)
        erc4626YieldSource = _newYieldSource(
            _getAsset(),
            YieldSourceType.ERC4626
        );

        // Deploy ERC5115 yield source
        erc5115YieldSource = _newYieldSource(
            _getAsset(),
            YieldSourceType.ERC5115
        );

        // Deploy ERC7540 yield source
        erc7540YieldSource = _newYieldSource(
            _getAsset(),
            YieldSourceType.ERC7540
        );

        // Set ERC4626 as the default active yield source
        _switchYieldSource(0); // Switch to first yield source in the array (ERC4626)

        // 4. Deploy SuperGovernor first (required by other contracts)
        superGovernor = new SuperGovernor(
            address(this), // superGovernor role
            address(this), // governor role
            address(this), // bankManager role
            address(this), // gasManager role
            feeRecipient, // treasury
            address(this) // prover
        );

        // 5. Deploy implementation contracts for the aggregator
        vaultImpl = new SuperVault(address(superGovernor));
        strategyImpl = new SuperVaultStrategy(address(superGovernor));
        escrowImpl = new SuperVaultEscrow();

        // 6. Deploy SuperVaultAggregator with implementation contracts
        superVaultAggregator = new UnsafeSuperVaultAggregator(
            address(superGovernor),
            address(vaultImpl),
            address(strategyImpl),
            address(escrowImpl)
        );

        // 7. Register the SuperVaultAggregator and UpToken address with SuperGovernor
        superGovernor.setAddress(
            superGovernor.SUPER_VAULT_AGGREGATOR(),
            address(superVaultAggregator)
        );

        address[] memory assets = _getAssets();
        superGovernor.setAddress(superGovernor.UP(), assets[1]); // the second deployed token in the AssetManager is the UPToken
        superGovernor.setAddress(superGovernor.SUPER_BANK(), address(this));

        // 8. Deploy Mocks and Oracles

        // Deploy specific oracles for each yield source type
        erc4626YieldSourceOracle = new MockERC4626YieldSourceOracle();
        erc5115YieldSourceOracle = new MockERC5115YieldSourceOracle();
        erc7540YieldSourceOracle = new MockERC7540YieldSourceOracle();
        ECDSAPPSOracle = new MockECDSAPPSOracle();

        // ECDSAPPSOracle setup
        superGovernor.setActivePPSOracle(address(ECDSAPPSOracle));
        ECDSAPPSOracle.setSUPER_GOVERNORReturn(address(superVaultAggregator));

        // Set valid assets for all oracles
        asset = _getAsset();
        erc4626YieldSourceOracle.setValidAsset(asset, true);
        erc5115YieldSourceOracle.setValidAsset(asset, true);
        erc7540YieldSourceOracle.setValidAsset(asset, true);

        // 9. Create a vault trio using the aggregator
        ISuperVaultAggregator.VaultCreationParams
            memory params = ISuperVaultAggregator.VaultCreationParams({
                asset: _getAsset(), // Use the token created by AssetManager
                name: "SuperVault",
                symbol: "SV",
                mainManager: address(this), // CONFIGURABLE: This parameter can be modified via target functions
                secondaryManagers: new address[](0), // CONFIGURABLE: This parameter can be modified via target functions
                minUpdateInterval: 5, // CONFIGURABLE: This parameter can be modified via target functions
                maxStaleness: 300, // CONFIGURABLE: This parameter can be modified via target functions
                feeConfig: ISuperVaultStrategy.FeeConfig({
                    performanceFeeBps: 1000, // 10% performance fee
                    managementFeeBps: 100, // 1% management fee
                    recipient: feeRecipient
                })
            });

        (
            address vaultAddr,
            address strategyAddr,
            address escrowAddr
        ) = superVaultAggregator.createVault(params);

        // 10. Store the deployed contracts
        superVault = SuperVault(vaultAddr);
        superVaultStrategy = SuperVaultStrategy(payable(strategyAddr));
        superVaultEscrow = SuperVaultEscrow(escrowAddr);

        /// 11. Deploy all hook contracts and helper
        merkleHelper = new MerkleTestHelper();

        // Deploy ERC4626 Hooks
        approveAndDeposit4626Hook = new ApproveAndDeposit4626VaultHook();
        deposit4626Hook = new Deposit4626VaultHook();
        redeem4626Hook = new Redeem4626VaultHook();

        // Deploy ERC5115 Hooks
        approveAndDeposit5115Hook = new ApproveAndDeposit5115VaultHook();
        deposit5115Hook = new Deposit5115VaultHook();
        redeem5115Hook = new Redeem5115VaultHook();

        // Deploy ERC7540 Hooks
        deposit7540Hook = new Deposit7540VaultHook();
        redeem7540Hook = new Redeem7540VaultHook();
        requestDeposit7540Hook = new RequestDeposit7540VaultHook();
        requestRedeem7540Hook = new RequestRedeem7540VaultHook();
        approveAndRequestDeposit7540Hook = new ApproveAndRequestDeposit7540VaultHook();
        cancelDepositRequest7540Hook = new CancelDepositRequest7540Hook();
        cancelRedeemRequest7540Hook = new CancelRedeemRequest7540Hook();
        claimCancelDepositRequest7540Hook = new ClaimCancelDepositRequest7540Hook();
        claimCancelRedeemRequest7540Hook = new ClaimCancelRedeemRequest7540Hook();
        withdraw7540Hook = new Withdraw7540VaultHook();

        // Deploy Super Vault Hooks
        cancelRedeemHook = new CancelRedeemHook();
        superVaultWithdraw7540Hook = new SuperVaultWithdraw7540VaultHook();

        // Register all hooks with SuperGovernor
        // ERC4626 Hooks (deposit hooks are regular hooks, redeem hooks are fulfill request hooks)
        superGovernor.registerHook(address(approveAndDeposit4626Hook), false);
        superGovernor.registerHook(address(deposit4626Hook), false);
        superGovernor.registerHook(address(redeem4626Hook), true); // fulfill request hook

        // ERC5115 Hooks
        superGovernor.registerHook(address(approveAndDeposit5115Hook), false);
        superGovernor.registerHook(address(deposit5115Hook), false);
        superGovernor.registerHook(address(redeem5115Hook), true); // fulfill request hook

        // ERC7540 Hooks (deposit/request hooks are regular hooks, redeem/withdraw hooks are fulfill request hooks)
        superGovernor.registerHook(address(deposit7540Hook), false);
        superGovernor.registerHook(address(redeem7540Hook), true); // fulfill request hook
        superGovernor.registerHook(address(requestDeposit7540Hook), false);
        superGovernor.registerHook(address(requestRedeem7540Hook), false);
        superGovernor.registerHook(
            address(approveAndRequestDeposit7540Hook),
            false
        );
        superGovernor.registerHook(
            address(cancelDepositRequest7540Hook),
            false
        );
        superGovernor.registerHook(address(cancelRedeemRequest7540Hook), false);
        superGovernor.registerHook(
            address(claimCancelDepositRequest7540Hook),
            false
        );
        superGovernor.registerHook(
            address(claimCancelRedeemRequest7540Hook),
            false
        );
        superGovernor.registerHook(address(withdraw7540Hook), true); // fulfill request hook

        // Super Vault Hooks
        superGovernor.registerHook(address(cancelRedeemHook), false);
        superGovernor.registerHook(address(superVaultWithdraw7540Hook), true); // fulfill request hook

        // 12. Set up approval array for contracts that need token access
        address[] memory approvalArray = new address[](6);
        approvalArray[0] = address(superVault);
        approvalArray[1] = address(superVaultStrategy);
        approvalArray[2] = address(superVaultAggregator);
        approvalArray[3] = erc4626YieldSource;
        approvalArray[4] = erc5115YieldSource;
        approvalArray[5] = erc7540YieldSource;

        // 13. Finalize asset deployment (mints to actors and sets approvals)
        _finalizeAssetDeployment(_getActors(), approvalArray, type(uint88).max);
    }

    /// Get hook addresses for different yield source types

    function _getApproveAndDepositHookForType(
        YieldSourceType sourceType
    ) internal view returns (address) {
        if (sourceType == YieldSourceType.ERC4626) {
            return address(approveAndDeposit4626Hook);
        } else if (sourceType == YieldSourceType.ERC5115) {
            return address(approveAndDeposit5115Hook);
        } else if (sourceType == YieldSourceType.ERC7540) {
            return address(approveAndRequestDeposit7540Hook);
        }
        return address(0);
    }

    function _getRedeemHookForType(
        YieldSourceType sourceType
    ) internal view returns (address) {
        if (sourceType == YieldSourceType.ERC4626) {
            return address(redeem4626Hook);
        } else if (sourceType == YieldSourceType.ERC5115) {
            return address(redeem5115Hook);
        } else if (sourceType == YieldSourceType.ERC7540) {
            return address(redeem7540Hook);
        }
        return address(0);
    }

    /// Get oracle addresses for different yield source types

    function _getYieldSourceOracleForType(
        YieldSourceType sourceType
    ) internal view returns (address) {
        if (sourceType == YieldSourceType.ERC4626) {
            return address(erc4626YieldSourceOracle);
        } else if (sourceType == YieldSourceType.ERC5115) {
            return address(erc5115YieldSourceOracle);
        } else if (sourceType == YieldSourceType.ERC7540) {
            return address(erc7540YieldSourceOracle);
        }
    }

    /// @dev Helper function to determine yield source type from address
    function _getYieldSourceTypeFromAddress(
        address yieldSource
    ) internal view returns (YieldSourceType) {
        // Get all available yield sources from YieldManager
        address[] memory yieldSources = _getYieldSources();

        // Check which index matches the current yield source
        for (uint256 i = 0; i < yieldSources.length; i++) {
            if (yieldSources[i] == yieldSource) {
                // Return the corresponding type based on creation order:
                // Index 0: ERC4626, Index 1: ERC5115, Index 2: ERC7540
                if (i == 0) return YieldSourceType.ERC4626;
                if (i == 1) return YieldSourceType.ERC5115;
                if (i == 2) return YieldSourceType.ERC7540;
            }
        }

        // Default to ERC4626 if not found
        return YieldSourceType.ERC4626;
    }

    function _getERC4626YieldSourceOracle() internal view returns (address) {
        return address(erc4626YieldSourceOracle);
    }

    function _getERC5115YieldSourceOracle() internal view returns (address) {
        return address(erc5115YieldSourceOracle);
    }

    function _getERC7540YieldSourceOracle() internal view returns (address) {
        return address(erc7540YieldSourceOracle);
    }

    // Helpers
    function _getRandomActor(uint256 entropy) public view returns (address) {
        address[] memory actors = _getActors();

        return actors[entropy % actors.length];
    }
}


0.0% test/recon/TargetFunctions.sol

Lines covered: 0 / 0 (0.0%)

// SPDX-License-Identifier: GPL-2.0
pragma solidity ^0.8.0;

// Chimera deps
import {vm} from "@chimera/Hevm.sol";

// Helpers
import {Panic} from "@recon/Panic.sol";

// Targets
// NOTE: Always import and apply them in alphabetical order, so much easier to debug!
import {AdminTargets} from "./targets/AdminTargets.sol";
import {DoomsdayTargets} from "./targets/DoomsdayTargets.sol";
import {ManagersTargets} from "./targets/ManagersTargets.sol";
import {OracleTargets} from "./targets/OracleTargets.sol";
import {SuperVaultTargets} from "./targets/SuperVaultTargets.sol";
import {SuperVaultAggregatorTargets} from "./targets/SuperVaultAggregatorTargets.sol";
import {SuperVaultEscrowTargets} from "./targets/SuperVaultEscrowTargets.sol";
import {SuperVaultStrategyTargets} from "./targets/SuperVaultStrategyTargets.sol";
import {SuperGovernorTargets} from "./targets/SuperGovernorTargets.sol";
import {YieldSourceTargets} from "./targets/YieldSourceTargets.sol";

abstract contract TargetFunctions is
    AdminTargets,
    DoomsdayTargets,
    ManagersTargets,
    OracleTargets,
    SuperVaultTargets,
    SuperVaultAggregatorTargets,
    SuperVaultEscrowTargets,
    SuperVaultStrategyTargets,
    SuperGovernorTargets,
    YieldSourceTargets
{
    /// CUSTOM TARGET FUNCTIONS - Add your own target functions here ///
    /// AUTO GENERATED TARGET FUNCTIONS - WARNING: DO NOT DELETE OR MODIFY THIS LINE ///
}


73.0% test/recon/helpers/MerkleTestHelper.sol

Lines covered: 25 / 34 (73.0%)

// SPDX-License-Identifier: GPL-2.0
pragma solidity ^0.8.0;

import {MerkleProof} from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";

/// @title MerkleTestHelper
/// @notice Helper contract for generating test Merkle roots and proofs for hook validation
contract MerkleTestHelper {
    /// @notice Generate a test Merkle root for ERC4626 deposit and redeem hooks
    /// @param depositHook Address of the Deposit4626VaultHook or ApproveAndDeposit4626VaultHook contract
    /// @param redeemHook Address of the Redeem4626VaultHook contract  
    /// @param mockVault Address of the mock ERC4626 vault
    /// @param mockToken Address of the mock token (unused but kept for compatibility)
    /// @return root The Merkle root for the tree
    /// @return proofs Array of proofs for each leaf [depositProof, redeemProof]
    function generateTestHooksRoot(
        address depositHook,
        address redeemHook,
        address mockVault,
        address mockToken
    ) public pure returns (bytes32 root, bytes32[][] memory proofs) {
        // Create leaves for the two hooks following the exact format from SuperVaultAggregator._createLeaf()
        bytes32[] memory leaves = new bytes32[](2);
        
        // Leaf 1: Deposit hook with yield source only (what inspect() returns)
        // The inspect() function only returns abi.encodePacked(yieldSource)
        bytes memory depositArgs = abi.encodePacked(mockVault); // Only yield source address
        leaves[0] = keccak256(bytes.concat(keccak256(abi.encode(depositHook, depositArgs))));
        
        // Leaf 2: Redeem hook with yield source only (what inspect() returns)
        // The inspect() function only returns abi.encodePacked(yieldSource)
        bytes memory redeemArgs = abi.encodePacked(mockVault); // Only yield source address
        leaves[1] = keccak256(bytes.concat(keccak256(abi.encode(redeemHook, redeemArgs))));
        
        // Sort leaves to match standard Merkle tree ordering
        if (leaves[0] > leaves[1]) {
            (leaves[0], leaves[1]) = (leaves[1], leaves[0]);
        }
        
        // For a 2-leaf tree, root is hash of the sorted leaves
        root = keccak256(abi.encodePacked(leaves[0], leaves[1]));
        
        // Store original leaf hashes for proof assignment
        bytes32 depositLeaf = keccak256(bytes.concat(keccak256(abi.encode(depositHook, depositArgs))));
        bytes32 redeemLeaf = keccak256(bytes.concat(keccak256(abi.encode(redeemHook, redeemArgs))));
        
        // Generate proofs for each leaf
        proofs = new bytes32[][](2);
        proofs[0] = new bytes32[](1); // Proof for deposit hook
        proofs[1] = new bytes32[](1); // Proof for redeem hook
        
        // In a 2-leaf tree, each leaf's proof is just its sibling
        // Find which position each leaf ended up in after sorting
        if (leaves[0] == depositLeaf) {
            // depositHook is first leaf after sorting
            proofs[0][0] = leaves[1]; // Sibling of deposit leaf
            proofs[1][0] = leaves[0]; // Sibling of redeem leaf  
        } else {
            // redeemHook is first leaf after sorting
            proofs[0][0] = leaves[1]; // Sibling of deposit leaf
            proofs[1][0] = leaves[0]; // Sibling of redeem leaf
        }
        
        return (root, proofs);
    }
    
    /// @notice Generate encoded hook arguments for Deposit4626VaultHook
    /// @param yieldSource Address of the yield source vault
    /// @param amount Amount to deposit
    /// @param usePrevHookAmount Whether to use previous hook amount
    /// @return Encoded hook arguments
    function encodeDepositHookArgs(
        address yieldSource,
        uint256 amount,
        bool usePrevHookAmount
    ) public pure returns (bytes memory) {
        return abi.encodePacked(
            bytes32(0), // yieldSourceOracleId placeholder
            yieldSource,
            amount,
            usePrevHookAmount
        );
    }
    
    /// @notice Generate encoded hook arguments for Redeem4626VaultHook
    /// @param yieldSource Address of the yield source vault
    /// @param owner Address of the owner
    /// @param shares Number of shares to redeem
    /// @param usePrevHookAmount Whether to use previous hook amount
    /// @return Encoded hook arguments
    function encodeRedeemHookArgs(
        address yieldSource,
        address owner,
        uint256 shares,
        bool usePrevHookAmount
    ) public pure returns (bytes memory) {
        return abi.encodePacked(
            bytes32(0), // yieldSourceOracleId placeholder
            yieldSource,
            owner,
            shares,
            usePrevHookAmount
        );
    }
    
    /// @notice Generate encoded hook arguments for ApproveAndDeposit4626VaultHook
    /// @param yieldSource Address of the yield source vault
    /// @param token Address of the token to approve and deposit
    /// @param amount Amount to deposit
    /// @param usePrevHookAmount Whether to use previous hook amount
    /// @return Encoded hook arguments
    function encodeApproveAndDepositHookArgs(
        address yieldSource,
        address token,
        uint256 amount,
        bool usePrevHookAmount
    ) public pure returns (bytes memory) {
        return abi.encodePacked(
            bytes32(0), // yieldSourceOracleId placeholder
            yieldSource,
            token,
            amount,
            usePrevHookAmount
        );
    }
    
    /// @notice Create a leaf hash for a specific hook and arguments
    /// @param hookAddress Address of the hook contract
    /// @param hookArgs Encoded hook arguments
    /// @return leaf The leaf hash
    function createLeaf(address hookAddress, bytes memory hookArgs) public pure returns (bytes32 leaf) {
        return keccak256(bytes.concat(keccak256(abi.encode(hookAddress, hookArgs))));
    }
    
    /// @notice Verify a Merkle proof against a root
    /// @param proof Array of proof elements
    /// @param root Merkle root
    /// @param leaf Leaf to verify
    /// @return True if proof is valid
    function verifyProof(bytes32[] memory proof, bytes32 root, bytes32 leaf) public pure returns (bool) {
        return MerkleProof.verify(proof, root, leaf);
    }
}

100.0% test/recon/helpers/UnsafeSuperVaultAggregator.sol

Lines covered: 8 / 8 (100.0%)

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.30;

import {SuperVaultAggregator} from "src/SuperVault/SuperVaultAggregator.sol";

/// @dev inherits from aggregator to override hook validation
contract UnsafeSuperVaultAggregator is SuperVaultAggregator {
    constructor(
        address superGovernor_,
        address vaultImpl_,
        address strategyImpl_,
        address escrowImpl_
    )
        SuperVaultAggregator(
            superGovernor_,
            vaultImpl_,
            strategyImpl_,
            escrowImpl_
        )
    {}

    function validateHook(
        address strategy,
        ValidateHookArgs calldata args
    ) external view override returns (bool isValid) {
        return true;
    }
}


89.0% test/recon/managers/YieldManager.sol

Lines covered: 26 / 29 (89.0%)

// SPDX-License-Identifier: GPL-2.0
pragma solidity ^0.8.0;

import {BaseSetup} from "@chimera/BaseSetup.sol";
import {vm} from "@chimera/Hevm.sol";

import {EnumerableSet} from "@recon/EnumerableSet.sol";
import {MockERC20} from "@recon/MockERC20.sol";

import {MockERC4626Tester} from "../mocks/MockERC4626Tester.sol";
import {MockERC5115Tester} from "../mocks/MockERC5115Tester.sol";
import {MockERC7540Tester} from "../mocks/MockERC7540Tester.sol";

/// @dev Source of truth for the yield sources being used in the test
/// @notice No yield sources should be used in the test suite without being added from here first
/// @notice Enum to specify the type of yield source to deploy
enum YieldSourceType {
    ERC4626,
    ERC5115,
    ERC7540
}

abstract contract YieldManager {
    using EnumerableSet for EnumerableSet.AddressSet;

    /// @notice The current target for this set of variables
    address private __yieldSource;

    /// @notice The current yield source type
    YieldSourceType private __currentYieldSourceType;

    /// @notice The list of all yield sources being used
    EnumerableSet.AddressSet private _yieldSources;

    // If the current target is address(0) then it has not been setup yet and should revert
    error YieldSourceNotSetup();
    // Do not allow duplicates
    error YieldSourceExists();
    // Enable only added yield sources
    error YieldSourceNotAdded();
    // Invalid yield source type
    error InvalidYieldSourceType();

    /// @notice Returns the current active yield source
    function _getYieldSource() internal view returns (address) {
        if (__yieldSource == address(0)) {
            revert YieldSourceNotSetup();
        }

        return __yieldSource;
    }

    /// @notice Returns all yield sources being used
    function _getYieldSources() internal view returns (address[] memory) {
        return _yieldSources.values();
    }

    /// @notice Returns the current yield source type
    function _getCurrentYieldSourceType() internal view returns (YieldSourceType) {
        return __currentYieldSourceType;
    }

    /// @notice Creates a new yield source and adds it to the list of yield sources
    /// @param asset The asset to create the yield source for
    /// @param yieldSourceType The type of yield source to deploy
    /// @return The address of the new yield source
    function _newYieldSource(address asset, YieldSourceType yieldSourceType) internal returns (address) {
        address yieldSource_;
        
        if (yieldSourceType == YieldSourceType.ERC4626) {
            yieldSource_ = address(new MockERC4626Tester(asset));
        } else if (yieldSourceType == YieldSourceType.ERC5115) {
            yieldSource_ = address(new MockERC5115Tester(asset));
        } else if (yieldSourceType == YieldSourceType.ERC7540) {
            yieldSource_ = address(new MockERC7540Tester(asset));
        } else {
            revert InvalidYieldSourceType();
        }
        
        _addYieldSource(yieldSource_);
        __yieldSource = yieldSource_; // sets the yield source as the current yield source
        __currentYieldSourceType = yieldSourceType;
        return yieldSource_;
    }

    /// @notice Creates a new yield source with ERC4626 by default (backward compatibility)
    /// @param asset The asset to create the yield source for
    /// @return The address of the new yield source
    function _newYieldSource(address asset) internal returns (address) {
        return _newYieldSource(asset, YieldSourceType.ERC4626);
    }

    /// @notice Legacy function name for backward compatibility
    /// @param asset The asset to create the yield source for
    /// @return The address of the new yield source
    function _newVault(address asset) internal returns (address) {
        return _newYieldSource(asset, YieldSourceType.ERC4626);
    }

    /// @notice Adds a yield source to the list of yield sources
    /// @param target The address of the yield source to add
    function _addYieldSource(address target) internal {
        if (_yieldSources.contains(target)) {
            revert YieldSourceExists();
        }

        _yieldSources.add(target);
    }

    /// @notice Legacy function name for backward compatibility
    /// @param target The address of the yield source to add
    function _addVault(address target) internal {
        _addYieldSource(target);
    }

    /// @notice Removes a yield source from the list of yield sources
    /// @param target The address of the yield source to remove
    function _removeYieldSource(address target) internal {
        if (!_yieldSources.contains(target)) {
            revert YieldSourceNotAdded();
        }

        _yieldSources.remove(target);
    }

    /// @notice Legacy function name for backward compatibility
    /// @param target The address of the yield source to remove
    function _removeVault(address target) internal {
        _removeYieldSource(target);
    }

    /// @notice Switches the current yield source based on the entropy
    /// @param entropy The entropy to choose a random yield source in the array for switching
    function _switchYieldSource(uint256 entropy) internal {
        address target = _yieldSources.at(entropy % _yieldSources.length());
        __yieldSource = target;
    }

    /// @notice Legacy function name for backward compatibility
    /// @param entropy The entropy to choose a random yield source in the array for switching
    function _switchVault(uint256 entropy) internal {
        _switchYieldSource(entropy);
    }

    /// @notice Switches to a different yield source type by deploying a new yield source
    /// @param asset The asset to create the new yield source for
    /// @param newYieldSourceType The new yield source type to switch to
    /// @return The address of the new yield source
    function _switchYieldSourceType(address asset, YieldSourceType newYieldSourceType) internal returns (address) {
        return _newYieldSource(asset, newYieldSourceType);
    }
}


35.0% test/recon/mocks/MockECDSAPPSOracle.sol

Lines covered: 15 / 42 (35.0%)

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

import {ISuperVaultAggregator} from "src/interfaces/SuperVault/ISuperVaultAggregator.sol";
import {IECDSAPPSOracle} from "src/interfaces/oracles/IECDSAPPSOracle.sol";

contract MockECDSAPPSOracle {
    //<>=============================================================<>
    //||                                                             ||
    //||                    NON-VIEW FUNCTIONS                       ||
    //||                                                             ||
    //<>=============================================================<>
    // Mock implementation of updatePPS
    function updatePPS(IECDSAPPSOracle.UpdatePPSArgs memory args) public {
        ISuperVaultAggregator.ForwardPPSArgs
            memory forwardArgs = ISuperVaultAggregator.ForwardPPSArgs({
                strategies: args.strategies,
                ppss: args.ppss,
                ppsStdevs: args.ppsStdevs,
                validatorSets: args.validatorSets,
                totalValidators: args.totalValidators,
                timestamps: args.timestamps,
                updateAuthority: msg.sender
            });

        ISuperVaultAggregator(_SUPER_GOVERNORReturn_0).forwardPPS(forwardArgs);
    }

    //<>=============================================================<>
    //||                                                             ||
    //||                    SETTER FUNCTIONS                         ||
    //||                                                             ||
    //<>=============================================================<>
    // Function to set return values for SUPER_GOVERNOR
    function setSUPER_GOVERNORReturn(address _value0) public {
        _SUPER_GOVERNORReturn_0 = _value0;
    }

    // Function to set return values for UPDATE_PPS_TYPEHASH
    function setUPDATE_PPS_TYPEHASHReturn(bytes32 _value0) public {
        _UPDATE_PPS_TYPEHASHReturn_0 = _value0;
    }

    // Function to set return values for domainSeparator
    function setDomainSeparatorReturn(bytes32 _value0) public {
        _domainSeparatorReturn_0 = _value0;
    }

    /*******************************************************************
     *   ⚠️ WARNING ⚠️ WARNING ⚠️ WARNING ⚠️ WARNING ⚠️ WARNING ⚠️  *
     *-----------------------------------------------------------------*
     *      Generally you only need to modify the sections above.      *
     *          The code below handles system operations.              *
     *******************************************************************/

    //<>=============================================================<>
    //||                                                             ||
    //||        ⚠️  STRUCT DEFINITIONS - DO NOT MODIFY  ⚠️          ||
    //||                                                             ||
    //<>=============================================================<>
    // Struct definition removed - using IECDSAPPSOracle.UpdatePPSArgs from interface

    //<>=============================================================<>
    //||                                                             ||
    //||        ⚠️  EVENTS DEFINITIONS - DO NOT MODIFY  ⚠️          ||
    //||                                                             ||
    //<>=============================================================<>
    event EIP712DomainChanged();
    event PPSValidated(
        address strategy,
        uint256 pps,
        uint256 ppsStdev,
        uint256 validatorSet,
        uint256 totalValidators,
        uint256 timestamp,
        address sender
    );

    //<>=============================================================<>
    //||                                                             ||
    //||         ⚠️  INTERNAL STORAGE - DO NOT MODIFY  ⚠️           ||
    //||                                                             ||
    //<>=============================================================<>
    address private _SUPER_GOVERNORReturn_0;
    bytes32 private _UPDATE_PPS_TYPEHASHReturn_0;
    bytes32 private _domainSeparatorReturn_0;
    bytes1 private _eip712DomainReturn_0;
    string private _eip712DomainReturn_1;
    string private _eip712DomainReturn_2;
    uint256 private _eip712DomainReturn_3;
    address private _eip712DomainReturn_4;
    bytes32 private _eip712DomainReturn_5;
    uint256[] private _eip712DomainReturn_6;
    uint256 private _nonceReturn_0;

    //<>=============================================================<>
    //||                                                             ||
    //||          ⚠️  VIEW FUNCTIONS - DO NOT MODIFY  ⚠️            ||
    //||                                                             ||
    //<>=============================================================<>
    // Mock implementation of SUPER_GOVERNOR
    function SUPER_GOVERNOR() public view returns (address) {
        return _SUPER_GOVERNORReturn_0;
    }

    // Mock implementation of UPDATE_PPS_TYPEHASH
    function UPDATE_PPS_TYPEHASH() public view returns (bytes32) {
        return _UPDATE_PPS_TYPEHASHReturn_0;
    }

    // Mock implementation of domainSeparator
    function domainSeparator() public view returns (bytes32) {
        return _domainSeparatorReturn_0;
    }

    // Mock implementation of eip712Domain
    function eip712Domain()
        public
        view
        returns (
            bytes1,
            string memory,
            string memory,
            uint256,
            address,
            bytes32,
            uint256[] memory
        )
    {
        return (
            _eip712DomainReturn_0,
            _eip712DomainReturn_1,
            _eip712DomainReturn_2,
            _eip712DomainReturn_3,
            _eip712DomainReturn_4,
            _eip712DomainReturn_5,
            _eip712DomainReturn_6
        );
    }

    // Mock implementation of nonce
    function nonce() public view returns (uint256) {
        return _nonceReturn_0;
    }
}


89.0% test/recon/mocks/MockERC4626Tester.sol

Lines covered: 105 / 117 (89.0%)

// SPDX-License-Identifier: MIT
// Heavily inspired by https://github.com/liquity/V2-gov/blob/9632de9a988522775336d9b60cdf2542efc600db/test/mocks/MaliciousInitiative.sol
pragma solidity ^0.8.0;

import {MockERC20} from "@recon/MockERC20.sol";

abstract contract ERC4626 is MockERC20 {
    MockERC20 public immutable asset;

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

    constructor(MockERC20 _asset) MockERC20("MockERC4626Tester", "MCT", 18) {
        asset = _asset;
    }

    function deposit(
        uint256 assets,
        address receiver
    ) public virtual returns (uint256) {
        uint256 shares = previewDeposit(assets);
        _deposit(msg.sender, receiver, assets, shares);
        return shares;
    }

    function mint(
        uint256 shares,
        address receiver
    ) public virtual returns (uint256) {
        uint256 assets = previewMint(shares);
        _deposit(msg.sender, receiver, assets, shares);
        return assets;
    }

    function withdraw(
        uint256 assets,
        address receiver,
        address owner
    ) public virtual returns (uint256) {
        uint256 shares = previewWithdraw(assets);
        _withdraw(msg.sender, receiver, owner, assets, shares);
        return shares;
    }

    function redeem(
        uint256 shares,
        address receiver,
        address owner
    ) public virtual returns (uint256) {
        uint256 assets = previewRedeem(shares);
        _withdraw(msg.sender, receiver, owner, assets, shares);
        return assets;
    }

    function totalAssets() public view virtual returns (uint256) {
        return asset.balanceOf(address(this));
    }

    function convertToShares(
        uint256 assets
    ) public view virtual returns (uint256) {
        uint256 supply = totalSupply;
        return supply == 0 ? assets : (assets * supply) / totalAssets();
    }

    function convertToAssets(
        uint256 shares
    ) public view virtual returns (uint256) {
        uint256 supply = totalSupply;
        return supply == 0 ? shares : (shares * totalAssets()) / supply;
    }

    function previewDeposit(
        uint256 assets
    ) public view virtual returns (uint256) {
        return convertToShares(assets);
    }

    function previewMint(uint256 shares) public view virtual returns (uint256) {
        uint256 supply = totalSupply;
        return supply == 0 ? shares : (shares * totalAssets()) / supply;
    }

    function previewWithdraw(
        uint256 assets
    ) public view virtual returns (uint256) {
        uint256 supply = totalSupply;
        return supply == 0 ? assets : (assets * supply) / totalAssets();
    }

    function previewRedeem(
        uint256 shares
    ) public view virtual returns (uint256) {
        return convertToAssets(shares);
    }

    function maxDeposit(address) public view virtual returns (uint256) {
        return type(uint256).max;
    }

    function maxMint(address) public view virtual returns (uint256) {
        return type(uint256).max;
    }

    function maxWithdraw(address owner) public view virtual returns (uint256) {
        return convertToAssets(balanceOf[owner]);
    }

    function maxRedeem(address owner) public view virtual returns (uint256) {
        return balanceOf[owner];
    }

    function _deposit(
        address caller,
        address receiver,
        uint256 assets,
        uint256 shares
    ) internal virtual {
        asset.transferFrom(caller, address(this), assets);
        _mint(receiver, shares);
        emit Deposit(caller, receiver, assets, shares);
    }

    function _withdraw(
        address caller,
        address receiver,
        address owner,
        uint256 assets,
        uint256 shares
    ) internal virtual {
        if (caller != owner) {
            allowance[owner][caller] -= shares;
        }
        _burn(owner, shares);
        asset.transfer(receiver, assets);
        emit Withdraw(caller, receiver, owner, assets, shares);
    }
}

enum FunctionType {
    NONE,
    DEPOSIT,
    MINT,
    WITHDRAW,
    REDEEM
}

enum RevertType {
    NONE,
    THROW,
    OOG,
    RETURN_BOMB,
    REVERT_BOMB
}

/// @dev This will use the simplest possible implementation initially to allow getting coverage and will be expanded on as necessary for testing potentially more interesting behaviors
/// @dev Note that blindspots not testable with this current implementation are covered in the ERC4626-integrations.md file
contract MockERC4626Tester is ERC4626 {
    mapping(FunctionType => RevertType) public revertBehaviours;

    uint8 public decimalsOffset;
    /// @dev Track total losses
    uint256 public totalLosses;
    uint256 public totalGains;
    uint256 public lossOnWithdraw;
    uint256 public MAX_BPS = 10_000;

    constructor(address _asset) ERC4626(MockERC20(_asset)) {}

    /// Standard ERC4626 functions ///

    /// @dev Deposit assets, reverts as specified
    function deposit(
        uint256 assets,
        address receiver
    ) public override returns (uint256) {
        _performRevertBehaviour(revertBehaviours[FunctionType.DEPOSIT]);
        return super.deposit(assets, receiver);
    }

    /// @dev Mint shares, reverts as specified
    function mint(
        uint256 shares,
        address receiver
    ) public override returns (uint256) {
        _performRevertBehaviour(revertBehaviours[FunctionType.MINT]);
        return super.mint(shares, receiver);
    }

    /// @dev Withdraw assets, reverts as specified
    function withdraw(
        uint256 assets,
        address receiver,
        address owner
    ) public override returns (uint256) {
        _performRevertBehaviour(revertBehaviours[FunctionType.WITHDRAW]);

        uint256 shares = previewWithdraw(assets);
        uint256 lossyAssets = assets - ((assets * lossOnWithdraw) / MAX_BPS);
        _withdraw(msg.sender, receiver, owner, lossyAssets, shares);

        return shares;
    }

    /// @dev Redeem shares, reverts as specified
    function redeem(
        uint256 shares,
        address receiver,
        address owner
    ) public override returns (uint256) {
        _performRevertBehaviour(revertBehaviours[FunctionType.REDEEM]);

        uint256 assets = previewRedeem(shares);
        uint256 lossyAssets = assets - ((assets * lossOnWithdraw) / MAX_BPS);
        _withdraw(msg.sender, receiver, owner, lossyAssets, shares);

        return lossyAssets;
    }

    /// @dev Preview deposit, reverts as specified
    function previewDeposit(
        uint256 assets
    ) public view override returns (uint256) {
        _performRevertBehaviour(revertBehaviours[FunctionType.DEPOSIT]);
        return super.previewDeposit(assets);
    }

    /// @dev Preview mint, reverts as specified
    function previewMint(
        uint256 shares
    ) public view override returns (uint256) {
        _performRevertBehaviour(revertBehaviours[FunctionType.MINT]);
        return super.previewMint(shares);
    }

    /// @dev Preview withdraw, reverts as specified
    function previewWithdraw(
        uint256 assets
    ) public view override returns (uint256) {
        _performRevertBehaviour(revertBehaviours[FunctionType.WITHDRAW]);
        return super.previewWithdraw(assets);
    }

    /// @dev Preview redeem, reverts as specified
    function previewRedeem(
        uint256 shares
    ) public view override returns (uint256) {
        _performRevertBehaviour(revertBehaviours[FunctionType.REDEEM]);
        return super.previewRedeem(shares);
    }

    /// @dev Revert in different ways to test the revert behaviour
    function _performRevertBehaviour(RevertType action) internal pure {
        if (action == RevertType.THROW) {
            revert("A normal Revert");
        }

        // 3 gas per iteration, consider changing to storage changes if traces are cluttered
        if (action == RevertType.OOG) {
            uint256 i;
            while (true) {
                ++i;
            }
        }

        if (action == RevertType.RETURN_BOMB) {
            uint256 _bytes = 2_000_000;
            assembly {
                return(0, _bytes)
            }
        }

        if (action == RevertType.REVERT_BOMB) {
            uint256 _bytes = 2_000_000;
            assembly {
                revert(0, _bytes)
            }
        }

        return; // NONE
    }

    /// Custom functions for testing vault behavior ///

    /// @dev Specify the revert behavior on each function
    function setRevertBehavior(FunctionType ft, RevertType rt) public {
        revertBehaviours[ft] = rt;
    }

    /// @dev Simulate a loss on the vault's assets
    function simulateLoss(uint256 lossAmount) external {
        MockERC20(asset).transfer(address(0xbeef), lossAmount);
        totalLosses += lossAmount;
    }

    /// @dev Simulate a gain on the vault's assets (similar to Yearn's profit taking)
    function simulateGain(uint256 gainAmount) external {
        MockERC20(asset).transferFrom(msg.sender, address(this), gainAmount);
        totalGains += gainAmount;
    }

    /// @dev Set the loss on withdraw as percentage of the assets being withdrawn
    function setLossOnWithdraw(uint256 _lossOnWithdraw) public {
        _lossOnWithdraw %= MAX_BPS + 1; // clamp to ensure we set a max of 100%
        lossOnWithdraw = _lossOnWithdraw;
    }

    /// @dev Set the decimal offset. Only possible with no supply.
    function setDecimalsOffset(uint8 targetDecimalsOffset) external {
        if (totalSupply != 0) {
            revert("Supply is not zero");
        }
        decimalsOffset = targetDecimalsOffset;
    }
}


10.0% test/recon/mocks/MockERC4626YieldSourceOracle.sol

Lines covered: 6 / 57 (10.0%)

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.30;

import {IERC4626} from "@openzeppelin/contracts/interfaces/IERC4626.sol";
import {IYieldSourceOracle} from "@superform-v2-core/src/interfaces/accounting/IYieldSourceOracle.sol";

/// @title MockERC4626YieldSourceOracle
/// @notice Mock oracle for ERC4626 vaults in testing
contract MockERC4626YieldSourceOracle is IYieldSourceOracle {
    mapping(address => bool) public validAssetMap;
    
    function setValidAsset(address asset, bool isValid) external {
        validAssetMap[asset] = isValid;
    }
    
    function decimals(address yieldSourceAddress) external view returns (uint8) {
        return IERC4626(yieldSourceAddress).decimals();
    }
    
    function getShareOutput(
        address yieldSourceAddress,
        address,
        uint256 assetsIn
    ) external view returns (uint256) {
        return IERC4626(yieldSourceAddress).previewDeposit(assetsIn);
    }
    
    function getAssetOutput(
        address yieldSourceAddress,
        address,
        uint256 sharesIn
    ) public view returns (uint256) {
        return IERC4626(yieldSourceAddress).previewRedeem(sharesIn);
    }
    
    function getPricePerShare(address yieldSourceAddress) external view returns (uint256) {
        IERC4626 yieldSource = IERC4626(yieldSourceAddress);
        uint256 _decimals = yieldSource.decimals();
        return yieldSource.convertToAssets(10 ** _decimals);
    }
    
    function getBalanceOfOwner(
        address yieldSourceAddress,
        address ownerOfShares
    ) external view returns (uint256) {
        return IERC4626(yieldSourceAddress).balanceOf(ownerOfShares);
    }
    
    function getTVLByOwnerOfShares(
        address yieldSourceAddress,
        address ownerOfShares
    ) external view returns (uint256) {
        uint256 shares = IERC4626(yieldSourceAddress).balanceOf(ownerOfShares);
        return IERC4626(yieldSourceAddress).convertToAssets(shares);
    }
    
    function getTVL(address yieldSourceAddress) external view returns (uint256) {
        return IERC4626(yieldSourceAddress).totalAssets();
    }
    
    function getPricePerShareMultiple(
        address[] memory yieldSourceAddresses
    ) external view returns (uint256[] memory) {
        uint256[] memory prices = new uint256[](yieldSourceAddresses.length);
        for (uint256 i = 0; i < yieldSourceAddresses.length; i++) {
            IERC4626 yieldSource = IERC4626(yieldSourceAddresses[i]);
            uint256 _decimals = yieldSource.decimals();
            prices[i] = yieldSource.convertToAssets(10 ** _decimals);
        }
        return prices;
    }
    
    function getTVLByOwnerOfSharesMultiple(
        address[] memory yieldSourceAddresses,
        address[][] memory ownersOfShares
    ) external view returns (uint256[][] memory) {
        uint256[][] memory result = new uint256[][](yieldSourceAddresses.length);
        for (uint256 i = 0; i < yieldSourceAddresses.length; i++) {
            result[i] = new uint256[](ownersOfShares[i].length);
            for (uint256 j = 0; j < ownersOfShares[i].length; j++) {
                uint256 shares = IERC4626(yieldSourceAddresses[i]).balanceOf(ownersOfShares[i][j]);
                result[i][j] = IERC4626(yieldSourceAddresses[i]).convertToAssets(shares);
            }
        }
        return result;
    }
    
    function getTVLMultiple(
        address[] memory yieldSourceAddresses
    ) external view returns (uint256[] memory) {
        uint256[] memory tvls = new uint256[](yieldSourceAddresses.length);
        for (uint256 i = 0; i < yieldSourceAddresses.length; i++) {
            tvls[i] = IERC4626(yieldSourceAddresses[i]).totalAssets();
        }
        return tvls;
    }
    
    function isValidUnderlyingAsset(address, address asset) external view returns (bool) {
        return validAssetMap[asset];
    }
    
    function isValidUnderlyingAssets(
        address[] memory,
        address[] memory assets
    ) external view returns (bool[] memory) {
        bool[] memory validities = new bool[](assets.length);
        for (uint256 i = 0; i < assets.length; i++) {
            validities[i] = validAssetMap[assets[i]];
        }
        return validities;
    }
    
    function getAssetOutputWithFees(
        bytes32,
        address yieldSourceAddress,
        address,
        address,
        uint256 sharesIn
    ) external view returns (uint256) {
        return IERC4626(yieldSourceAddress).previewRedeem(sharesIn);
    }
}

25.0% test/recon/mocks/MockERC5115Tester.sol

Lines covered: 26 / 104 (25.0%)

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

import {MockERC20} from "@recon/MockERC20.sol";

abstract contract ERC5115 is MockERC20 {
    MockERC20 public immutable yieldToken;
    address[] public tokensIn;
    address[] public tokensOut;

    event Deposit(
        address indexed caller,
        address indexed receiver,
        address indexed tokenIn,
        uint256 amountDeposited,
        uint256 amountSyOut
    );

    event Redeem(
        address indexed caller,
        address indexed receiver,
        address indexed tokenOut,
        uint256 amountSyToRedeem,
        uint256 amountTokenOut
    );

    constructor(
        MockERC20 _yieldToken
    ) MockERC20("MockERC5115Tester", "SY5115", 18) {
        yieldToken = _yieldToken;
        tokensIn.push(address(_yieldToken));
        tokensOut.push(address(_yieldToken));
    }

    function deposit(
        address receiver,
        address tokenIn,
        uint256 amountTokenToDeposit,
        uint256 minSharesOut,
        bool depositFromInternalBalance
    ) public virtual returns (uint256 amountSharesOut) {
        amountSharesOut = previewDeposit(tokenIn, amountTokenToDeposit);

        MockERC20(tokenIn).transferFrom(
            msg.sender,
            address(this),
            amountTokenToDeposit
        );
        _mint(receiver, amountSharesOut);

        emit Deposit(
            msg.sender,
            receiver,
            tokenIn,
            amountTokenToDeposit,
            amountSharesOut
        );
    }

    function exchangeRate() public view virtual returns (uint256) {
        uint256 supply = totalSupply;
        if (supply == 0) return 1e18;
        return (yieldToken.balanceOf(address(this)) * 1e18) / supply;
    }

    function getTokensIn() public view virtual returns (address[] memory) {
        return tokensIn;
    }

    function getTokensOut() public view virtual returns (address[] memory) {
        return tokensOut;
    }

    function previewDeposit(
        address tokenIn,
        uint256 amountTokenToDeposit
    ) public view virtual returns (uint256 amountSharesOut) {
        require(tokenIn == address(yieldToken), "Invalid token");
        uint256 supply = totalSupply;
        if (supply == 0) {
            return amountTokenToDeposit;
        }
        return
            (amountTokenToDeposit * supply) /
            yieldToken.balanceOf(address(this));
    }

    function previewRedeem(
        address tokenOut,
        uint256 amountSharesToRedeem
    ) public view virtual returns (uint256 amountTokenOut) {
        require(tokenOut == address(yieldToken), "Invalid token");
        uint256 supply = totalSupply;
        if (supply == 0) {
            return amountSharesToRedeem;
        }
        return
            (amountSharesToRedeem * yieldToken.balanceOf(address(this))) /
            supply;
    }
}

enum RevertType {
    NONE,
    THROW,
    OOG,
    RETURN_BOMB,
    REVERT_BOMB
}

contract MockERC5115Tester is ERC5115 {
    RevertType public revertBehaviour;
    uint256 public totalLosses;
    uint256 public totalGains;
    uint256 public lossOnWithdraw;
    uint256 public MAX_BPS = 10_000;

    constructor(address _yieldToken) ERC5115(MockERC20(_yieldToken)) {}

    function deposit(
        address receiver,
        address tokenIn,
        uint256 amountTokenToDeposit,
        uint256 minSharesOut,
        bool depositFromInternalBalance
    ) public override returns (uint256 amountSharesOut) {
        _performRevertBehaviour(revertBehaviour);
        return
            super.deposit(
                receiver,
                tokenIn,
                amountTokenToDeposit,
                minSharesOut,
                depositFromInternalBalance
            );
    }

    function redeem(
        address receiver,
        uint256 amountSharesToRedeem,
        address tokenOut,
        uint256 minTokenOut,
        bool burnFromInternalBalance
    ) public virtual returns (uint256 amountTokenOut) {
        amountTokenOut = previewRedeem(tokenOut, amountSharesToRedeem);

        _burn(msg.sender, amountSharesToRedeem);
        uint256 lossyAmountTokenOut = amountTokenOut -
            ((amountTokenOut * lossOnWithdraw) / MAX_BPS);
        MockERC20(tokenOut).transfer(receiver, lossyAmountTokenOut);

        emit Redeem(
            msg.sender,
            receiver,
            tokenOut,
            amountSharesToRedeem,
            amountTokenOut
        );
    }

    function _performRevertBehaviour(RevertType action) internal pure {
        if (action == RevertType.THROW) {
            revert("A normal Revert");
        }

        if (action == RevertType.OOG) {
            uint256 i;
            while (true) {
                ++i;
            }
        }

        if (action == RevertType.RETURN_BOMB) {
            uint256 _bytes = 2_000_000;
            assembly {
                return(0, _bytes)
            }
        }

        if (action == RevertType.REVERT_BOMB) {
            uint256 _bytes = 2_000_000;
            assembly {
                revert(0, _bytes)
            }
        }

        return; // NONE
    }

    function setRevertBehavior(RevertType rt) public {
        revertBehaviour = rt;
    }

    function simulateLoss(uint256 lossAmount) external {
        MockERC20(yieldToken).transfer(address(0xbeef), lossAmount);
        totalLosses += lossAmount;
    }

    function simulateGain(uint256 gainAmount) external {
        MockERC20(yieldToken).transferFrom(
            msg.sender,
            address(this),
            gainAmount
        );
        totalGains += gainAmount;
    }

    /// @dev Set the loss on withdraw as percentage of the assets being withdrawn
    function setLossOnWithdraw(uint256 _lossOnWithdraw) public {
        _lossOnWithdraw %= MAX_BPS + 1; // clamp to ensure we set a max of 100%
        lossOnWithdraw = _lossOnWithdraw;
    }

    function increaseYield(uint256 increasePercentageFP4) public {
        require(increasePercentageFP4 <= 10000, "Invalid percentage");
        uint256 amount = (yieldToken.balanceOf(address(this)) *
            increasePercentageFP4) / 10000;
        MockERC20(yieldToken).transferFrom(msg.sender, address(this), amount);
    }

    function decreaseYield(uint256 decreasePercentageFP4) public {
        require(decreasePercentageFP4 <= 10000, "Invalid percentage");
        uint256 amount = (yieldToken.balanceOf(address(this)) *
            decreasePercentageFP4) / 10000;
        MockERC20(yieldToken).transfer(address(0xbeef), amount);
        totalLosses += amount;
    }
}


10.0% test/recon/mocks/MockERC5115YieldSourceOracle.sol

Lines covered: 6 / 59 (10.0%)

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.30;

import {IYieldSourceOracle} from "@superform-v2-core/src/interfaces/accounting/IYieldSourceOracle.sol";
import {MockERC5115Tester} from "./MockERC5115Tester.sol";

/// @title MockERC5115YieldSourceOracle
/// @notice Mock oracle for ERC5115 (Standardized Yield) vaults in testing
contract MockERC5115YieldSourceOracle is IYieldSourceOracle {
    mapping(address => bool) public validAssetMap;
    
    function setValidAsset(address asset, bool isValid) external {
        validAssetMap[asset] = isValid;
    }
    
    function decimals(address) external pure returns (uint8) {
        // ERC5115 always uses 18 decimals
        return 18;
    }
    
    function getShareOutput(
        address yieldSourceAddress,
        address assetIn,
        uint256 assetsIn
    ) external view returns (uint256) {
        return MockERC5115Tester(yieldSourceAddress).previewDeposit(assetIn, assetsIn);
    }
    
    function getAssetOutput(
        address yieldSourceAddress,
        address assetOut,
        uint256 sharesIn
    ) public view returns (uint256) {
        return MockERC5115Tester(yieldSourceAddress).previewRedeem(assetOut, sharesIn);
    }
    
    function getPricePerShare(address yieldSourceAddress) external view returns (uint256) {
        return MockERC5115Tester(yieldSourceAddress).exchangeRate();
    }
    
    function getBalanceOfOwner(
        address yieldSourceAddress,
        address ownerOfShares
    ) external view returns (uint256) {
        return MockERC5115Tester(yieldSourceAddress).balanceOf(ownerOfShares);
    }
    
    function getTVLByOwnerOfShares(
        address yieldSourceAddress,
        address ownerOfShares
    ) external view returns (uint256) {
        uint256 shares = MockERC5115Tester(yieldSourceAddress).balanceOf(ownerOfShares);
        uint256 exchangeRate = MockERC5115Tester(yieldSourceAddress).exchangeRate();
        return (shares * exchangeRate) / 1e18;
    }
    
    function getTVL(address yieldSourceAddress) external view returns (uint256) {
        uint256 totalShares = MockERC5115Tester(yieldSourceAddress).totalSupply();
        uint256 exchangeRate = MockERC5115Tester(yieldSourceAddress).exchangeRate();
        return (totalShares * exchangeRate) / 1e18;
    }
    
    function getPricePerShareMultiple(
        address[] memory yieldSourceAddresses
    ) external view returns (uint256[] memory) {
        uint256[] memory prices = new uint256[](yieldSourceAddresses.length);
        for (uint256 i = 0; i < yieldSourceAddresses.length; i++) {
            prices[i] = MockERC5115Tester(yieldSourceAddresses[i]).exchangeRate();
        }
        return prices;
    }
    
    function getTVLByOwnerOfSharesMultiple(
        address[] memory yieldSourceAddresses,
        address[][] memory ownersOfShares
    ) external view returns (uint256[][] memory) {
        uint256[][] memory result = new uint256[][](yieldSourceAddresses.length);
        for (uint256 i = 0; i < yieldSourceAddresses.length; i++) {
            result[i] = new uint256[](ownersOfShares[i].length);
            uint256 exchangeRate = MockERC5115Tester(yieldSourceAddresses[i]).exchangeRate();
            for (uint256 j = 0; j < ownersOfShares[i].length; j++) {
                uint256 shares = MockERC5115Tester(yieldSourceAddresses[i]).balanceOf(ownersOfShares[i][j]);
                result[i][j] = (shares * exchangeRate) / 1e18;
            }
        }
        return result;
    }
    
    function getTVLMultiple(
        address[] memory yieldSourceAddresses
    ) external view returns (uint256[] memory) {
        uint256[] memory tvls = new uint256[](yieldSourceAddresses.length);
        for (uint256 i = 0; i < yieldSourceAddresses.length; i++) {
            uint256 totalShares = MockERC5115Tester(yieldSourceAddresses[i]).totalSupply();
            uint256 exchangeRate = MockERC5115Tester(yieldSourceAddresses[i]).exchangeRate();
            tvls[i] = (totalShares * exchangeRate) / 1e18;
        }
        return tvls;
    }
    
    function isValidUnderlyingAsset(address, address asset) external view returns (bool) {
        return validAssetMap[asset];
    }
    
    function isValidUnderlyingAssets(
        address[] memory,
        address[] memory assets
    ) external view returns (bool[] memory) {
        bool[] memory validities = new bool[](assets.length);
        for (uint256 i = 0; i < assets.length; i++) {
            validities[i] = validAssetMap[assets[i]];
        }
        return validities;
    }
    
    function getAssetOutputWithFees(
        bytes32,
        address yieldSourceAddress,
        address assetOut,
        address,
        uint256 sharesIn
    ) external view returns (uint256) {
        return MockERC5115Tester(yieldSourceAddress).previewRedeem(assetOut, sharesIn);
    }
}

71.0% test/recon/mocks/MockERC7540Tester.sol

Lines covered: 127 / 177 (71.0%)

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

import {MockERC20} from "@recon/MockERC20.sol";
import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";

abstract contract ERC7575 is MockERC20 {
    MockERC20 public immutable asset;

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

    constructor(MockERC20 _asset) MockERC20("MockERC7540Tester", "M7540", 18) {
        asset = _asset;
    }

    function share() external view returns (address shareTokenAddress) {
        return address(this);
    }

    function totalAssets() public view virtual returns (uint256) {
        return asset.balanceOf(address(this));
    }

    function convertToShares(
        uint256 assets
    ) public view virtual returns (uint256) {
        uint256 supply = totalSupply;
        return supply == 0 ? assets : (assets * supply) / totalAssets();
    }

    function convertToAssets(
        uint256 shares
    ) public view virtual returns (uint256) {
        uint256 supply = totalSupply;
        return supply == 0 ? shares : (shares * totalAssets()) / supply;
    }

    function maxDeposit(address) public pure virtual returns (uint256) {
        return type(uint256).max;
    }

    function maxMint(address) public pure virtual returns (uint256) {
        return type(uint256).max;
    }

    function maxWithdraw(address owner) public view virtual returns (uint256) {
        return convertToAssets(balanceOf[owner]);
    }

    function maxRedeem(address owner) public view virtual returns (uint256) {
        return balanceOf[owner];
    }

    function previewDeposit(
        uint256 assets
    ) public view virtual returns (uint256) {
        return convertToShares(assets);
    }

    function previewMint(uint256 shares) public view virtual returns (uint256) {
        uint256 supply = totalSupply;
        return supply == 0 ? shares : (shares * totalAssets()) / supply;
    }

    function previewWithdraw(
        uint256 assets
    ) public view virtual returns (uint256) {
        uint256 supply = totalSupply;
        return supply == 0 ? assets : (assets * supply) / totalAssets();
    }

    function previewRedeem(
        uint256 shares
    ) public view virtual returns (uint256) {
        return convertToAssets(shares);
    }

    function deposit(
        uint256 assets,
        address receiver
    ) public virtual returns (uint256 shares) {
        shares = previewDeposit(assets);
        asset.transferFrom(msg.sender, address(this), assets);
        _mint(receiver, shares);
        emit Deposit(msg.sender, receiver, assets, shares);
    }

    function mint(
        uint256 shares,
        address receiver
    ) public virtual returns (uint256 assets) {
        assets = previewMint(shares);
        asset.transferFrom(msg.sender, address(this), assets);
        _mint(receiver, shares);
        emit Deposit(msg.sender, receiver, assets, shares);
    }
}

contract MockERC7540Tester is ERC7575, IERC165 {
    event DepositRequest(
        address indexed controller,
        address indexed owner,
        uint256 indexed requestId,
        address sender,
        uint256 assets
    );
    event RedeemRequest(
        address indexed controller,
        address indexed owner,
        uint256 indexed requestId,
        address sender,
        uint256 shares
    );
    event OperatorSet(
        address indexed controller,
        address indexed operator,
        bool approved
    );

    struct DepositRequestStruct {
        uint256 assets;
        address controller;
        address owner;
        bool fulfilled;
        bool canceled;
    }

    struct RedeemRequestStruct {
        uint256 shares;
        address controller;
        address owner;
        bool fulfilled;
        bool canceled;
    }

    uint256 private _nextRequestId = 1;

    mapping(uint256 => DepositRequestStruct) public depositRequests;
    mapping(uint256 => RedeemRequestStruct) public redeemRequests;
    mapping(address => mapping(address => bool)) public operators;
    mapping(uint256 => bool) public pendingCancelDeposit;
    mapping(uint256 => bool) public pendingCancelRedeem;

    uint256 public yieldMultiplier = 10000; // 100% in basis points
    uint256 private constant MAX_BPS = 10000;
    uint256 public totalLosses;
    uint256 public totalGains;
    uint256 public lossOnWithdraw;

    constructor(address _asset) ERC7575(MockERC20(_asset)) {}

    // Operator Management
    function setOperator(
        address operator,
        bool approved
    ) external returns (bool) {
        operators[msg.sender][operator] = approved;
        emit OperatorSet(msg.sender, operator, approved);
        return true;
    }

    function isOperator(
        address controller,
        address operator
    ) external view returns (bool) {
        return operators[controller][operator];
    }

    // Async Deposit Flow
    function requestDeposit(
        uint256 assets,
        address controller,
        address owner
    ) external returns (uint256 requestId) {
        requestId = _nextRequestId++;
        depositRequests[requestId] = DepositRequestStruct({
            assets: assets,
            controller: controller,
            owner: owner,
            fulfilled: false,
            canceled: false
        });

        asset.transferFrom(msg.sender, address(this), assets);
        emit DepositRequest(controller, owner, requestId, msg.sender, assets);
    }

    function pendingDepositRequest(
        uint256 requestId,
        address controller
    ) external view returns (uint256) {
        DepositRequestStruct storage request = depositRequests[requestId];
        if (
            request.controller != controller ||
            request.fulfilled ||
            request.canceled
        ) {
            return 0;
        }
        return request.assets;
    }

    function claimableDepositRequest(
        uint256 requestId,
        address controller
    ) external view returns (uint256) {
        DepositRequestStruct storage request = depositRequests[requestId];
        if (
            request.controller != controller ||
            request.fulfilled ||
            request.canceled
        ) {
            return 0;
        }
        return request.assets;
    }

    function pendingCancelDepositRequest(
        uint256 requestId,
        address controller
    ) external view returns (bool) {
        DepositRequestStruct storage request = depositRequests[requestId];
        return
            request.controller == controller && pendingCancelDeposit[requestId];
    }

    // Override deposit to handle async requests
    function deposit(
        uint256 assets,
        address receiver,
        address controller
    ) public returns (uint256 shares) {
        require(
            msg.sender == controller || operators[controller][msg.sender],
            "Not authorized"
        );

        // Find and fulfill a matching deposit request
        for (uint256 i = 1; i < _nextRequestId; i++) {
            DepositRequestStruct storage request = depositRequests[i];
            if (
                request.controller == controller &&
                !request.fulfilled &&
                !request.canceled &&
                request.assets >= assets
            ) {
                shares = previewDeposit(assets);
                request.fulfilled = true;
                _mint(receiver, shares);

                // Refund excess assets if any
                if (request.assets > assets) {
                    asset.transfer(controller, request.assets - assets);
                }

                emit Deposit(msg.sender, receiver, assets, shares);
                return shares;
            }
        }

        // Fallback to synchronous deposit if no matching request
        return super.deposit(assets, receiver);
    }

    function withdraw(
        uint256 assets,
        address receiver,
        address owner
    ) public returns (uint256 shares) {
        shares = previewWithdraw(assets);
        if (msg.sender != owner) {
            allowance[owner][msg.sender] -= shares;
        }
        _burn(owner, shares);
        uint256 lossyAssets = assets - ((assets * lossOnWithdraw) / MAX_BPS);

        asset.transfer(receiver, lossyAssets);
        emit Withdraw(msg.sender, receiver, owner, lossyAssets, shares);
    }

    function redeem(
        uint256 shares,
        address receiver,
        address owner
    ) public returns (uint256 assets) {
        assets = previewRedeem(shares);
        if (msg.sender != owner) {
            allowance[owner][msg.sender] -= shares;
        }
        _burn(owner, shares);
        uint256 lossyAssets = assets - ((assets * lossOnWithdraw) / MAX_BPS);

        asset.transfer(receiver, lossyAssets);
        emit Withdraw(msg.sender, receiver, owner, lossyAssets, shares);
    }

    // Async Redeem Flow
    function requestRedeem(
        uint256 shares,
        address controller,
        address owner
    ) external returns (uint256 requestId) {
        requestId = _nextRequestId++;
        redeemRequests[requestId] = RedeemRequestStruct({
            shares: shares,
            controller: controller,
            owner: owner,
            fulfilled: false,
            canceled: false
        });

        emit RedeemRequest(controller, owner, requestId, msg.sender, shares);
    }

    function pendingRedeemRequest(
        uint256 requestId,
        address controller
    ) external view returns (uint256) {
        RedeemRequestStruct storage request = redeemRequests[requestId];
        if (
            request.controller != controller ||
            request.fulfilled ||
            request.canceled
        ) {
            return 0;
        }
        return request.shares;
    }

    function claimableRedeemRequest(
        uint256 requestId,
        address controller
    ) external view returns (uint256) {
        RedeemRequestStruct storage request = redeemRequests[requestId];
        if (
            request.controller != controller ||
            request.fulfilled ||
            request.canceled
        ) {
            return 0;
        }
        return request.shares;
    }

    function pendingCancelRedeemRequest(
        uint256 requestId,
        address controller
    ) external view returns (bool) {
        RedeemRequestStruct storage request = redeemRequests[requestId];
        return
            request.controller == controller && pendingCancelRedeem[requestId];
    }

    // Cancel Operations
    function cancelDepositRequest(
        uint256 requestId,
        address controller
    ) external {
        require(
            msg.sender == controller || operators[controller][msg.sender],
            "Not authorized"
        );
        DepositRequestStruct storage request = depositRequests[requestId];
        require(
            request.controller == controller && !request.fulfilled,
            "Invalid request"
        );

        pendingCancelDeposit[requestId] = true;
    }

    function claimCancelDepositRequest(
        uint256 requestId,
        address receiver,
        address controller
    ) external returns (uint256 assets) {
        DepositRequestStruct storage request = depositRequests[requestId];

        assets = request.assets;
        request.canceled = true;
        pendingCancelDeposit[requestId] = false;

        asset.transfer(receiver, assets);
    }

    function cancelRedeemRequest(
        uint256 requestId,
        address controller
    ) external {
        RedeemRequestStruct storage request = redeemRequests[requestId];

        pendingCancelRedeem[requestId] = true;
    }

    function claimCancelRedeemRequest(
        uint256 requestId,
        address receiver,
        address controller
    ) external returns (uint256 shares) {
        RedeemRequestStruct storage request = redeemRequests[requestId];

        shares = request.shares;
        request.canceled = true;
        pendingCancelRedeem[requestId] = false;

        _mint(receiver, shares);
    }

    // Placeholder functions for Centrifuge compatibility
    function poolId() external pure returns (uint64) {
        return 1;
    }

    function trancheId() external pure returns (bytes16) {
        return bytes16(uint128(1));
    }

    // Yield simulation functions (similar to MockERC4626Tester)
    // Primary way that 7540 vaults receive losses is on rounding in redemptions so we just simulate a loss that reduces total asset balance
    function increaseYield(uint256 increasePercentageFP4) external {
        uint256 amount = (totalAssets() * increasePercentageFP4) / MAX_BPS;
        MockERC20(asset).transferFrom(msg.sender, address(this), amount);
    }

    function decreaseYield(uint256 decreasePercentageFP4) external {
        uint256 amount = (totalAssets() * decreasePercentageFP4) / MAX_BPS;
        MockERC20(asset).transfer(address(0xbeef), amount);
    }

    function simulateGain(uint256 gainAmount) external {
        MockERC20(asset).transferFrom(msg.sender, address(this), gainAmount);
        totalGains += gainAmount;
    }

    function simulateLoss(uint256 lossAmount) external {
        MockERC20(asset).transfer(address(0xbeef), lossAmount);
        totalLosses += lossAmount;
    }

    /// @dev Set the loss on withdraw as percentage of the assets being withdrawn
    function setLossOnWithdraw(uint256 _lossOnWithdraw) public {
        _lossOnWithdraw %= MAX_BPS + 1; // clamp to ensure we set a max of 100%
        lossOnWithdraw = _lossOnWithdraw;
    }

    /// @notice ERC165 interface detection
    function supportsInterface(
        bytes4 interfaceId
    ) external pure override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}


10.0% test/recon/mocks/MockERC7540YieldSourceOracle.sol

Lines covered: 6 / 60 (10.0%)

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.30;

import {IERC20Metadata} from "@openzeppelin/contracts/interfaces/IERC20Metadata.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IYieldSourceOracle} from "@superform-v2-core/src/interfaces/accounting/IYieldSourceOracle.sol";
import {MockERC7540Tester} from "./MockERC7540Tester.sol";

/// @title MockERC7540YieldSourceOracle
/// @notice Mock oracle for ERC7540 (Asynchronous Tokenized Vaults) in testing
contract MockERC7540YieldSourceOracle is IYieldSourceOracle {
    mapping(address => bool) public validAssetMap;
    
    function setValidAsset(address asset, bool isValid) external {
        validAssetMap[asset] = isValid;
    }
    
    function decimals(address yieldSourceAddress) external view returns (uint8) {
        address share = MockERC7540Tester(yieldSourceAddress).share();
        return IERC20Metadata(share).decimals();
    }
    
    function getShareOutput(
        address yieldSourceAddress,
        address,
        uint256 assetsIn
    ) external view returns (uint256) {
        return MockERC7540Tester(yieldSourceAddress).convertToShares(assetsIn);
    }
    
    function getAssetOutput(
        address yieldSourceAddress,
        address,
        uint256 sharesIn
    ) public view returns (uint256) {
        return MockERC7540Tester(yieldSourceAddress).convertToAssets(sharesIn);
    }
    
    function getPricePerShare(address yieldSourceAddress) external view returns (uint256) {
        address share = MockERC7540Tester(yieldSourceAddress).share();
        uint256 _decimals = IERC20Metadata(share).decimals();
        return MockERC7540Tester(yieldSourceAddress).convertToAssets(10 ** _decimals);
    }
    
    function getBalanceOfOwner(
        address yieldSourceAddress,
        address ownerOfShares
    ) external view returns (uint256) {
        return IERC20(MockERC7540Tester(yieldSourceAddress).share()).balanceOf(ownerOfShares);
    }
    
    function getTVLByOwnerOfShares(
        address yieldSourceAddress,
        address ownerOfShares
    ) external view returns (uint256) {
        address share = MockERC7540Tester(yieldSourceAddress).share();
        uint256 shares = IERC20(share).balanceOf(ownerOfShares);
        return MockERC7540Tester(yieldSourceAddress).convertToAssets(shares);
    }
    
    function getTVL(address yieldSourceAddress) external view returns (uint256) {
        return MockERC7540Tester(yieldSourceAddress).totalAssets();
    }
    
    function getPricePerShareMultiple(
        address[] memory yieldSourceAddresses
    ) external view returns (uint256[] memory) {
        uint256[] memory prices = new uint256[](yieldSourceAddresses.length);
        for (uint256 i = 0; i < yieldSourceAddresses.length; i++) {
            address share = MockERC7540Tester(yieldSourceAddresses[i]).share();
            uint256 _decimals = IERC20Metadata(share).decimals();
            prices[i] = MockERC7540Tester(yieldSourceAddresses[i]).convertToAssets(10 ** _decimals);
        }
        return prices;
    }
    
    function getTVLByOwnerOfSharesMultiple(
        address[] memory yieldSourceAddresses,
        address[][] memory ownersOfShares
    ) external view returns (uint256[][] memory) {
        uint256[][] memory result = new uint256[][](yieldSourceAddresses.length);
        for (uint256 i = 0; i < yieldSourceAddresses.length; i++) {
            result[i] = new uint256[](ownersOfShares[i].length);
            address share = MockERC7540Tester(yieldSourceAddresses[i]).share();
            for (uint256 j = 0; j < ownersOfShares[i].length; j++) {
                uint256 shares = IERC20(share).balanceOf(ownersOfShares[i][j]);
                result[i][j] = MockERC7540Tester(yieldSourceAddresses[i]).convertToAssets(shares);
            }
        }
        return result;
    }
    
    function getTVLMultiple(
        address[] memory yieldSourceAddresses
    ) external view returns (uint256[] memory) {
        uint256[] memory tvls = new uint256[](yieldSourceAddresses.length);
        for (uint256 i = 0; i < yieldSourceAddresses.length; i++) {
            tvls[i] = MockERC7540Tester(yieldSourceAddresses[i]).totalAssets();
        }
        return tvls;
    }
    
    function isValidUnderlyingAsset(address, address asset) external view returns (bool) {
        return validAssetMap[asset];
    }
    
    function isValidUnderlyingAssets(
        address[] memory,
        address[] memory assets
    ) external view returns (bool[] memory) {
        bool[] memory validities = new bool[](assets.length);
        for (uint256 i = 0; i < assets.length; i++) {
            validities[i] = validAssetMap[assets[i]];
        }
        return validities;
    }
    
    function getAssetOutputWithFees(
        bytes32,
        address yieldSourceAddress,
        address,
        address,
        uint256 sharesIn
    ) external view returns (uint256) {
        return MockERC7540Tester(yieldSourceAddress).convertToAssets(sharesIn);
    }
}

96.0% test/recon/targets/AdminTargets.sol

Lines covered: 196 / 203 (96.0%)

// SPDX-License-Identifier: GPL-2.0
pragma solidity ^0.8.0;

// External dependencies
import {BaseTargetFunctions} from "@chimera/BaseTargetFunctions.sol";
import {vm} from "@chimera/Hevm.sol";
import {Panic} from "@recon/Panic.sol";
import {MockERC20} from "@recon/MockERC20.sol";

// System dependencies
import {ISuperVaultStrategy} from "src/interfaces/SuperVault/ISuperVaultStrategy.sol";
import {IERC4626} from "@openzeppelin/contracts/interfaces/IERC4626.sol";

// Test dependencies
import {YieldSourceType} from "test/recon/managers/YieldManager.sol";
import {BeforeAfter, OpType} from "../BeforeAfter.sol";
import {Properties} from "../Properties.sol";

abstract contract AdminTargets is BaseTargetFunctions, Properties {
    enum HookType {
        // ERC4626 Hooks
        ApproveAndDeposit4626,
        Deposit4626,
        Redeem4626,
        // ERC5115 Hooks
        ApproveAndDeposit5115,
        Deposit5115,
        Redeem5115,
        // ERC7540 Hooks
        Deposit7540,
        Redeem7540,
        RequestDeposit7540,
        RequestRedeem7540,
        ApproveAndRequestDeposit7540,
        CancelDepositRequest7540,
        CancelRedeemRequest7540,
        ClaimCancelDepositRequest7540,
        ClaimCancelRedeemRequest7540,
        Withdraw7540,
        // Super Vault Hooks
        CancelRedeem,
        SuperVaultWithdraw7540
    }

    /// CUSTOM TARGET FUNCTIONS - Add your own target functions here ///
    function superVaultStrategy_executeHooks_clamped(
        uint256[] memory hookTypeInts,
        uint256[] memory amountsToInvest,
        bool[] memory usePrevHookAmounts
    ) public payable {
        // Limit the number of hooks to 10 maximum
        uint256 numHooks = hookTypeInts.length;
        if (numHooks > 10) {
            numHooks = 10;
        }

        // Ensure all arrays have the same length
        if (amountsToInvest.length < numHooks) {
            numHooks = amountsToInvest.length;
        }
        if (usePrevHookAmounts.length < numHooks) {
            numHooks = usePrevHookAmounts.length;
        }

        // Return early if no hooks to execute
        if (numHooks == 0) {
            return;
        }

        // Create ExecuteArgs for the hooks
        ISuperVaultStrategy.ExecuteArgs memory executeArgs = ISuperVaultStrategy
            .ExecuteArgs({
                hooks: new address[](numHooks),
                hookCalldata: new bytes[](numHooks),
                expectedAssetsOrSharesOut: new uint256[](numHooks),
                globalProofs: new bytes32[][](numHooks),
                strategyProofs: new bytes32[][](numHooks)
            });

        // Process each hook
        uint256 totalAmountToDeposit;
        for (uint256 i = 0; i < numHooks; i++) {
            // Convert integer to enum (will wrap around if > max enum value)
            HookType hookType = HookType(hookTypeInts[i] % 17); // 17 is the total number of hooks

            // Clamp to the strategy's asset balance (not SuperVault's balance)
            uint256 clampedAmount = amountsToInvest[i] %
                (MockERC20(superVault.asset()).balanceOf(
                    address(superVaultStrategy)
                ) + 1);

            // Get the hook address and calldata
            (
                address hookAddress,
                bytes memory hookCalldata
            ) = _getHookAddressAndCalldata(
                    hookType,
                    clampedAmount,
                    usePrevHookAmounts[i]
                );

            executeArgs.hooks[i] = hookAddress;
            executeArgs.hookCalldata[i] = hookCalldata;
            executeArgs.expectedAssetsOrSharesOut[i] = clampedAmount;
            executeArgs.globalProofs[i] = new bytes32[](1);
            executeArgs.strategyProofs[i] = new bytes32[](1);

            totalAmountToDeposit += clampedAmount;
        }

        // Check that amount to be invested is less than the claimable assets so that it doesn't reinvest and prevent users from claiming
        if (_claimableMoreThanInvested(totalAmountToDeposit)) return;

        // Execute all hooks
        this.superVaultStrategy_executeHooks{value: msg.value}(executeArgs);
    }

    function _getHookAddressAndCalldata(
        HookType hookType,
        uint256 amountToInvest,
        bool usePrevHookAmount
    ) internal view returns (address hookAddress, bytes memory hookCalldata) {
        if (hookType == HookType.ApproveAndDeposit4626) {
            hookAddress = address(approveAndDeposit4626Hook);
            hookCalldata = abi.encodePacked(
                bytes32(0), // yieldSourceOracleId placeholder
                _getYieldSource(), // Address of the yield source
                superVault.asset(), // Address of the token to approve and deposit
                amountToInvest, // Amount to deposit
                usePrevHookAmount
            );
        } else if (hookType == HookType.Deposit4626) {
            hookAddress = address(deposit4626Hook);
            hookCalldata = abi.encodePacked(
                bytes32(0), // yieldSourceOracleId placeholder
                _getYieldSource(), // Address of the yield source
                amountToInvest, // Amount to deposit
                usePrevHookAmount
            );
        } else if (hookType == HookType.Redeem4626) {
            hookAddress = address(redeem4626Hook);
            hookCalldata = abi.encodePacked(
                bytes32(0), // yieldSourceOracleId placeholder
                _getYieldSource(), // Address of the yield source
                amountToInvest, // Amount to redeem
                address(superVaultStrategy), // Receiver
                address(superVaultStrategy) // Owner
            );
        } else if (hookType == HookType.ApproveAndDeposit5115) {
            hookAddress = address(approveAndDeposit5115Hook);
            hookCalldata = abi.encodePacked(
                bytes32(0), // yieldSourceOracleId placeholder
                _getYieldSource(), // Address of the yield source
                superVault.asset(), // Address of the token to approve and deposit
                bytes32(0), // tokenId (for ERC5115)
                amountToInvest, // Amount to deposit
                usePrevHookAmount
            );
        } else if (hookType == HookType.Deposit5115) {
            hookAddress = address(deposit5115Hook);
            hookCalldata = abi.encodePacked(
                bytes32(0), // yieldSourceOracleId placeholder
                _getYieldSource(), // Address of the yield source
                bytes32(0), // tokenId (for ERC5115)
                amountToInvest, // Amount to deposit
                usePrevHookAmount
            );
        } else if (hookType == HookType.Redeem5115) {
            hookAddress = address(redeem5115Hook);
            hookCalldata = abi.encodePacked(
                bytes32(0), // yieldSourceOracleId placeholder
                _getYieldSource(), // Address of the yield source
                bytes32(0), // tokenId (for ERC5115)
                amountToInvest, // Amount to redeem
                address(superVaultStrategy), // Receiver
                address(superVaultStrategy) // Owner
            );
        } else if (hookType == HookType.Deposit7540) {
            hookAddress = address(deposit7540Hook);
            hookCalldata = abi.encodePacked(
                bytes32(0), // yieldSourceOracleId placeholder
                _getYieldSource(), // Address of the yield source
                amountToInvest, // Amount to deposit
                address(superVaultStrategy), // Receiver
                address(superVaultStrategy) // Controller
            );
        } else if (hookType == HookType.Redeem7540) {
            hookAddress = address(redeem7540Hook);
            hookCalldata = abi.encodePacked(
                bytes32(0), // yieldSourceOracleId placeholder
                _getYieldSource(), // Address of the yield source
                amountToInvest, // Amount to redeem
                address(superVaultStrategy), // Receiver
                address(superVaultStrategy), // Owner
                address(superVaultStrategy) // Controller
            );
        } else if (hookType == HookType.RequestDeposit7540) {
            hookAddress = address(requestDeposit7540Hook);
            hookCalldata = abi.encodePacked(
                bytes32(0), // yieldSourceOracleId placeholder
                _getYieldSource(), // Address of the yield source
                amountToInvest, // Amount to request deposit
                address(superVaultStrategy), // Owner
                address(superVaultStrategy) // Controller
            );
        } else if (hookType == HookType.RequestRedeem7540) {
            hookAddress = address(requestRedeem7540Hook);
            hookCalldata = abi.encodePacked(
                bytes32(0), // yieldSourceOracleId placeholder
                _getYieldSource(), // Address of the yield source
                amountToInvest, // Amount to request redeem
                address(superVaultStrategy), // Owner
                address(superVaultStrategy) // Controller
            );
        } else if (hookType == HookType.ApproveAndRequestDeposit7540) {
            hookAddress = address(approveAndRequestDeposit7540Hook);
            hookCalldata = abi.encodePacked(
                bytes32(0), // yieldSourceOracleId placeholder
                _getYieldSource(), // Address of the yield source
                superVault.asset(), // Address of the token to approve
                amountToInvest, // Amount to request deposit
                address(superVaultStrategy), // Owner
                address(superVaultStrategy) // Controller
            );
        } else if (hookType == HookType.CancelDepositRequest7540) {
            hookAddress = address(cancelDepositRequest7540Hook);
            hookCalldata = abi.encodePacked(
                bytes32(0), // yieldSourceOracleId placeholder
                _getYieldSource(), // Address of the yield source
                address(superVaultStrategy) // Controller
            );
        } else if (hookType == HookType.CancelRedeemRequest7540) {
            hookAddress = address(cancelRedeemRequest7540Hook);
            hookCalldata = abi.encodePacked(
                bytes32(0), // yieldSourceOracleId placeholder
                _getYieldSource(), // Address of the yield source
                address(superVaultStrategy) // Controller
            );
        } else if (hookType == HookType.ClaimCancelDepositRequest7540) {
            hookAddress = address(claimCancelDepositRequest7540Hook);
            hookCalldata = abi.encodePacked(
                bytes32(0), // yieldSourceOracleId placeholder
                _getYieldSource(), // Address of the yield source
                address(superVaultStrategy), // Receiver
                address(superVaultStrategy) // Controller
            );
        } else if (hookType == HookType.ClaimCancelRedeemRequest7540) {
            hookAddress = address(claimCancelRedeemRequest7540Hook);
            hookCalldata = abi.encodePacked(
                bytes32(0), // yieldSourceOracleId placeholder
                _getYieldSource(), // Address of the yield source
                address(superVaultStrategy), // Receiver
                address(superVaultStrategy) // Controller
            );
        } else if (hookType == HookType.Withdraw7540) {
            hookAddress = address(withdraw7540Hook);
            hookCalldata = abi.encodePacked(
                bytes32(0), // yieldSourceOracleId placeholder
                _getYieldSource(), // Address of the yield source
                amountToInvest, // Amount to withdraw
                address(superVaultStrategy), // Receiver
                address(superVaultStrategy), // Owner
                address(superVaultStrategy) // Controller
            );
        } else if (hookType == HookType.CancelRedeem) {
            hookAddress = address(cancelRedeemHook);
            hookCalldata = abi.encodePacked(
                bytes32(0), // yieldSourceOracleId placeholder
                _getYieldSource(), // Address of the yield source
                address(superVaultStrategy) // Controller
            );
        } else if (hookType == HookType.SuperVaultWithdraw7540) {
            hookAddress = address(superVaultWithdraw7540Hook);
            hookCalldata = abi.encodePacked(
                bytes32(0), // yieldSourceOracleId placeholder
                _getYieldSource(), // Address of the yield source
                amountToInvest, // Amount to withdraw
                address(superVaultStrategy), // Receiver
                address(superVaultStrategy), // Owner
                address(superVaultStrategy) // Controller
            );
        }
    }

    function superVaultStrategy_fulfillRedeemRequests_clamped(
        uint256 redeemAmount
    ) public {
        // Find a controller that has pending redeem requests
        address selectedController = _getActor();
        uint256 pendingAmount = superVaultStrategy.pendingRedeemRequest(
            selectedController
        );

        // Clamp using the actor's pending amount
        uint256 actualRedeemAmount = redeemAmount % (pendingAmount + 1);

        address[] memory controllers = new address[](1);
        controllers[0] = selectedController;

        // Determine yield source type from currently active yield source
        YieldSourceType activeYieldSourceType = _getYieldSourceTypeFromAddress(
            _getYieldSource()
        );
        address redeemHook = _getRedeemHookForType(activeYieldSourceType);

        // Create realistic hook calldata for redeem operation
        bytes memory redeemHookCalldata;

        if (
            activeYieldSourceType == YieldSourceType.ERC4626 ||
            activeYieldSourceType == YieldSourceType.ERC5115
        ) {
            // ERC4626/ERC5115 Layout: bytes32 oracleId, address yieldSource, address owner, uint256 shares, bool usePrevAmount
            redeemHookCalldata = abi.encodePacked(
                bytes32(0), // yieldSourceOracleId placeholder
                _getYieldSource(), // Current active yield source
                address(superVaultStrategy), // Owner (strategy owns the yield source shares)
                actualRedeemAmount, // Amount to redeem (matches controller's pending request)
                false // Don't use previous hook amount
            );
        } else {
            // ERC7540 Layout: bytes32 oracleId, address yieldSource, uint256 shares, bool usePrevAmount
            redeemHookCalldata = abi.encodePacked(
                bytes32(0), // yieldSourceOracleId placeholder
                _getYieldSource(), // Current active yield source
                actualRedeemAmount, // Amount to redeem (matches controller's pending request)
                false // Don't use previous hook amount
            );
        }

        // Create arrays for FulfillArgs
        address[] memory hooks = new address[](1);
        hooks[0] = redeemHook;

        bytes[] memory hookCalldata = new bytes[](1);
        hookCalldata[0] = redeemHookCalldata;

        uint256[] memory expectedAssetsOrSharesOut = new uint256[](1);
        expectedAssetsOrSharesOut[0] = 1; // @audit Allow max losse amount matching the actual redeem

        bytes32[][] memory globalProofs = new bytes32[][](1);
        globalProofs[0] = new bytes32[](0); // Empty proof for UnsafeSuperVaultAggregator

        bytes32[][] memory strategyProofs = new bytes32[][](1);
        strategyProofs[0] = new bytes32[](0); // Empty proof

        // Create the FulfillArgs struct
        ISuperVaultStrategy.FulfillArgs memory fulfillArgs = ISuperVaultStrategy
            .FulfillArgs({
                controllers: controllers,
                hooks: hooks,
                hookCalldata: hookCalldata,
                expectedAssetsOrSharesOut: expectedAssetsOrSharesOut,
                globalProofs: globalProofs,
                strategyProofs: strategyProofs
            });

        // Execute the function
        superVaultStrategy_fulfillRedeemRequests_ASSERTION_STRATEGY_NO_LOSS_ON_FULFILLMENT(fulfillArgs);
    }

    /// AUTO GENERATED TARGET FUNCTIONS - WARNING: DO NOT DELETE OR MODIFY THIS LINE ///

    function superVaultStrategy_executeHooks(
        ISuperVaultStrategy.ExecuteArgs memory args
    ) public payable asAdmin {
        superVaultStrategy.executeHooks{value: msg.value}(args);

        executeHooksSuccess = true;
    }

    /// @dev Property: superVaultStrategy does not incur loss on fulfillment
    function superVaultStrategy_fulfillRedeemRequests_ASSERTION_STRATEGY_NO_LOSS_ON_FULFILLMENT(
        ISuperVaultStrategy.FulfillArgs memory args
    ) public updateGhostsWithOpType(OpType.FULFILL) {
        uint256 summedExpectedAssets;
        for (uint256 i; i < args.expectedAssetsOrSharesOut.length; i++) {
            summedExpectedAssets += args.expectedAssetsOrSharesOut[i];
        }

        // no need to prank because called as admin address(this)
        superVaultStrategy.fulfillRedeemRequests(args);

        uint256 assetBalanceAfter = MockERC20(superVault.asset()).balanceOf(
            address(superVaultStrategy)
        );

        gte(
            assetBalanceAfter,
            summedExpectedAssets,
            ASSERTION_STRATEGY_NO_LOSS_ON_FULFILLMENT
        );
    }

    // Functions that require SuperGovernor access
    /// @dev removed because we're bypassing hook validation
    // function superVaultAggregator_setHooksRootUpdateTimelock(
    //     uint256 newTimelock
    // ) public asAdmin {
    //     superVaultAggregator.setHooksRootUpdateTimelock(newTimelock);
    // }

    /// @dev removed because we're bypassing hook validation
    // function superVaultAggregator_proposeGlobalHooksRoot(
    //     bytes32 newRoot
    // ) public asAdmin {
    //     superVaultAggregator.proposeGlobalHooksRoot(newRoot);
    // }

    /// @dev removed because we're bypassing hook validation
    // function superVaultAggregator_executeGlobalHooksRootUpdate()
    //     public
    //     asAdmin
    // {
    //     superVaultAggregator.executeGlobalHooksRootUpdate();
    // }

    /// @dev removed because we're bypassing hook validation
    // function superVaultAggregator_setGlobalHooksRootVetoStatus(
    //     bool vetoed
    // ) public asAdmin {
    //     superVaultAggregator.setGlobalHooksRootVetoStatus(vetoed);
    // }

    /// @dev removed because we're bypassing hook validation
    // function superVaultAggregator_setStrategyHooksRootVetoStatus(
    //     address strategy,
    //     bool vetoed
    // ) public asAdmin {
    //     superVaultAggregator.setStrategyHooksRootVetoStatus(strategy, vetoed);
    // }

    function superVaultAggregator_changePrimaryManager(
        address strategy,
        address newManager
    ) public asAdmin {
        superVaultAggregator.changePrimaryManager(strategy, newManager);
    }

    /// @dev won't achieve coverage until issue outlined here is resolved: https://github.com/Recon-Fuzz/superform-review/issues/5
    function superVaultAggregator_slashStake(
        address manager,
        uint256 amount
    ) public asAdmin {
        superVaultAggregator.slashStake(manager, amount);
    }

    /// Helpers

    function _requestedSharesForControllers(
        address[] memory controllers
    ) internal returns (uint256) {
        uint256 totalRequested;
        for (uint256 i; i < controllers.length; i++) {
            totalRequested += superVault.pendingRedeemRequest(
                0,
                controllers[i]
            );
        }

        return totalRequested;
    }

    function _sumSuperVaultValsForControllers(
        address[] memory controllers
    )
        internal
        view
        returns (uint256 sumAccumulatorShares, uint256 sumAccumulatorCostBasis)
    {
        for (uint256 i; i < controllers.length; i++) {
            sumAccumulatorShares += superVaultStrategy
                .getSuperVaultState(controllers[i])
                .accumulatorShares;
            sumAccumulatorCostBasis += superVaultStrategy
                .getSuperVaultState(controllers[i])
                .accumulatorCostBasis;
        }
    }

    function _claimableMoreThanInvested(
        uint256 totalAmountToDeposit
    ) internal returns (bool) {
        address[] memory actors = _getActors();
        uint256 totalClaimable;
        for (uint256 i; i < actors.length; i++) {
            uint256 claimableRedemptions = superVault.claimableRedeemRequest(
                0,
                actors[i]
            );
            uint256 claimableRedemptionsAsAssets = superVault.convertToAssets(
                claimableRedemptions
            );
            totalClaimable += claimableRedemptionsAsAssets;
        }

        uint256 currentStrategyBalance = MockERC20(superVault.asset())
            .balanceOf(address(superVaultStrategy));

        // Don't allow investing more than the claimable amount
        if (totalAmountToDeposit > totalClaimable) {
            return true;
        }

        // Ensure strategy has sufficient assets remaining after investment to cover claimable amounts
        uint256 remainingStrategyBalance = currentStrategyBalance -
            totalAmountToDeposit;
        if (remainingStrategyBalance < totalClaimable) {
            return true;
        }

        return false;
    }
}


89.0% test/recon/targets/DoomsdayTargets.sol

Lines covered: 336 / 375 (89.0%)

// SPDX-License-Identifier: GPL-2.0
pragma solidity ^0.8.0;

import {BaseTargetFunctions} from "@chimera/BaseTargetFunctions.sol";
import {vm} from "@chimera/Hevm.sol";
import {Panic} from "@recon/Panic.sol";
import {MockERC20} from "@recon/MockERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

import {BeforeAfter} from "../BeforeAfter.sol";
import {Properties} from "../Properties.sol";
import {ISuperVaultStrategy} from "src/interfaces/SuperVault/ISuperVaultStrategy.sol";
import {YieldSourceType} from "test/recon/managers/YieldManager.sol";
import {MockERC4626Tester} from "test/recon/mocks/MockERC4626Tester.sol";
import {MockERC5115Tester} from "test/recon/mocks/MockERC5115Tester.sol";
import {MockERC7540Tester} from "test/recon/mocks/MockERC7540Tester.sol";

abstract contract DoomsdayTargets is BaseTargetFunctions, Properties {
    /// @dev Property: previewDeposit and deposit equivalence
    function doomsday_previewDepositEquivalence_ASSERTION_PREVIEW_DEPOSIT_EQUIVALENCE(
        uint256 assets
    ) public stateless {
        uint256 previewDepositShares = superVault.previewDeposit(assets);

        vm.prank(_getActor());
        uint256 sharesActualDeposit = superVault.deposit(assets, _getActor());

        eq(
            previewDepositShares,
            sharesActualDeposit,
            ASSERTION_PREVIEW_DEPOSIT_EQUIVALENCE
        );
    }

    /// @dev Property: previewMint and mint equivalence
    function doomsday_previewMintEquivalence_ASSERTION_PREVIEW_MINT_EQUIVALENCE(uint256 shares) public stateless {
        uint256 previewMintAssets = superVault.previewMint(shares);

        vm.prank(_getActor());
        uint256 assetsActualMint = superVault.mint(shares, _getActor());

        eq(
            previewMintAssets,
            assetsActualMint,
            ASSERTION_PREVIEW_MINT_EQUIVALENCE
        );
    }

    /// @dev Property: mint/redeem doesn't cause loss to user
    function doomsday_mintRedeemSymmetrical_ASSERTION_MINT_REDEEM_SYMMETRICAL(
        uint256 sharesToMint
    ) public stateless {
        // skip if there's been any gain because it complicates the assertion checking
        // NOTE: removed because was previously checking that user doesn't gain only from minting/redeeming
        // if (MockERC4626Tester(_getYieldSource()).totalGains() > 0) {
        //     return;
        // }
        address asset = superVault.asset();
        uint256 balanceBefore = MockERC20(asset).balanceOf(_getActor());
        uint256 feeRecipientBalanceBefore = MockERC20(asset).balanceOf(
            feeRecipient
        );

        // 1. Mint
        vm.prank(_getActor());
        uint256 assetsUsed = superVault.mint(sharesToMint, _getActor());

        // 2. Deposit assets into yield strategy via executeHooks
        // This is needed because the user's assets are currently in the strategy contract
        // but not yet deposited into the underlying yield source
        uint256 strategyAssetBalance = MockERC20(asset).balanceOf(
            address(superVaultStrategy)
        );
        if (strategyAssetBalance > 0) {
            ISuperVaultStrategy.ExecuteArgs
                memory depositArgs = _createExecuteDepositArgs(
                    strategyAssetBalance
                );

            superVaultStrategy.executeHooks(depositArgs);
        }

        // 3. Request Redemption
        uint256 userShares = superVault.balanceOf(_getActor());
        // get shares of strategy in the deposited yield source
        uint256 shares = _getSuperVaultStrategyShares();

        vm.prank(_getActor());
        superVault.requestRedeem(shares, _getActor(), _getActor());

        uint256 feeBalanceBefore = MockERC20(superVault.asset()).balanceOf(
            feeRecipient
        );

        // 4. Fulfill Redemption from yield strategy
        // Now we need to redeem from the yield strategy to get assets back
        ISuperVaultStrategy.FulfillArgs
            memory fulfillArgs = _createFulfillRedeemFromStrategyArgs(shares);

        // called by admin address(this)
        superVaultStrategy.fulfillRedeemRequests(fulfillArgs);

        // 5. Claim Redemption
        uint256 sharesToRedeem = superVault.maxRedeem(_getActor());

        vm.prank(_getActor());
        superVault.redeem(sharesToRedeem, _getActor(), _getActor());

        uint256 balanceAfter = MockERC20(asset).balanceOf(_getActor());

        uint256 TOLERANCE = 10; // 10 wei max tolerance of assets lost

        uint256 feeRecipientBalanceAfter = MockERC20(superVault.asset())
            .balanceOf(feeRecipient);
        uint256 feeDelta = feeRecipientBalanceAfter - feeRecipientBalanceBefore;

        // 6. Check that user didn't lose assets
        gte(
            balanceAfter + TOLERANCE + feeDelta,
            balanceBefore,
            ASSERTION_MINT_REDEEM_SYMMETRICAL
        );
    }

    /// @dev Property: deposit/withdraw doesn't cause loss to user
    function doomsday_depositWithdrawSymmetrical_ASSERTION_DEPOSIT_WITHDRAW_SYMMETRICAL(
        uint256 assetsToDeposit
    ) public stateless returns (uint256, uint256) {
        // skip if there's been any gain because it complicates the assertion checking
        // NOTE: removed because was previously checking that user doesn't gain only from minting/redeeming
        // if (MockERC4626Tester(_getYieldSource()).totalGains() > 0) {
        //     return;
        // }
        address asset = superVault.asset();
        uint256 balanceBefore = MockERC20(asset).balanceOf(_getActor());

        // 1. Deposit
        vm.prank(_getActor());
        superVault.deposit(assetsToDeposit, _getActor());

        // 2. Request Withdrawal (through redemption in ERC7540)
        uint256 shares = superVault.balanceOf(_getActor());
        vm.prank(_getActor());
        superVault.requestRedeem(shares, _getActor(), _getActor());

        // 3. Fulfill Withdrawal
        ISuperVaultStrategy.FulfillArgs
            memory fulfillArgs = _createFulfillRedeemArgs(shares);
        // fulfills as admin (address(this))
        superVaultStrategy.fulfillRedeemRequests(fulfillArgs);

        // 4. Claim Withdrawal
        uint256 withdrawableAssets = superVault.maxWithdraw(_getActor());
        vm.prank(_getActor());
        superVault.withdraw(withdrawableAssets, _getActor(), _getActor());

        uint256 balanceAfter = MockERC20(asset).balanceOf(_getActor());

        uint256 TOLERANCE = 10; // 10 wei max tolerance of assets lost
        // 5. Check that user didn't lose assets
        gte(
            balanceAfter + TOLERANCE,
            balanceBefore,
            ASSERTION_DEPOSIT_WITHDRAW_SYMMETRICAL
        );

        return (balanceAfter, balanceBefore);
    }

    /// @dev Property: maxRedeem is reset to 0 after full redemption
    /// @dev Property: redeeming maxRedeem shouldn't revert
    function doomsday_maxRedeemResetsAfterFullRedemption_ASSERTION_MAX_REDEEM_RESETS_AFTER_FULL_REDEMPTION(
        uint256 sharesToMint
    ) public stateless {
        // 1. Deposit to get shares
        vm.prank(_getActor());
        superVault.mint(sharesToMint, _getActor());

        // redeem all user shares
        uint256 shares = superVault.balanceOf(_getActor());

        // 2. Request full redemption
        vm.prank(_getActor());
        superVault.requestRedeem(shares, _getActor(), _getActor());

        // 3. Fulfill the redemption request
        ISuperVaultStrategy.FulfillArgs
            memory fulfillArgs = _createFulfillRedeemArgs(shares);
        // fulfill as address(this)
        superVaultStrategy.fulfillRedeemRequests(fulfillArgs);

        // 4. Check maxRedeem before claiming
        uint256 maxRedeemBeforeClaim = superVault.maxRedeem(_getActor());

        // 5. Claim the full redemption
        vm.prank(_getActor());
        try superVault.redeem(maxRedeemBeforeClaim, _getActor(), _getActor()) {
            // 6. Check maxRedeem is reset to 0 after full redemption
            uint256 maxRedeemAfterClaim = superVault.maxRedeem(_getActor());
            eq(
                maxRedeemAfterClaim,
                0,
                ASSERTION_MAX_REDEEM_RESETS_AFTER_FULL_REDEMPTION
            );
        } catch {
            if (maxRedeemBeforeClaim > 0) {
                t(false, ASSERTION_MAX_REDEEM_RESETS_AFTER_FULL_REDEMPTION);
            }
        }
    }

    /// @dev Property: maxWithdraw is reset to 0 after full withdrawal
    function doomsday_maxWithdrawResetsAfterFullWithdrawal_ASSERTION_MAX_WITHDRAW_RESETS_AFTER_FULL_WITHDRAWAL(
        uint256 assetsToDeposit
    ) public stateless {
        // 1. Deposit to get shares
        vm.prank(_getActor());
        superVault.deposit(assetsToDeposit, _getActor());

        uint256 shares = superVault.balanceOf(_getActor());

        // 2. Request redemption of all shares
        vm.prank(_getActor());
        superVault.requestRedeem(shares, _getActor(), _getActor());

        // 3. Fulfill the redemption request
        ISuperVaultStrategy.FulfillArgs
            memory fulfillArgs = _createFulfillRedeemArgs(shares);
        // called as admin address(this)
        superVaultStrategy.fulfillRedeemRequests(fulfillArgs);

        // 4. Check maxWithdraw after fulfillment and use that value
        uint256 maxWithdrawBefore = superVault.maxWithdraw(_getActor());

        // 5. Withdraw the exact amount returned by maxWithdraw
        vm.prank(_getActor());
        try superVault.withdraw(maxWithdrawBefore, _getActor(), _getActor()) {
            // 6. Check maxWithdraw is reset to 0 after full withdrawal
            uint256 maxWithdrawAfter = superVault.maxWithdraw(_getActor());
            eq(
                maxWithdrawAfter,
                0,
                ASSERTION_MAX_WITHDRAW_RESETS_AFTER_FULL_WITHDRAWAL
            );
        } catch {
            t(false, ASSERTION_MAX_WITHDRAW_RESETS_AFTER_FULL_WITHDRAWAL);
        }
    }

    /// @dev Property: fulfillRedeemRequests doesn't redeem more than requested for multiple actors
    function doomsday_fulfillDoesntOverRedeemMultipleActors_ASSERTION_FULFILL_DOESNT_OVER_REDEEM_MULTIPLE_ACTORS(
        uint256[3] memory sharesToMint,
        uint256[3] memory actorIndexes
    ) public stateless {
        address[] memory actors = _getActors();
        if (actors.length < 3) return; // Need at least 3 actors for this test

        // Arrays to track actors and their requests
        address[] memory testActors = new address[](3);
        uint256[] memory requestedShares = new uint256[](3);
        uint256[] memory sharesBefore = new uint256[](3);

        // 1. Setup: Each actor deposits and requests redemption
        uint256 totalRequestedShares;
        for (uint256 i = 0; i < 3; i++) {
            // Get unique actor
            testActors[i] = actors[actorIndexes[i] % actors.length];

            // Mint shares for this actor
            if (sharesToMint[i] > 0) {
                vm.prank(testActors[i]);
                superVault.mint(sharesToMint[i], testActors[i]);
            }

            // Get actual share balance
            sharesBefore[i] = superVault.maxRedeem(testActors[i]);
            requestedShares[i] = sharesBefore[i];

            // Request redemption of all shares
            if (requestedShares[i] > 0) {
                vm.prank(testActors[i]);
                superVault.requestRedeem(
                    requestedShares[i],
                    testActors[i],
                    testActors[i]
                );
            }
            totalRequestedShares += requestedShares[i];
        }

        // 2. Create multi-actor FulfillArgs
        ISuperVaultStrategy.FulfillArgs
            memory fulfillArgs = _createMultiActorFulfillArgs(
                testActors,
                requestedShares
            );

        // 3. Calculate total pending before
        uint256 totalPendingBefore;
        for (uint256 i = 0; i < 3; i++) {
            totalPendingBefore += superVault.pendingRedeemRequest(
                0,
                testActors[i]
            );
        }

        // 4. Fulfill all redemption requests at once
        // fulfill as address(this)
        superVaultStrategy.fulfillRedeemRequests(fulfillArgs);

        // 5. Calculate total pending after
        uint256 totalPendingAfter;
        for (uint256 i = 0; i < 3; i++) {
            totalPendingAfter += superVault.pendingRedeemRequest(
                0,
                testActors[i]
            );
        }

        lte(
            totalPendingBefore - totalPendingAfter,
            totalRequestedShares,
            ASSERTION_FULFILL_DOESNT_OVER_REDEEM_MULTIPLE_ACTORS
        );
    }

    /// @dev Property: primary manager can always be replaced by governance via `changePrimaryManager`
    function doomsday_primaryManagerAlwaysChangeable_ASSERTION_PRIMARY_MANAGER_ALWAYS_CHANGEABLE() public stateless {
        address strategy = address(superVaultStrategy);
        address newManager = _getActor();

        // Since address(this) has SUPER_GOVERNOR_ROLE, this should always succeed
        vm.prank(address(this));
        try superGovernor.changePrimaryManager(strategy, newManager) {
            // Call succeeded - this is expected behavior
        } catch (bytes memory err) {
            bool expectedError;
            expectedError = checkError(err, "MANAGER_TAKEOVERS_FROZEN()"); // custom error
            t(
                !expectedError,
                ASSERTION_PRIMARY_MANAGER_ALWAYS_CHANGEABLE
            );
        }
    }

    /// @dev Property: all users can withdraw (solvency)
    // NOTE: if withdrawing from a given strategy via fulfillRedeemRequests fails, it can be expected that one of the YieldSourceTargets would be called to switch the yield source
    // this should allow fulfillments to eventually succeed so we don't need to sort through all yield sources that have currently been deposited into before fulfilling
    function doomsday_allUsersCanWithdraw_ASSERTION_ALL_USERS_CAN_WITHDRAW_WHEN_UNPAUSED() public stateless {
        address[] memory actors = _getActors();
        bool paused = superVaultAggregator.isStrategyPaused(
            address(superVaultStrategy)
        );

        // request redemption for all actors
        for (uint256 i; i < actors.length; i++) {
            uint256 redeemableShares = superVault.balanceOf(actors[i]);

            vm.prank(actors[i]);
            superVault.requestRedeem(redeemableShares, actors[i], actors[i]);
        }

        // fulfill redemption for all actors
        for (uint256 i; i < actors.length; i++) {
            uint256 redeemableShares = superVault.pendingRedeemRequest(
                0,
                actors[i]
            );

            // switch the actor
            _switchActor(i);

            ISuperVaultStrategy.FulfillArgs
                memory fulfillArgs = _fulfillRedeemRequestsArgs(
                    redeemableShares
                );
            superVaultStrategy.fulfillRedeemRequests(fulfillArgs);
        }

        // try to withdraw max possible for all actors
        for (uint256 i; i < actors.length; i++) {
            uint256 withdrawable = superVault.maxWithdraw(actors[i]);

            if (withdrawable > 0 && !paused) {
                vm.prank(actors[i]);
                try
                    superVault.withdraw(withdrawable, actors[i], actors[i])
                {} catch {
                    // if user can't maxWithdraw there's most likely an insolvency issue related to the TOLERANCE_CONSTANT
                    t(
                        false,
                        ASSERTION_ALL_USERS_CAN_WITHDRAW_WHEN_UNPAUSED
                    );
                }
            }
        }
    }

    /// @dev Property: Claiming redemptions should never revert with INVALID_REDEEM_CLAIM
    function doomsday_redemptionsNeverReverts_ASSERTION_REDEEM_SHOULD_NOT_REVERT_INVALID_REDEEM_CLAIM(
        uint256 shares
    ) public asActor stateless {
        try superVault.redeem(shares, _getActor(), _getActor()) {} catch (
            bytes memory err
        ) {
            bool unexpectedError = checkError(err, "INVALID_REDEEM_CLAIM()");
            t(
                !unexpectedError,
                ASSERTION_REDEEM_SHOULD_NOT_REVERT_INVALID_REDEEM_CLAIM
            );
        }
    }

    /// @dev Get shares for SuperVaultStrategy in the current yield source
    function _getSuperVaultStrategyShares() internal view returns (uint256) {
        address yieldSource = _getYieldSource();
        YieldSourceType sourceType = _getYieldSourceTypeFromAddress(
            yieldSource
        );

        if (sourceType == YieldSourceType.ERC4626) {
            return
                MockERC4626Tester(yieldSource).balanceOf(
                    address(superVaultStrategy)
                );
        } else if (sourceType == YieldSourceType.ERC5115) {
            return
                MockERC5115Tester(yieldSource).balanceOf(
                    address(superVaultStrategy)
                );
        } else if (sourceType == YieldSourceType.ERC7540) {
            return
                MockERC7540Tester(yieldSource).balanceOf(
                    address(superVaultStrategy)
                );
        } else {
            revert("Invalid yield source type");
        }
    }

    // Helpers

    /// @dev Helper function to clamp the values for the function call
    function _fulfillRedeemRequestsArgs(
        uint256 redeemAmount
    ) public returns (ISuperVaultStrategy.FulfillArgs memory fulfillArgs) {
        // Find a controller that has pending redeem requests
        address selectedController = _getActor();
        uint256 pendingAmount = superVaultStrategy.pendingRedeemRequest(
            selectedController
        );

        // Clamp using the actor's pending amount
        uint256 actualRedeemAmount = redeemAmount % (pendingAmount + 1);

        address[] memory controllers = new address[](1);
        controllers[0] = selectedController;

        // Determine yield source type from currently active yield source
        YieldSourceType activeYieldSourceType = _getYieldSourceTypeFromAddress(
            _getYieldSource()
        );
        address redeemHook = _getRedeemHookForType(activeYieldSourceType);

        // Create realistic hook calldata for redeem operation
        bytes memory redeemHookCalldata;

        if (
            activeYieldSourceType == YieldSourceType.ERC4626 ||
            activeYieldSourceType == YieldSourceType.ERC5115
        ) {
            // ERC4626/ERC5115 Layout: bytes32 oracleId, address yieldSource, address owner, uint256 shares, bool usePrevAmount
            redeemHookCalldata = abi.encodePacked(
                bytes32(0), // yieldSourceOracleId placeholder
                _getYieldSource(), // Current active yield source
                address(superVaultStrategy), // Owner (strategy owns the yield source shares)
                actualRedeemAmount, // Amount to redeem (matches controller's pending request)
                false // Don't use previous hook amount
            );
        } else {
            // ERC7540 Layout: bytes32 oracleId, address yieldSource, uint256 shares, bool usePrevAmount
            redeemHookCalldata = abi.encodePacked(
                bytes32(0), // yieldSourceOracleId placeholder
                _getYieldSource(), // Current active yield source
                actualRedeemAmount, // Amount to redeem (matches controller's pending request)
                false // Don't use previous hook amount
            );
        }

        // Create arrays for FulfillArgs
        address[] memory hooks = new address[](1);
        hooks[0] = redeemHook;

        bytes[] memory hookCalldata = new bytes[](1);
        hookCalldata[0] = redeemHookCalldata;

        uint256[] memory expectedAssetsOrSharesOut = new uint256[](1);
        expectedAssetsOrSharesOut[0] = actualRedeemAmount; // Expect amount matching the actual redeem

        bytes32[][] memory globalProofs = new bytes32[][](1);
        globalProofs[0] = new bytes32[](0); // Empty proof for UnsafeSuperVaultAggregator

        bytes32[][] memory strategyProofs = new bytes32[][](1);
        strategyProofs[0] = new bytes32[](0); // Empty proof

        // Create the FulfillArgs struct
        fulfillArgs = ISuperVaultStrategy.FulfillArgs({
            controllers: controllers,
            hooks: hooks,
            hookCalldata: hookCalldata,
            expectedAssetsOrSharesOut: expectedAssetsOrSharesOut,
            globalProofs: globalProofs,
            strategyProofs: strategyProofs
        });

        return fulfillArgs;
    }

    /// @dev Helper function to create FulfillArgs for multiple actors
    function _createMultiActorFulfillArgs(
        address[] memory controllers,
        uint256[] memory amounts
    ) internal view returns (ISuperVaultStrategy.FulfillArgs memory) {
        uint256 numActors = controllers.length;

        address[] memory hooks = new address[](numActors);
        bytes[] memory hookCalldata = new bytes[](numActors);
        uint256[] memory expectedAssetsOrSharesOut = new uint256[](numActors);
        bytes32[][] memory globalProofs = new bytes32[][](numActors);
        bytes32[][] memory strategyProofs = new bytes32[][](numActors);

        for (uint256 i = 0; i < numActors; i++) {
            hooks[i] = _getRedeemHookForType(
                _getYieldSourceTypeFromAddress(_getYieldSource())
            );

            if (
                _getYieldSourceTypeFromAddress(_getYieldSource()) ==
                YieldSourceType.ERC4626
            ) {
                hookCalldata[i] = abi.encodePacked(
                    bytes32(0),
                    _getYieldSource(),
                    address(superVaultStrategy),
                    amounts[i],
                    false
                );
            } else {
                hookCalldata[i] = abi.encodePacked(
                    bytes32(0),
                    _getYieldSource(),
                    amounts[i],
                    false
                );
            }

            expectedAssetsOrSharesOut[i] = amounts[i];
            globalProofs[i] = new bytes32[](0);
            strategyProofs[i] = new bytes32[](0);
        }

        return
            ISuperVaultStrategy.FulfillArgs({
                controllers: controllers,
                hooks: hooks,
                hookCalldata: hookCalldata,
                expectedAssetsOrSharesOut: expectedAssetsOrSharesOut,
                globalProofs: globalProofs,
                strategyProofs: strategyProofs
            });
    }

    /// @dev Helper function to create FulfillArgs for redeem requests
    function _createFulfillRedeemArgs(
        uint256 amount
    ) internal view returns (ISuperVaultStrategy.FulfillArgs memory) {
        address[] memory controllers = new address[](1);
        controllers[0] = _getActor();

        address[] memory hooks = new address[](1);
        hooks[0] = _getRedeemHookForType(
            _getYieldSourceTypeFromAddress(_getYieldSource())
        );

        bytes[] memory hookCalldata = new bytes[](1);
        if (
            _getYieldSourceTypeFromAddress(_getYieldSource()) ==
            YieldSourceType.ERC4626
        ) {
            hookCalldata[0] = abi.encodePacked(
                bytes32(0),
                _getYieldSource(),
                address(superVaultStrategy),
                amount,
                false
            );
        } else {
            hookCalldata[0] = abi.encodePacked(
                bytes32(0),
                _getYieldSource(),
                amount,
                false
            );
        }

        uint256[] memory expectedAssetsOrSharesOut = new uint256[](1);
        expectedAssetsOrSharesOut[0] = amount;

        bytes32[][] memory globalProofs = new bytes32[][](1);
        globalProofs[0] = new bytes32[](0);

        bytes32[][] memory strategyProofs = new bytes32[][](1);
        strategyProofs[0] = new bytes32[](0);

        return
            ISuperVaultStrategy.FulfillArgs({
                controllers: controllers,
                hooks: hooks,
                hookCalldata: hookCalldata,
                expectedAssetsOrSharesOut: expectedAssetsOrSharesOut,
                globalProofs: globalProofs,
                strategyProofs: strategyProofs
            });
    }

    /// @dev Helper function to create ExecuteArgs for depositing assets into yield strategy
    function _createExecuteDepositArgs(
        uint256 amount
    ) internal view returns (ISuperVaultStrategy.ExecuteArgs memory) {
        address[] memory hooks = new address[](1);
        hooks[0] = _getApproveAndDepositHookForType(
            _getYieldSourceTypeFromAddress(_getYieldSource())
        );

        bytes[] memory hookCalldata = new bytes[](1);
        YieldSourceType sourceType = _getYieldSourceTypeFromAddress(
            _getYieldSource()
        );

        if (sourceType == YieldSourceType.ERC4626) {
            // ERC4626 deposit: bytes32 oracleId, address yieldSource, address token, uint256 assets, bool usePrevAmount
            hookCalldata[0] = abi.encodePacked(
                bytes32(0), // oracle ID placeholder
                _getYieldSource(),
                superVault.asset(), // token address
                amount,
                false // don't use previous amount
            );
        } else if (sourceType == YieldSourceType.ERC5115) {
            // ERC5115 deposit: bytes32 oracleId, address yieldSource, address token, uint256 assets, address receiver, uint256 id, bool usePrevAmount
            hookCalldata[0] = abi.encodePacked(
                bytes32(0),
                _getYieldSource(),
                superVault.asset(), // token address
                amount,
                address(superVaultStrategy),
                uint256(0), // sy ID for ERC5115
                false
            );
        } else if (sourceType == YieldSourceType.ERC7540) {
            // ERC7540 requestDeposit: bytes32 oracleId, address yieldSource, address token, uint256 assets, address controller, bool usePrevAmount
            hookCalldata[0] = abi.encodePacked(
                bytes32(0),
                _getYieldSource(),
                superVault.asset(), // token address
                amount,
                address(superVaultStrategy),
                false
            );
        }

        uint256[] memory expectedAssetsOrSharesOut = new uint256[](1);
        // For deposit hooks, we expect shares back. Calculate expected shares based on yield source conversion
        // Use a very small amount (1) as minimum since we just want the deposit to succeed
        expectedAssetsOrSharesOut[0] = 1; // Minimum expected shares from deposit

        bytes32[][] memory globalProofs = new bytes32[][](1);
        globalProofs[0] = new bytes32[](0);

        bytes32[][] memory strategyProofs = new bytes32[][](1);
        strategyProofs[0] = new bytes32[](0);

        return
            ISuperVaultStrategy.ExecuteArgs({
                hooks: hooks,
                hookCalldata: hookCalldata,
                expectedAssetsOrSharesOut: expectedAssetsOrSharesOut,
                globalProofs: globalProofs,
                strategyProofs: strategyProofs
            });
    }

    /// @dev Helper function to create FulfillArgs for redeeming from yield strategy
    function _createFulfillRedeemFromStrategyArgs(
        uint256 sharesToRedeem
    ) internal view returns (ISuperVaultStrategy.FulfillArgs memory) {
        address[] memory controllers = new address[](1);
        controllers[0] = _getActor();

        // Get the actual share balance that the SuperVaultStrategy holds in the yield source
        address yieldSource = _getYieldSource();
        uint256 strategyYieldSourceShares = IERC20(yieldSource).balanceOf(
            address(superVaultStrategy)
        );

        // Use the pending shares for the hook calldata to match what's expected by fulfillRedeemRequests
        uint256 pendingShares = superVault.pendingRedeemRequest(0, _getActor());

        // For debugging: ensure we don't try to redeem more than the strategy has
        uint256 actualSharesToRedeem = strategyYieldSourceShares < pendingShares
            ? strategyYieldSourceShares
            : pendingShares;

        address[] memory hooks = new address[](1);
        hooks[0] = _getRedeemHookForType(
            _getYieldSourceTypeFromAddress(yieldSource)
        );

        bytes[] memory hookCalldata = new bytes[](1);
        YieldSourceType sourceType = _getYieldSourceTypeFromAddress(
            yieldSource
        );

        if (
            sourceType == YieldSourceType.ERC4626 ||
            sourceType == YieldSourceType.ERC5115
        ) {
            // For ERC4626/5115: bytes32 oracleId, address yieldSource, address owner, uint256 shares, bool usePrevAmount
            // Use the calculated shares to redeem (limited by what strategy actually has)
            hookCalldata[0] = abi.encodePacked(
                bytes32(0),
                yieldSource,
                address(superVaultStrategy), // owner is the strategy
                actualSharesToRedeem, // redeem calculated amount
                false
            );
        } else {
            // For ERC7540: bytes32 oracleId, address yieldSource, uint256 shares, bool usePrevAmount
            hookCalldata[0] = abi.encodePacked(
                bytes32(0),
                yieldSource,
                actualSharesToRedeem, // redeem calculated amount
                false
            );
        }

        // For fulfillment, we expect to get assets back from redeeming the shares
        // Use a conservative estimate for expected assets out
        uint256[] memory expectedAssetsOrSharesOut = new uint256[](1);
        expectedAssetsOrSharesOut[0] = actualSharesToRedeem > 0 ? 1 : 0; // Minimum 1 asset expected if redeeming anything

        bytes32[][] memory globalProofs = new bytes32[][](1);
        globalProofs[0] = new bytes32[](0);

        bytes32[][] memory strategyProofs = new bytes32[][](1);
        strategyProofs[0] = new bytes32[](0);

        return
            ISuperVaultStrategy.FulfillArgs({
                controllers: controllers,
                hooks: hooks,
                hookCalldata: hookCalldata,
                expectedAssetsOrSharesOut: expectedAssetsOrSharesOut,
                globalProofs: globalProofs,
                strategyProofs: strategyProofs
            });
    }
}


100.0% test/recon/targets/ManagersTargets.sol

Lines covered: 14 / 14 (100.0%)

// SPDX-License-Identifier: GPL-2.0
pragma solidity ^0.8.0;

import {BaseTargetFunctions} from "@chimera/BaseTargetFunctions.sol";
import {BeforeAfter} from "../BeforeAfter.sol";
import {Properties} from "../Properties.sol";
import {vm} from "@chimera/Hevm.sol";

import {MockERC20} from "@recon/MockERC20.sol";

// Target functions that are effectively inherited from the Actor and AssetManagers
// Once properly standardized, managers will expose these by default
// Keeping them out makes your project more custom
abstract contract ManagersTargets is BaseTargetFunctions, Properties {
    // == ACTOR HANDLERS == //

    /// @dev Start acting as another actor
    /// @dev Update ghosts here to make global property checks not fail falsely
    function switchActor(uint256 entropy) public updateGhosts {
        _switchActor(entropy);
    }

    /// @dev Starts using a new asset
    function switch_asset(uint256 entropy) public {
        _switchAsset(entropy);
    }

    /// @dev Deploy a new token and add it to the list of assets, then set it as the current asset
    function add_new_asset(uint8 decimals) public returns (address) {
        address newAsset = _newAsset(decimals);
        return newAsset;
    }

    /// @dev Switches the current vault based on the entropy
    /// @param entropy The entropy to choose a random vault in the array for switching
    function switch_vault(uint256 entropy) public {
        _switchVault(entropy);
    }

    /// @dev Deploy a new vault using the current asset and add it to the list of vaults,
    /// then set it as the current vault
    function add_new_vault() public {
        _newVault(superVault.asset());
    }

    /// === GHOST UPDATING HANDLERS ===///
    /// We `updateGhosts` cause you never know (e.g. donations)
    /// If you don't want to track donations, remove the `updateGhosts`

    /// @dev Approve to arbitrary address, uses Actor by default
    /// NOTE: You're almost always better off setting approvals in `Setup`
    function asset_approve(
        address to,
        uint128 amt
    ) public updateGhosts asActor {
        MockERC20(superVault.asset()).approve(to, amt);
    }

    /// @dev Mint to arbitrary address, uses owner by default, even though MockERC20 doesn't check
    function asset_mint(address to, uint128 amt) public updateGhosts asAdmin {
        MockERC20(superVault.asset()).mint(to, amt);
    }
}


100.0% test/recon/targets/OracleTargets.sol

Lines covered: 36 / 36 (100.0%)

// SPDX-License-Identifier: GPL-2.0
pragma solidity ^0.8.0;

// External dependencies
import {BaseTargetFunctions} from "@chimera/BaseTargetFunctions.sol";
import {vm} from "@chimera/Hevm.sol";
import {Panic} from "@recon/Panic.sol";

// Source dependencies
import {IECDSAPPSOracle} from "src/interfaces/oracles/IECDSAPPSOracle.sol";
import "test/mocks/MockYieldSourceOracle.sol";
import "../mocks/MockERC4626YieldSourceOracle.sol";
import "../mocks/MockERC5115YieldSourceOracle.sol";
import "../mocks/MockERC7540YieldSourceOracle.sol";

// Test suite dependencies
import {BeforeAfter} from "../BeforeAfter.sol";
import {Properties} from "../Properties.sol";

abstract contract OracleTargets is BaseTargetFunctions, Properties {
    /// CUSTOM TARGET FUNCTIONS - Add your own target functions here ///
    function yieldSourceOracle_setValidAsset_clamped() public {
        mockERC4626YieldSourceOracle_setValidAsset(superVault.asset(), true);
    }

    function mockERC4626YieldSourceOracle_setValidAsset(
        address asset,
        bool isValid
    ) public asActor {
        MockERC4626YieldSourceOracle(address(erc4626YieldSourceOracle))
            .setValidAsset(asset, isValid);
    }

    function mockERC5115YieldSourceOracle_setValidAsset(
        address asset,
        bool isValid
    ) public asActor {
        MockERC5115YieldSourceOracle(address(erc5115YieldSourceOracle))
            .setValidAsset(asset, isValid);
    }

    function mockERC7540YieldSourceOracle_setValidAsset(
        address asset,
        bool isValid
    ) public asActor {
        MockERC7540YieldSourceOracle(address(erc7540YieldSourceOracle))
            .setValidAsset(asset, isValid);
    }

    function ECDSAPPSOracle_updatePPS_clamped(uint256 pps) public {
        pps %= (100_000_000 * 1e18) + 1; // clamp to a reasonable max price

        address[] memory strategies = new address[](1);
        strategies[0] = address(superVaultStrategy);

        bytes[][] memory proofsArray = new bytes[][](1);
        proofsArray[0] = new bytes[](0);

        uint256[] memory ppss = new uint256[](1);
        ppss[0] = pps;

        uint256[] memory ppsStdevs = new uint256[](1);
        ppsStdevs[0] = 0;

        uint256[] memory validatorSets = new uint256[](1);
        validatorSets[0] = 0;

        uint256[] memory totalValidators = new uint256[](1);
        totalValidators[0] = 0;

        uint256[] memory timestamps = new uint256[](1);
        timestamps[0] = block.timestamp;

        IECDSAPPSOracle.UpdatePPSArgs memory args = IECDSAPPSOracle
            .UpdatePPSArgs({
                strategies: strategies,
                proofsArray: proofsArray,
                ppss: ppss,
                ppsStdevs: ppsStdevs,
                validatorSets: validatorSets,
                totalValidators: totalValidators,
                timestamps: timestamps
            });

        ECDSAPPSOracle_updatePPS(args);
    }

    /// AUTO GENERATED TARGET FUNCTIONS - WARNING: DO NOT DELETE OR MODIFY THIS LINE ///
    function ECDSAPPSOracle_updatePPS(
        IECDSAPPSOracle.UpdatePPSArgs memory args
    ) public asActor {
        ECDSAPPSOracle.updatePPS(args);

        hasUpdatedPPS = true;
    }
}


100.0% test/recon/targets/SuperGovernorTargets.sol

Lines covered: 37 / 37 (100.0%)

// SPDX-License-Identifier: GPL-2.0
pragma solidity ^0.8.0;

import {BaseTargetFunctions} from "@chimera/BaseTargetFunctions.sol";
import {BeforeAfter} from "../BeforeAfter.sol";
import {Properties} from "../Properties.sol";
// Chimera deps
import {vm} from "@chimera/Hevm.sol";

// Helpers
import {Panic} from "@recon/Panic.sol";

import "src/SuperGovernor.sol";

abstract contract SuperGovernorTargets is BaseTargetFunctions, Properties {
    /// CUSTOM TARGET FUNCTIONS - Add your own target functions here ///
    function superGovernor_proposeGlobalHooksRoot_clamped(
        bytes32 newRoot
    ) public {
        (bytes32 testRoot, bytes32[][] memory testProofs) = merkleHelper
            .generateTestHooksRoot(
                address(approveAndDeposit4626Hook),
                address(redeem4626Hook),
                _getYieldSource(),
                superVault.asset()
            );

        superGovernor_proposeGlobalHooksRoot(testRoot);
    }

    function superGovernor_proposeUpkeepPaymentsChange_clamped() public {
        superGovernor_proposeUpkeepPaymentsChange(true);
    }

    function superGovernor_proposeFee_clamped(
        uint256 feeTypeAsUint,
        uint256 value
    ) public {
        feeTypeAsUint %= 3;
        superGovernor_proposeFee(FeeType(feeTypeAsUint), value);
    }

    function superGovernor_executeFeeUpdate_clamped(
        uint256 feeTypeAsUint
    ) public {
        feeTypeAsUint %= 3;
        superGovernor_executeFeeUpdate(FeeType(feeTypeAsUint));
    }

    /// AUTO GENERATED TARGET FUNCTIONS - WARNING: DO NOT DELETE OR MODIFY THIS LINE ///

    function superGovernor_proposeFee(
        FeeType feeType,
        uint256 value
    ) public asAdmin {
        superGovernor.proposeFee(feeType, value);
    }

    function superGovernor_executeFeeUpdate(FeeType feeType) public asAdmin {
        superGovernor.executeFeeUpdate(feeType);
    }

    function superGovernor_proposeMinStaleness(
        uint256 newMinStaleness
    ) public asAdmin {
        superGovernor.proposeMinStaleness(newMinStaleness);
    }

    function superGovernor_executeMinStalenesChange() public asAdmin {
        superGovernor.executeMinStalenesChange();
    }

    function superGovernor_executeRemoveIncentiveTokens() public asAdmin {
        superGovernor.executeRemoveIncentiveTokens();
    }

    function superGovernor_executeUpkeepClaim(uint256 amount) public asAdmin {
        superGovernor.executeUpkeepClaim(amount);
    }

    function superGovernor_proposeUpkeepPaymentsChange(
        bool enabled
    ) public asAdmin {
        superGovernor.proposeUpkeepPaymentsChange(enabled);
    }

    function superGovernor_executeUpkeepPaymentsChange() public asAdmin {
        superGovernor.executeUpkeepPaymentsChange();
    }

    function superGovernor_proposeAddIncentiveTokens(
        address[] memory tokens
    ) public asAdmin {
        superGovernor.proposeAddIncentiveTokens(tokens);
    }

    function superGovernor_executeAddIncentiveTokens() public asAdmin {
        superGovernor.executeAddIncentiveTokens();
    }

    function superGovernor_proposeGlobalHooksRoot(
        bytes32 newRoot
    ) public asAdmin {
        superGovernor.proposeGlobalHooksRoot(newRoot);
    }
}


100.0% test/recon/targets/SuperVaultAggregatorTargets.sol

Lines covered: 56 / 56 (100.0%)

// SPDX-License-Identifier: GPL-2.0
pragma solidity ^0.8.0;

import {BaseTargetFunctions} from "@chimera/BaseTargetFunctions.sol";
import {vm} from "@chimera/Hevm.sol";
import {Panic} from "@recon/Panic.sol";

import {ISuperVaultStrategy} from "src/interfaces/SuperVault/ISuperVaultStrategy.sol";
import "src/SuperVault/SuperVaultAggregator.sol";

import {BeforeAfter} from "../BeforeAfter.sol";
import {Properties} from "../Properties.sol";

abstract contract SuperVaultAggregatorTargets is
    BaseTargetFunctions,
    Properties
{
    /// CUSTOM TARGET FUNCTIONS - Add your own target functions here ///
    function superVaultAggregator_proposeChangePrimaryManager_clamped() public {
        superVaultAggregator_proposeChangePrimaryManager(
            address(superVaultStrategy),
            _getActor()
        );
    }

    function superVaultAggregator_executeChangePrimaryManager_clamped() public {
        superVaultAggregator_executeChangePrimaryManager(
            address(superVaultStrategy)
        );
    }

    function superVaultAggregator_createVault_clamped(
        uint256 minUpdateInterval,
        uint256 maxStaleness,
        uint256 performanceFeeBps,
        uint256 managementFeeBps
    ) public {
        // Clamp values to reasonable ranges
        minUpdateInterval = minUpdateInterval % 3601; // Max 1 hour
        maxStaleness = (maxStaleness % 86400) + 301; // Between 5 minutes and 1 day
        performanceFeeBps = performanceFeeBps % 9001; // Max 90%
        managementFeeBps = managementFeeBps % 5001; // Max 50%

        // Create secondary managers array
        address[] memory secondaryManagers = new address[](1);

        ISuperVaultAggregator.VaultCreationParams
            memory params = ISuperVaultAggregator.VaultCreationParams({
                asset: _getAsset(),
                name: "SuperVault",
                symbol: "SV",
                mainManager: address(this),
                secondaryManagers: secondaryManagers,
                minUpdateInterval: minUpdateInterval,
                maxStaleness: maxStaleness,
                feeConfig: ISuperVaultStrategy.FeeConfig({
                    performanceFeeBps: performanceFeeBps,
                    managementFeeBps: managementFeeBps,
                    recipient: address(this)
                })
            });

        superVaultAggregator_createVault(params);
    }

    /// AUTO GENERATED TARGET FUNCTIONS - WARNING: DO NOT DELETE OR MODIFY THIS LINE ///

    function superVaultAggregator_addAuthorizedCaller(
        address strategy,
        address caller
    ) public asAdmin {
        superVaultAggregator.addAuthorizedCaller(strategy, caller);
    }

    function superVaultAggregator_addSecondaryManager(
        address strategy,
        address manager
    ) public asActor {
        superVaultAggregator.addSecondaryManager(strategy, manager);
    }

    /// @dev removed because only callable by oracle
    // function superVaultAggregator_batchForwardPPS(
    //     ISuperVaultAggregator.BatchForwardPPSArgs memory args
    // ) public asActor {
    //     superVaultAggregator.batchForwardPPS(args);
    // }

    /// @dev irrelevant for testing because we're bypassing hook validation
    // function superVaultAggregator_changeGlobalLeavesStatus(
    //     bytes32[] memory leaves,
    //     bool[] memory statuses,
    //     address strategy
    // ) public asActor {
    //     superVaultAggregator.changeGlobalLeavesStatus(
    //         leaves,
    //         statuses,
    //         strategy
    //     );
    // }

    function superVaultAggregator_claimUpkeep(uint256 amount) public asActor {
        superVaultAggregator.claimUpkeep(amount);
    }

    function superVaultAggregator_createVault(
        ISuperVaultAggregator.VaultCreationParams memory params
    ) public asActor {
        (
            address _superVault,
            address _strategy,
            address _escrow
        ) = superVaultAggregator.createVault(params);

        superVault = SuperVault(_superVault);
        superVaultStrategy = SuperVaultStrategy(payable(_strategy));
        superVaultEscrow = SuperVaultEscrow(_escrow);

        hasDeployedNewVault = true;
    }

    function superVaultAggregator_depositStake(
        address manager,
        uint256 amount
    ) public asActor {
        superVaultAggregator.depositStake(manager, amount);
    }

    function superVaultAggregator_depositUpkeep(uint256 amount) public asActor {
        superVaultAggregator.depositUpkeep(_getActor(), amount);
    }

    function superVaultAggregator_executeChangePrimaryManager(
        address strategy
    ) public asActor {
        superVaultAggregator.executeChangePrimaryManager(strategy);
    }

    /// @dev removed because we're bypassing hook validation
    // function superVaultAggregator_executeStrategyHooksRootUpdate(
    //     address strategy
    // ) public asActor {
    //     superVaultAggregator.executeStrategyHooksRootUpdate(strategy);
    // }

    /// @dev removed because only callable by oracle
    // function superVaultAggregator_forwardPPS(
    //     address updateAuthority,
    //     ISuperVaultAggregator.ForwardPPSArgs memory args
    // ) public asActor {
    //     superVaultAggregator.forwardPPS(updateAuthority, args);
    // }

    function superVaultAggregator_proposeChangePrimaryManager(
        address strategy,
        address newManager
    ) public asActor {
        superVaultAggregator.proposeChangePrimaryManager(strategy, newManager);
    }

    /// @dev removed because we're bypassing hook validation
    // function superVaultAggregator_proposeStrategyHooksRoot(
    //     address strategy,
    //     bytes32 newRoot
    // ) public asActor {
    //     superVaultAggregator.proposeStrategyHooksRoot(strategy, newRoot);
    // }

    function superVaultAggregator_removeAuthorizedCaller(
        address strategy,
        address caller
    ) public asActor {
        superVaultAggregator.removeAuthorizedCaller(strategy, caller);
    }

    function superVaultAggregator_removeSecondaryManager(
        address strategy,
        address manager
    ) public asActor {
        superVaultAggregator.removeSecondaryManager(strategy, manager);
    }

    function superVaultAggregator_updatePPSVerificationThresholds(
        address strategy,
        uint256 dispersionThreshold_,
        uint256 deviationThreshold_,
        uint256 mnThreshold_
    ) public asActor {
        superVaultAggregator.updatePPSVerificationThresholds(
            strategy,
            dispersionThreshold_,
            deviationThreshold_,
            mnThreshold_
        );
    }

    function superVaultAggregator_withdrawStake(uint256 amount) public asActor {
        superVaultAggregator.withdrawStake(amount);
    }

    function superVaultAggregator_withdrawUpkeep(
        uint256 amount
    ) public asActor {
        superVaultAggregator.withdrawUpkeep(amount);
    }
}


100.0% test/recon/targets/SuperVaultEscrowTargets.sol

Lines covered: 6 / 6 (100.0%)

// SPDX-License-Identifier: GPL-2.0
pragma solidity ^0.8.0;

import {BaseTargetFunctions} from "@chimera/BaseTargetFunctions.sol";
import {BeforeAfter} from "../BeforeAfter.sol";
import {Properties} from "../Properties.sol";
// Chimera deps
import {vm} from "@chimera/Hevm.sol";

// Helpers
import {Panic} from "@recon/Panic.sol";

import "src/SuperVault/SuperVaultEscrow.sol";

abstract contract SuperVaultEscrowTargets is
    BaseTargetFunctions,
    Properties
{
    /// CUSTOM TARGET FUNCTIONS - Add your own target functions here ///


    /// AUTO GENERATED TARGET FUNCTIONS - WARNING: DO NOT DELETE OR MODIFY THIS LINE ///

    function superVaultEscrow_escrowShares(address from, uint256 amount) public asActor {
        superVaultEscrow.escrowShares(from, amount);
    }

    function superVaultEscrow_initialize(address vaultAddress, address strategyAddress) public asActor {
        superVaultEscrow.initialize(vaultAddress, strategyAddress);
    }

    function superVaultEscrow_returnShares(address to, uint256 amount) public asActor {
        superVaultEscrow.returnShares(to, amount);
    }
}

100.0% test/recon/targets/SuperVaultStrategyTargets.sol

Lines covered: 36 / 36 (100.0%)

// SPDX-License-Identifier: GPL-2.0
pragma solidity ^0.8.0;

import {BaseTargetFunctions} from "@chimera/BaseTargetFunctions.sol";

import {vm} from "@chimera/Hevm.sol";
import {Panic} from "@recon/Panic.sol";
import {MockERC20} from "@recon/MockERC20.sol";

import "src/SuperVault/SuperVaultStrategy.sol";

import {YieldSourceType} from "test/recon/managers/YieldManager.sol";
import {BeforeAfter, OpType} from "../BeforeAfter.sol";
import {Properties} from "../Properties.sol";

abstract contract SuperVaultStrategyTargets is BaseTargetFunctions, Properties {
    /// CUSTOM TARGET FUNCTIONS - Add your own target functions here ///

    /// @dev Clamps the action type to 0 to add a vault as a yield source
    function superVaultStrategy_manageYieldSource_clamped(
        uint256 sourceType
    ) public {
        YieldSourceType clampedType = YieldSourceType(sourceType % 3); // 0=ERC4626, 1=ERC5115, 2=ERC7540
        address yieldSourceOracle = _getYieldSourceOracleForType(clampedType);

        superVaultStrategy_manageYieldSource(
            _getYieldSource(),
            yieldSourceOracle,
            0
        );
    }

    function superVaultStrategy_handleOperations7540_clamped(
        uint256 operation,
        uint256 amount
    ) public {
        operation %= 7; // clamp by the possible operation types in the enum
        superVaultStrategy_handleOperations7540(
            ISuperVaultStrategy.Operation(operation),
            _getActor(),
            _getActor(),
            amount
        );
    }

    /// AUTO GENERATED TARGET FUNCTIONS - WARNING: DO NOT DELETE OR MODIFY THIS LINE ///

    function superVaultStrategy_executeVaultFeeConfigUpdate() public asActor {
        superVaultStrategy.executeVaultFeeConfigUpdate();
    }

    function superVaultStrategy_handleOperations4626Deposit(
        address controller,
        uint256 assetsGross
    ) public asActor {
        superVaultStrategy.handleOperations4626Deposit(controller, assetsGross);
    }

    function superVaultStrategy_handleOperations4626Mint(
        address controller,
        uint256 sharesNet,
        uint256 assetsGross,
        uint256 assetsNet
    ) public asActor {
        superVaultStrategy.handleOperations4626Mint(
            controller,
            sharesNet,
            assetsGross,
            assetsNet
        );
    }

    function superVaultStrategy_handleOperations7540(
        ISuperVaultStrategy.Operation operation,
        address controller,
        address receiver,
        uint256 amount
    ) public asActor {
        superVaultStrategy.handleOperations7540(
            operation,
            controller,
            receiver,
            amount
        );
    }

    function superVaultStrategy_manageEmergencyWithdraw(
        uint8 action,
        address recipient,
        uint256 amount
    ) public asActor {
        superVaultStrategy.manageEmergencyWithdraw(action, recipient, amount);
    }

    function superVaultStrategy_manageYieldSource(
        address source,
        address oracle,
        uint8 actionType
    ) public asActor {
        superVaultStrategy.manageYieldSource(source, oracle, actionType);
    }

    function superVaultStrategy_manageYieldSources(
        address[] memory sources,
        address[] memory oracles,
        uint8[] memory actionTypes
    ) public asActor {
        superVaultStrategy.manageYieldSources(sources, oracles, actionTypes);
    }

    function superVaultStrategy_moveAccumulatorOnTransfer(
        address from,
        address to,
        uint256 shares
    ) public asActor {
        superVaultStrategy.moveAccumulatorOnTransfer(from, to, shares);
    }

    function superVaultStrategy_proposeVaultFeeConfigUpdate(
        uint256 performanceFeeBps,
        uint256 managementFeeBps,
        address recipient
    ) public asActor {
        superVaultStrategy.proposeVaultFeeConfigUpdate(
            performanceFeeBps,
            managementFeeBps,
            recipient
        );
    }

    function superVaultStrategy_updateMaxPPSSlippage(
        uint256 maxSlippageBps
    ) public asActor {
        superVaultStrategy.updateMaxPPSSlippage(maxSlippageBps);
    }
}


100.0% test/recon/targets/SuperVaultTargets.sol

Lines covered: 123 / 123 (100.0%)

// SPDX-License-Identifier: GPL-2.0
pragma solidity ^0.8.0;

// Recon deps
import {BaseTargetFunctions} from "@chimera/BaseTargetFunctions.sol";
import {vm} from "@chimera/Hevm.sol";
import {Panic} from "@recon/Panic.sol";
import {MockERC20} from "@recon/MockERC20.sol";

import "src/SuperVault/SuperVault.sol";

import {BeforeAfter, OpType} from "test/recon/BeforeAfter.sol";
import {Properties} from "../Properties.sol";

/// @dev All receivers are inherently clamped to actors to make checking properties easier
abstract contract SuperVaultTargets is BaseTargetFunctions, Properties {
    /// CUSTOM TARGET FUNCTIONS - Add your own target functions here ///
    function superVault_requestRedeem_clamped(uint256 shares) public {
        shares %= superVault.balanceOf(_getActor()) + 1;

        superVault_requestRedeem(shares);
    }

    function superVault_redeem_clamped(uint256 shares) public {
        uint256 claimableAssets = superVault.maxWithdraw(_getActor());
        uint256 claimableShares = superVault.convertToShares(claimableAssets);

        shares %= claimableShares + 1;

        superVault_redeem(shares);
    }

    function superVault_withdraw_clamped(uint256 assets) public {
        uint256 claimableAssets = superVault.maxWithdraw(_getActor());
        assets %= claimableAssets + 1;

        superVault_withdraw(assets);
    }

    /// AUTO GENERATED TARGET FUNCTIONS - WARNING: DO NOT DELETE OR MODIFY THIS LINE ///

    function superVault_approve(address spender, uint256 value) public asActor {
        superVault.approve(spender, value);
    }

    function superVault_burnShares(uint256 amount) public asActor {
        superVault.burnShares(amount);
    }

    /// @dev Property: pendingRedeemRequest should be 0 after a user calls cancelRedeem
    /// @dev Property: averageRequestPPS should be 0 after a user calls cancelRedeem
    /// @dev Property: user shouldn't receive more than convertToAssets(pendingRedeemRequest) after cancelRedeem
    function superVault_cancelRedeem_ASSERTION_CANCEL_REDEEM_NO_OVERPAY()
        public
        updateGhostsWithOpType(OpType.CANCEL)
    {
        uint256 pendingRedeemRequestsBefore = superVault.pendingRedeemRequest(
            0,
            _getActor()
        );
        uint256 pendingRedeemRequestsAsAssets = superVault.convertToAssets(
            pendingRedeemRequestsBefore
        );
        uint256 balanceBefore = MockERC20(superVault.asset()).balanceOf(
            _getActor()
        );

        vm.prank(_getActor());
        superVault.cancelRedeem(_getActor());

        uint256 pendingRedeemRequestsAfter = superVault.pendingRedeemRequest(
            0,
            _getActor()
        );
        uint256 averageRequestPPS = superVaultStrategy
            .getSuperVaultState(_getActor())
            .averageRequestPPS;
        uint256 balanceAfter = MockERC20(superVault.asset()).balanceOf(
            _getActor()
        );

        // Checks
        eq(
            pendingRedeemRequestsAfter,
            0,
            ASSERTION_CANCEL_REDEEM_NO_OVERPAY
        );
        eq(
            averageRequestPPS,
            0,
            ASSERTION_CANCEL_REDEEM_NO_OVERPAY
        );
        lte(
            balanceAfter - balanceBefore,
            pendingRedeemRequestsAsAssets,
            ASSERTION_CANCEL_REDEEM_NO_OVERPAY
        );
    }

    /// @dev Property: previewDeposit returns the correct amounts compared to executing a deposit
    function superVault_deposit_ASSERTION_PREVIEW_DEPOSIT_MATCHES_EXECUTION(
        uint256 assets
    ) public updateGhostsWithOpType(OpType.ADD) {
        uint256 previewShares = superVault.previewDeposit(assets);

        vm.prank(_getActor());
        uint256 shares = superVault.deposit(assets, _getActor());

        eq(
            previewShares,
            shares,
            ASSERTION_PREVIEW_DEPOSIT_MATCHES_EXECUTION
        );
    }

    /// @dev Property: previewMint returns the correct amounts compared to executing a mint
    function superVault_mint_ASSERTION_PREVIEW_MINT_MATCHES_EXECUTION(
        uint256 shares
    ) public updateGhostsWithOpType(OpType.ADD) {
        uint256 previewMint = superVault.previewMint(shares);

        vm.prank(_getActor());
        uint256 assets = superVault.mint(shares, _getActor());

        eq(
            assets,
            previewMint,
            ASSERTION_PREVIEW_MINT_MATCHES_EXECUTION
        );
    }

    function superVault_invalidateNonce(bytes32 nonce) public asActor {
        superVault.invalidateNonce(nonce);
    }

    function superVault_redeem(
        uint256 shares
    ) public updateGhostsWithOpType(OpType.REMOVE) asActor {
        superVault.redeem(shares, _getActor(), _getActor());
    }

    function superVault_withdraw(
        uint256 assets
    ) public updateGhostsWithOpType(OpType.REMOVE) asActor {
        superVault.withdraw(assets, _getActor(), _getActor());
    }

    function superVault_requestRedeem(
        uint256 shares
    ) public updateGhostsWithOpType(OpType.REQUEST) asActor {
        superVault.requestRedeem(shares, _getActor(), _getActor());
    }

    function superVault_setOperator(
        uint256 entropy,
        bool approved
    ) public asActor {
        address operator = _getRandomActor(entropy);
        superVault.setOperator(operator, approved);
    }

    /// @dev Propery: _update should never revert
    /// @dev Property: Transfers of shares should transfer the exact amount of accumulatorShares to the recipient
    /// @dev Property: Transfers of shares should transfer the exact amount of accumulatorCostBasis to the recipient
    // NOTE: _update only gets called on transfer of Vault shares
    function superVault_transfer_ASSERTION_TRANSFER_SHARES_CONSERVED(
        uint256 entropy,
        uint256 value
    ) public updateGhostsWithOpType(OpType.TRANSFER) {
        address to = _getRandomActor(entropy);
        ISuperVaultStrategy.SuperVaultState
            memory stateSenderBefore = superVaultStrategy.getSuperVaultState(
                _getActor()
            );
        ISuperVaultStrategy.SuperVaultState
            memory stateRecipientBefore = superVaultStrategy.getSuperVaultState(
                to
            );

        vm.prank(_getActor());
        try superVault.transfer(to, value) {
            ISuperVaultStrategy.SuperVaultState
                memory stateSenderAfter = superVaultStrategy.getSuperVaultState(
                    _getActor()
                );
            ISuperVaultStrategy.SuperVaultState
                memory stateRecipientAfter = superVaultStrategy
                    .getSuperVaultState(to);

            eq(
                stateSenderBefore.accumulatorShares -
                    stateSenderAfter.accumulatorShares,
                stateRecipientAfter.accumulatorShares -
                    stateRecipientBefore.accumulatorShares,
                ASSERTION_TRANSFER_SHARES_CONSERVED
            );
            eq(
                stateSenderBefore.accumulatorCostBasis -
                    stateSenderAfter.accumulatorCostBasis,
                stateRecipientAfter.accumulatorCostBasis -
                    stateRecipientBefore.accumulatorCostBasis,
                ASSERTION_TRANSFER_SHARES_CONSERVED
            );
        } catch (bytes memory err) {
            bool expectedError;
            expectedError = checkError(
                err,
                "ERC20InsufficientBalance(address,uint256,uint256)"
            );
            t(expectedError, ASSERTION_TRANSFER_SHARES_CONSERVED);
        }
    }

    /// @dev Propery: _update should never revert
    // NOTE: _update only gets called on transfer of Vault shares
    function superVault_transferFrom_ASSERTION_UPDATE_SHOULD_NOT_REVERT_TRANSFER_FROM(
        uint256 entropyFrom,
        uint256 entropyTo,
        uint256 value
    ) public updateGhostsWithOpType(OpType.TRANSFER) {
        address from = _getRandomActor(entropyFrom);
        address to = _getRandomActor(entropyTo);

        vm.prank(_getActor());
        try superVault.transferFrom(from, to, value) {} catch (
            bytes memory err
        ) {
            bool expectedError;
            expectedError =
                checkError(
                    err,
                    "ERC20InsufficientBalance(address,uint256,uint256)"
                ) ||
                checkError(
                    err,
                    "ERC20InsufficientAllowance(address,uint256,uint256)"
                );
            t(
                expectedError,
                ASSERTION_UPDATE_SHOULD_NOT_REVERT_TRANSFER_FROM
            );
        }
    }

    /// @dev removed because signature components not fuzzable
    // function superVault_authorizeOperator(
    //     address controller,
    //     address operator,
    //     bool approved,
    //     bytes32 nonce,
    //     uint256 deadline,
    //     bytes memory signature
    // ) public asActor {
    //     superVault.authorizeOperator(
    //         controller,
    //         operator,
    //         approved,
    //         nonce,
    //         deadline,
    //         signature
    //     );
    // }
}


94.0% test/recon/targets/YieldSourceTargets.sol

Lines covered: 166 / 176 (94.0%)

// SPDX-License-Identifier: GPL-2.0
pragma solidity ^0.8.0;

// Chimera deps
import {BaseTargetFunctions} from "@chimera/BaseTargetFunctions.sol";
import {vm} from "@chimera/Hevm.sol";

// Helpers
import {Panic} from "@recon/Panic.sol";

import {Properties} from "../Properties.sol";
import {MockERC4626Tester, FunctionType, RevertType} from "../mocks/MockERC4626Tester.sol";
import {MockERC5115Tester, RevertType as RevertType5115} from "../mocks/MockERC5115Tester.sol";
import {MockERC7540Tester} from "../mocks/MockERC7540Tester.sol";
import {YieldSourceType} from "../managers/YieldManager.sol";

/// @dev Target functions for yield source testers which are used as yield sources in SuperVaultStrategy
abstract contract YieldSourceTargets is BaseTargetFunctions, Properties {
    /// AUTO GENERATED TARGET FUNCTIONS - WARNING: DO NOT DELETE OR MODIFY THIS LINE ///

    /// ERC20 functions (available across all types as they inherit from MockERC20) ///
    function yieldSource_approve(
        address spender,
        uint256 value
    ) public asActor {
        YieldSourceType currentType = _getCurrentYieldSourceType();
        address yieldSource = _getYieldSource();

        if (currentType == YieldSourceType.ERC4626) {
            MockERC4626Tester(yieldSource).approve(spender, value);
        } else if (currentType == YieldSourceType.ERC5115) {
            MockERC5115Tester(yieldSource).approve(spender, value);
        } else if (currentType == YieldSourceType.ERC7540) {
            MockERC7540Tester(yieldSource).approve(spender, value);
        }
    }

    function yieldSource_setDecimalsOffset(
        uint8 targetDecimalsOffset
    ) public asActor {
        YieldSourceType currentType = _getCurrentYieldSourceType();
        address yieldSource = _getYieldSource();

        if (currentType == YieldSourceType.ERC4626) {
            MockERC4626Tester(yieldSource).setDecimalsOffset(
                targetDecimalsOffset
            );
        }
        // Note: ERC5115 and ERC7540 don't have setDecimalsOffset function
    }

    function yieldSource_transfer(address to, uint256 value) public asActor {
        YieldSourceType currentType = _getCurrentYieldSourceType();
        address yieldSource = _getYieldSource();

        if (currentType == YieldSourceType.ERC4626) {
            MockERC4626Tester(yieldSource).transfer(to, value);
        } else if (currentType == YieldSourceType.ERC5115) {
            MockERC5115Tester(yieldSource).transfer(to, value);
        } else if (currentType == YieldSourceType.ERC7540) {
            MockERC7540Tester(yieldSource).transfer(to, value);
        }
    }

    function yieldSource_transferFrom(
        address from,
        address to,
        uint256 value
    ) public asActor {
        YieldSourceType currentType = _getCurrentYieldSourceType();
        address yieldSource = _getYieldSource();

        if (currentType == YieldSourceType.ERC4626) {
            MockERC4626Tester(yieldSource).transferFrom(from, to, value);
        } else if (currentType == YieldSourceType.ERC5115) {
            MockERC5115Tester(yieldSource).transferFrom(from, to, value);
        } else if (currentType == YieldSourceType.ERC7540) {
            MockERC7540Tester(yieldSource).transferFrom(from, to, value);
        }
    }

    /// Core Vault Functions (ERC4626/ERC4626-like) ///
    function yieldSource_deposit(
        uint256 assets,
        address receiver
    ) public asActor {
        YieldSourceType currentType = _getCurrentYieldSourceType();
        address yieldSource = _getYieldSource();

        if (currentType == YieldSourceType.ERC4626) {
            MockERC4626Tester(yieldSource).deposit(assets, receiver);
        }
        // Note: ERC5115 has different deposit signature, handled separately
        // Note: ERC7540 has different deposit signature, handled separately
    }

    function yieldSource_mint(uint256 shares, address receiver) public asActor {
        YieldSourceType currentType = _getCurrentYieldSourceType();
        address yieldSource = _getYieldSource();

        if (currentType == YieldSourceType.ERC4626) {
            MockERC4626Tester(yieldSource).mint(shares, receiver);
        } else if (currentType == YieldSourceType.ERC7540) {
            MockERC7540Tester(yieldSource).mint(shares, receiver);
        }
        // Note: ERC5115 doesn't have mint function
    }

    function yieldSource_withdraw(
        uint256 assets,
        address receiver,
        address owner
    ) public asActor {
        YieldSourceType currentType = _getCurrentYieldSourceType();
        address yieldSource = _getYieldSource();

        if (currentType == YieldSourceType.ERC4626) {
            MockERC4626Tester(yieldSource).withdraw(assets, receiver, owner);
        } else if (currentType == YieldSourceType.ERC7540) {
            MockERC7540Tester(yieldSource).withdraw(assets, receiver, owner);
        }
        // Note: ERC5115 doesn't have withdraw function
    }

    function yieldSource_redeem(
        uint256 shares,
        address receiver,
        address owner
    ) public asActor {
        YieldSourceType currentType = _getCurrentYieldSourceType();
        address yieldSource = _getYieldSource();

        if (currentType == YieldSourceType.ERC4626) {
            MockERC4626Tester(yieldSource).redeem(shares, receiver, owner);
        } else if (currentType == YieldSourceType.ERC7540) {
            MockERC7540Tester(yieldSource).redeem(shares, receiver, owner);
        }
        // Note: ERC5115 has different redeem signature, handled separately
    }

    /// ERC5115-specific functions ///
    function yieldSource_deposit5115(
        address receiver,
        address tokenIn,
        uint256 amountTokenToDeposit,
        uint256 minSharesOut,
        bool depositFromInternalBalance
    ) public asActor {
        YieldSourceType currentType = _getCurrentYieldSourceType();
        address yieldSource = _getYieldSource();

        if (currentType == YieldSourceType.ERC5115) {
            MockERC5115Tester(yieldSource).deposit(
                receiver,
                tokenIn,
                amountTokenToDeposit,
                minSharesOut,
                depositFromInternalBalance
            );
        }
    }

    function yieldSource_redeem5115(
        address receiver,
        uint256 amountSharesToRedeem,
        address tokenOut,
        uint256 minTokenOut,
        bool burnFromInternalBalance
    ) public asActor {
        YieldSourceType currentType = _getCurrentYieldSourceType();
        address yieldSource = _getYieldSource();

        if (currentType == YieldSourceType.ERC5115) {
            MockERC5115Tester(yieldSource).redeem(
                receiver,
                amountSharesToRedeem,
                tokenOut,
                minTokenOut,
                burnFromInternalBalance
            );
        }
    }

    /// ERC7540-specific functions ///
    function yieldSource_setOperator(
        address operator,
        bool approved
    ) public asActor {
        YieldSourceType currentType = _getCurrentYieldSourceType();
        address yieldSource = _getYieldSource();

        if (currentType == YieldSourceType.ERC7540) {
            MockERC7540Tester(yieldSource).setOperator(operator, approved);
        }
    }

    function yieldSource_requestDeposit(
        uint256 assets,
        address controller,
        address owner
    ) public asActor {
        YieldSourceType currentType = _getCurrentYieldSourceType();
        address yieldSource = _getYieldSource();

        if (currentType == YieldSourceType.ERC7540) {
            MockERC7540Tester(yieldSource).requestDeposit(
                assets,
                controller,
                owner
            );
        }
    }

    function yieldSource_requestRedeem(
        uint256 shares,
        address controller,
        address owner
    ) public asActor {
        YieldSourceType currentType = _getCurrentYieldSourceType();
        address yieldSource = _getYieldSource();

        if (currentType == YieldSourceType.ERC7540) {
            MockERC7540Tester(yieldSource).requestRedeem(
                shares,
                controller,
                owner
            );
        }
    }

    function yieldSource_cancelDepositRequest(
        uint256 requestId,
        address controller
    ) public asActor {
        YieldSourceType currentType = _getCurrentYieldSourceType();
        address yieldSource = _getYieldSource();

        if (currentType == YieldSourceType.ERC7540) {
            MockERC7540Tester(yieldSource).cancelDepositRequest(
                requestId,
                controller
            );
        }
    }

    function yieldSource_cancelRedeemRequest(
        uint256 requestId,
        address controller
    ) public asActor {
        YieldSourceType currentType = _getCurrentYieldSourceType();
        address yieldSource = _getYieldSource();

        if (currentType == YieldSourceType.ERC7540) {
            MockERC7540Tester(yieldSource).cancelRedeemRequest(
                requestId,
                controller
            );
        }
    }

    function yieldSource_claimCancelDepositRequest(
        uint256 requestId,
        address receiver,
        address controller
    ) public asActor {
        YieldSourceType currentType = _getCurrentYieldSourceType();
        address yieldSource = _getYieldSource();

        if (currentType == YieldSourceType.ERC7540) {
            MockERC7540Tester(yieldSource).claimCancelDepositRequest(
                requestId,
                receiver,
                controller
            );
        }
    }

    function yieldSource_claimCancelRedeemRequest(
        uint256 requestId,
        address receiver,
        address controller
    ) public asActor {
        YieldSourceType currentType = _getCurrentYieldSourceType();
        address yieldSource = _getYieldSource();

        if (currentType == YieldSourceType.ERC7540) {
            MockERC7540Tester(yieldSource).claimCancelRedeemRequest(
                requestId,
                receiver,
                controller
            );
        }
    }

    function yieldSource_deposit7540(
        uint256 assets,
        address receiver,
        address controller
    ) public asActor {
        YieldSourceType currentType = _getCurrentYieldSourceType();
        address yieldSource = _getYieldSource();

        if (currentType == YieldSourceType.ERC7540) {
            MockERC7540Tester(yieldSource).deposit(
                assets,
                receiver,
                controller
            );
        }
    }

    /// Testing-specific functions (ERC4626 only) ///
    function yieldSource_setRevertBehavior4626(
        uint8 functionType,
        uint8 revertType
    ) public asActor {
        YieldSourceType currentType = _getCurrentYieldSourceType();
        address yieldSource = _getYieldSource();

        if (currentType == YieldSourceType.ERC4626) {
            MockERC4626Tester(yieldSource).setRevertBehavior(
                FunctionType(functionType),
                RevertType(revertType)
            );
        }
    }

    /// Testing-specific functions (ERC5115 only) ///
    function yieldSource_setRevertBehavior5115(
        uint8 revertType
    ) public asActor {
        YieldSourceType currentType = _getCurrentYieldSourceType();
        address yieldSource = _getYieldSource();

        if (currentType == YieldSourceType.ERC5115) {
            MockERC5115Tester(yieldSource).setRevertBehavior(
                RevertType5115(revertType)
            );
        }
    }

    /// Common yield manipulation functions ///

    function yieldSource_simulateLoss(uint256 lossAmount) public {
        YieldSourceType currentType = _getCurrentYieldSourceType();
        address yieldSource = _getYieldSource();

        if (currentType == YieldSourceType.ERC4626) {
            MockERC4626Tester(yieldSource).simulateLoss(lossAmount);
        } else if (currentType == YieldSourceType.ERC5115) {
            MockERC5115Tester(yieldSource).simulateLoss(lossAmount);
        } else if (currentType == YieldSourceType.ERC7540) {
            MockERC7540Tester(yieldSource).simulateLoss(lossAmount);
        }
    }

    function yieldSource_simulateGain(uint256 gainAmount) public {
        YieldSourceType currentType = _getCurrentYieldSourceType();
        address yieldSource = _getYieldSource();

        if (currentType == YieldSourceType.ERC4626) {
            MockERC4626Tester(yieldSource).simulateGain(gainAmount);
        } else if (currentType == YieldSourceType.ERC5115) {
            MockERC5115Tester(yieldSource).simulateGain(gainAmount);
        } else if (currentType == YieldSourceType.ERC7540) {
            MockERC7540Tester(yieldSource).simulateGain(gainAmount);
        }
    }

    function yieldSource_setLossOnWithdraw(
        uint256 lossOnWithdraw
    ) public asActor {
        YieldSourceType currentType = _getCurrentYieldSourceType();
        address yieldSource = _getYieldSource();

        if (currentType == YieldSourceType.ERC4626) {
            MockERC4626Tester(yieldSource).setLossOnWithdraw(lossOnWithdraw);
        } else if (currentType == YieldSourceType.ERC5115) {
            MockERC5115Tester(yieldSource).setLossOnWithdraw(lossOnWithdraw);
        } else if (currentType == YieldSourceType.ERC7540) {
            MockERC7540Tester(yieldSource).setLossOnWithdraw(lossOnWithdraw);
        }
    }

    /// Yield source management functions ///
    function yieldSource_switchToERC4626() public {
        _switchYieldSource(0); // Switch to first yield source (ERC4626)
    }

    function yieldSource_switchToERC5115() public {
        _switchYieldSource(1); // Switch to second yield source (ERC5115)
    }

    function yieldSource_switchToERC7540() public {
        _switchYieldSource(2); // Switch to third yield source (ERC7540)
    }

    function yieldSource_switchRandom(uint256 entropy) public {
        // Randomly switch between the three deployed yield sources
        _switchYieldSource(entropy);
    }
}


1	// SPDX-License-Identifier: AGPL-3.0-only
2	pragma solidity ^0.8.21;
3
4	import {Asserts} from "@chimera/Asserts.sol";
5
6	interface IShareLike {
7	function balanceOf(address) external view returns (uint256);
8	function totalSupply() external view returns (uint256);
9	function decimals() external view returns (uint8);
10	}
11
12	interface IERC7540Like {
13	function share() external view returns (address shareTokenAddress);
14	function convertToShares(
15	uint256 assets
16	) external view returns (uint256 shares);
17	function convertToAssets(
18	uint256 shares
19	) external view returns (uint256 assets);
20	function totalAssets() external view returns (uint256 totalManagedAssets);
21	function maxDeposit(
22	address receiver
23	) external view returns (uint256 maxAssets);
24	function previewDeposit(
25	uint256 assets
26	) external view returns (uint256 shares);
27	function deposit(
28	uint256 assets,
29	address receiver
30	) external returns (uint256 shares);
31	function maxMint(
32	address receiver
33	) external view returns (uint256 maxShares);
34	function previewMint(uint256 shares) external view returns (uint256 assets);
35	function mint(
36	uint256 shares,
37	address receiver
38	) external returns (uint256 assets);
39	function maxWithdraw(
40	address owner
41	) external view returns (uint256 maxAssets);
42	function previewWithdraw(
43	uint256 assets
44	) external view returns (uint256 shares);
45	function withdraw(
46	uint256 assets,
47	address receiver,
48	address owner
49	) external returns (uint256 shares);
50	function maxRedeem(address owner) external view returns (uint256 maxShares);
51	function previewRedeem(
52	uint256 shares
53	) external view returns (uint256 assets);
54	function redeem(
55	uint256 shares,
56	address receiver,
57	address owner
58	) external returns (uint256 assets);
59
60	function requestRedeem(
61	uint256 shares,
62	address receiver,
63	address owner,
64	bytes calldata data
65	) external returns (uint256 requestId);
66	}
67
68	/// @dev ERC-7540 Properties
69	/// @author The Recon Team
70	/// @notice A set of reuseable tests for your ERC7540 Vaults
71	/// To get started, extend from this contract and make sure to add a way to set the actor (the current user)
72	/// For more info: https://getrecon.xyz/
73	abstract contract ERC7540Properties is Asserts {
74	uint256 public constant MAX_ROUNDING_ERROR = 10 ** 18;
75
76	address actor;
77
78	/// @audit TODO: You must add a way to change this!
79
80	/// @dev 7540-1 convertToAssets(totalSupply) == totalAssets unless price is 0.0
81	function erc7540_1(address erc7540Target) public virtual returns (bool) {
82	// Doesn't hold on zero price
83	if (
84	IERC7540Like(erc7540Target).convertToAssets(
85	10 ** IShareLike(IERC7540Like(erc7540Target).share()).decimals()
86	) == 0
87	) return true;
88
89	return
90	IERC7540Like(erc7540Target).convertToAssets(
91	IShareLike(IERC7540Like(erc7540Target).share()).totalSupply()
92	) == IERC7540Like(erc7540Target).totalAssets();
93	}
94
95	/// @dev 7540-2 convertToShares(totalAssets) == totalSupply unless price is 0.0
96	function erc7540_2(address erc7540Target) public virtual returns (bool) {
97	if (
98	IERC7540Like(erc7540Target).convertToAssets(
99	10 ** IShareLike(IERC7540Like(erc7540Target).share()).decimals()
100	) == 0
101	) return true;
102
103	// convertToShares(totalAssets) == totalSupply
104	return
105	_diff(
106	IERC7540Like(erc7540Target).convertToShares(
107	IERC7540Like(erc7540Target).totalAssets()
108	),
109	IShareLike(IERC7540Like(erc7540Target).share()).totalSupply()
110	) <= MAX_ROUNDING_ERROR;
111	}
112
113	function _diff(uint256 a, uint256 b) internal pure returns (uint256) {
114	return a > b ? a - b : b - a;
115	}
116
117	/// @dev 7540-3 max* never reverts
118	function erc7540_3(address erc7540Target) public virtual returns (bool) {
119	// max* never reverts
120	try IERC7540Like(erc7540Target).maxDeposit(actor) {} catch {
121	return false;
122	}
123	try IERC7540Like(erc7540Target).maxMint(actor) {} catch {
124	return false;
125	}
126	try IERC7540Like(erc7540Target).maxRedeem(actor) {} catch {
127	return false;
128	}
129	try IERC7540Like(erc7540Target).maxWithdraw(actor) {} catch {
130	return false;
131	}
132
133	return true;
134	}
135
136	/// == erc7540_4 == //
137
138	/// @dev 7540-4 claiming more than max always reverts
139	function erc7540_4_deposit(
140	address erc7540Target,
141	uint256 amt
142	) public virtual returns (bool) {
143	// Skip 0
144	if (amt == 0) {
145	return true; // Skip
146	}
147
148	uint256 maxDep = IERC7540Like(erc7540Target).maxDeposit(actor);
149
150	/// @audit No Revert is proven by erc7540_5
151
152	uint256 sum = maxDep + amt;
153	if (sum == 0) {
154	return true; // Needs to be greater than 0, skip
155	}
156
157	try IERC7540Like(erc7540Target).deposit(maxDep + amt, actor) {
158	return false;
159	} catch {
160	// We want this to be hit
161	return true; // So we explicitly return here, as a means to ensure that this is the code path
162	}
163
164	// NOTE: This code path is never hit per the above
165	}
166
167	function erc7540_4_mint(
168	address erc7540Target,
169	uint256 amt
170	) public virtual returns (bool) {
171	// Skip 0
172	if (amt == 0) {
173	return true;
174	}
175
176	uint256 maxDep = IERC7540Like(erc7540Target).maxMint(actor);
177
178	uint256 sum = maxDep + amt;
179	if (sum == 0) {
180	return true; // Needs to be greater than 0, skip
181	}
182
183	try IERC7540Like(erc7540Target).mint(maxDep + amt, actor) {
184	return false;
185	} catch {
186	// We want this to be hit
187	return true; // So we explicitly return here, as a means to ensure that this is the code path
188	}
189
190	// NOTE: This code path is never hit per the above
191	}
192
193	function erc7540_4_withdraw(
194	address erc7540Target,
195	uint256 amt
196	) public virtual returns (bool) {
197	// Skip 0
198	if (amt == 0) {
199	return true;
200	}
201
202	uint256 maxDep = IERC7540Like(erc7540Target).maxWithdraw(actor);
203
204	uint256 sum = maxDep + amt;
205	if (sum == 0) {
206	return true; // Needs to be greater than 0
207	}
208
209	try IERC7540Like(erc7540Target).withdraw(maxDep + amt, actor, actor) {
210	return false;
211	} catch {
212	// We want this to be hit
213	return true; // So we explicitly return here, as a means to ensure that this is the code path
214	}
215
216	// NOTE: This code path is never hit per the above
217	}
218
219	function erc7540_4_redeem(
220	address erc7540Target,
221	uint256 amt
222	) public virtual returns (bool) {
223	// Skip 0
224	if (amt == 0) {
225	return true;
226	}
227
228	uint256 maxDep = IERC7540Like(erc7540Target).maxRedeem(actor);
229
230	uint256 sum = maxDep + amt;
231	if (sum == 0) {
232	return true; // Needs to be greater than 0
233	}
234
235	try IERC7540Like(erc7540Target).redeem(maxDep + amt, actor, actor) {
236	return false;
237	} catch {
238	// We want this to be hit
239	return true; // So we explicitly return here, as a means to ensure that this is the code path
240	}
241
242	// NOTE: This code path is never hit per the above
243	}
244
245	/// == END erc7540_4 == //
246
247	/// @dev 7540-5 requestRedeem reverts if the share balance is less than amount
248	function erc7540_5(
249	address erc7540Target,
250	address shareToken,
251	uint256 shares
252	) public virtual returns (bool) {
253	if (shares == 0) {
254	return true; // Skip
255	}
256
257	uint256 actualBal = IShareLike(shareToken).balanceOf(actor);
258	uint256 balWeWillUse = actualBal + shares;
259
260	if (balWeWillUse == 0) {
261	return true; // Skip
262	}
263
264	try
265	IERC7540Like(erc7540Target).requestRedeem(
266	balWeWillUse,
267	actor,
268	actor,
269	""
270	)
271	{
272	return false;
273	} catch {
274	return true;
275	}
276
277	// NOTE: This code path is never hit per the above
278	}
279
280	/// @dev 7540-6 preview* always reverts
281	function erc7540_6(address erc7540Target) public virtual returns (bool) {
282	// preview* always reverts
283	try IERC7540Like(erc7540Target).previewDeposit(0) {
284	return false;
285	} catch {}
286	try IERC7540Like(erc7540Target).previewMint(0) {
287	return false;
288	} catch {}
289	try IERC7540Like(erc7540Target).previewRedeem(0) {
290	return false;
291	} catch {}
292	try IERC7540Like(erc7540Target).previewWithdraw(0) {
293	return false;
294	} catch {}
295
296	return true;
297	}
298
299	/// == erc7540_7 == //
300
301	/// @dev 7540-7 if max[method] > 0, then [method] (max) should not revert
302	function erc7540_7_deposit(
303	address erc7540Target,
304	uint256 amt
305	) public virtual returns (bool) {
306	// Per erc7540_4
307	uint256 maxDeposit = IERC7540Like(erc7540Target).maxDeposit(actor);
308	amt = between(amt, 0, maxDeposit);
309
310	if (amt == 0) {
311	return true; // Skip
312	}
313
314	try IERC7540Like(erc7540Target).deposit(amt, actor) {
315	// Success here
316	return true;
317	} catch {
318	return false;
319	}
320
321	// NOTE: This code path is never hit per the above
322	}
323
324	function erc7540_7_mint(
325	address erc7540Target,
326	uint256 amt
327	) public virtual returns (bool) {
328	uint256 maxMint = IERC7540Like(erc7540Target).maxMint(actor);
329	amt = between(amt, 0, maxMint);
330
331	if (amt == 0) {
332	return true; // Skip
333	}
334
335	try IERC7540Like(erc7540Target).mint(amt, actor) {
336	// Success here
337	return true;
338	} catch {
339	return false;
340	}
341
342	// NOTE: This code path is never hit per the above
343	}
344
345	function erc7540_7_withdraw(
346	address erc7540Target,
347	uint256 amt
348	) public virtual returns (bool) {
349	uint256 maxWithdraw = IERC7540Like(erc7540Target).maxWithdraw(actor);
350	amt = between(amt, 0, maxWithdraw);
351
352	if (amt == 0) {
353	return true; // Skip
354	}
355
356	try IERC7540Like(erc7540Target).withdraw(amt, actor, actor) {
357	// Success here
358	return true;
359	} catch {
360	return false;
361	}
362
363	// NOTE: This code path is never hit per the above
364	}
365
366	function erc7540_7_redeem(
367	address erc7540Target,
368	uint256 amt
369	) public virtual returns (bool) {
370	// Per erc7540_4
371	uint256 maxRedeem = IERC7540Like(erc7540Target).maxRedeem(actor);
372	amt = between(amt, 0, maxRedeem);
373
374	if (amt == 0) {
375	return true; // Skip
376	}
377
378	try IERC7540Like(erc7540Target).redeem(amt, actor, actor) {
379	return true;
380	} catch {
381	return false;
382	}
383
384	// NOTE: This code path is never hit per the above
385	}
386
387	/// == END erc7540_7 == //
388	}
389

1	// SPDX-License-Identifier: MIT
2	// OpenZeppelin Contracts (last updated v5.3.0) (proxy/utils/Initializable.sol)
3
4	pragma solidity ^0.8.20;
5
6	/**
7	* @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
8	* behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
9	* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
10	* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
11	*
12	* The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
13	* reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
14	* case an upgrade adds a module that needs to be initialized.
15	*
16	* For example:
17	*
18	* [.hljs-theme-light.nopadding]
19	* ```solidity
20	* contract MyToken is ERC20Upgradeable {
21	* function initialize() initializer public {
22	* __ERC20_init("MyToken", "MTK");
23	* }
24	* }
25	*
26	* contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
27	* function initializeV2() reinitializer(2) public {
28	* __ERC20Permit_init("MyToken");
29	* }
30	* }
31	* ```
32	*
33	* TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
34	* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
35	*
36	* CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
37	* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
38	*
39	* [CAUTION]
40	* ====
41	* Avoid leaving a contract uninitialized.
42	*
43	* An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
44	* contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
45	* the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
46	*
47	* [.hljs-theme-light.nopadding]
48	* ```
49	* /// @custom:oz-upgrades-unsafe-allow constructor
50	* constructor() {
51	* _disableInitializers();
52	* }
53	* ```
54	* ====
55	*/
56	abstract contract Initializable {
57	/**
58	* @dev Storage of the initializable contract.
59	*
60	* It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions
61	* when using with upgradeable contracts.
62	*
63	* @custom:storage-location erc7201:openzeppelin.storage.Initializable
64	*/
65	struct InitializableStorage {
66	/**
67	* @dev Indicates that the contract has been initialized.
68	*/
69	uint64 _initialized;
70	/**
71	* @dev Indicates that the contract is in the process of being initialized.
72	*/
73	bool _initializing;
74	}
75
76	// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Initializable")) - 1)) & ~bytes32(uint256(0xff))
77	bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;
78
79	/**
80	* @dev The contract is already initialized.
81	*/
82	error InvalidInitialization();
83
84	/**
85	* @dev The contract is not initializing.
86	*/
87	error NotInitializing();
88
89	/**
90	* @dev Triggered when the contract has been initialized or reinitialized.
91	*/
92	event Initialized(uint64 version);
93
94	/**
95	* @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
96	* `onlyInitializing` functions can be used to initialize parent contracts.
97	*
98	* Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any
99	* number of times. This behavior in the constructor can be useful during testing and is not expected to be used in
100	* production.
101	*
102	* Emits an {Initialized} event.
103	*/
104	modifier initializer() {
105	// solhint-disable-next-line var-name-mixedcase
106	InitializableStorage storage $ = _getInitializableStorage();
107
108	// Cache values to avoid duplicated sloads
109	bool isTopLevelCall = !$._initializing;
110	uint64 initialized = $._initialized;
111
112	// Allowed calls:
113	// - initialSetup: the contract is not in the initializing state and no previous version was
114	// initialized
115	// - construction: the contract is initialized at version 1 (no reinitialization) and the
116	// current contract is just being deployed
117	bool initialSetup = initialized == 0 && isTopLevelCall;
118	bool construction = initialized == 1 && address(this).code.length == 0;
119
120	if (!initialSetup && !construction) {
121	revert InvalidInitialization();
122	}
123	$._initialized = 1;
124	if (isTopLevelCall) {
125	$._initializing = true;
126	}
127	_;
128	if (isTopLevelCall) {
129	$._initializing = false;
130	emit Initialized(1);
131	}
132	}
133
134	/**
135	* @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
136	* contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
137	* used to initialize parent contracts.
138	*
139	* A reinitializer may be used after the original initialization step. This is essential to configure modules that
140	* are added through upgrades and that require initialization.
141	*
142	* When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
143	* cannot be nested. If one is invoked in the context of another, execution will revert.
144	*
145	* Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
146	* a contract, executing them in the right order is up to the developer or operator.
147	*
148	* WARNING: Setting the version to 2**64 - 1 will prevent any future reinitialization.
149	*
150	* Emits an {Initialized} event.
151	*/
152	modifier reinitializer(uint64 version) {
153	// solhint-disable-next-line var-name-mixedcase
154	InitializableStorage storage $ = _getInitializableStorage();
155
156	if ($._initializing \|\| $._initialized >= version) {
157	revert InvalidInitialization();
158	}
159	$._initialized = version;
160	$._initializing = true;
161	_;
162	$._initializing = false;
163	emit Initialized(version);
164	}
165
166	/**
167	* @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
168	* {initializer} and {reinitializer} modifiers, directly or indirectly.
169	*/
170	modifier onlyInitializing() {
171	_checkInitializing();
172	_;
173	}
174
175	/**
176	* @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}.
177	*/
178	function _checkInitializing() internal view virtual {
179	if (!_isInitializing()) {
180	revert NotInitializing();
181	}
182	}
183
184	/**
185	* @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
186	* Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
187	* to any version. It is recommended to use this to lock implementation contracts that are designed to be called
188	* through proxies.
189	*
190	* Emits an {Initialized} event the first time it is successfully executed.
191	*/
192	function _disableInitializers() internal virtual {
193	// solhint-disable-next-line var-name-mixedcase
194	InitializableStorage storage $ = _getInitializableStorage();
195
196	if ($._initializing) {
197	revert InvalidInitialization();
198	}
199	if ($._initialized != type(uint64).max) {
200	$._initialized = type(uint64).max;
201	emit Initialized(type(uint64).max);
202	}
203	}
204
205	/**
206	* @dev Returns the highest version that has been initialized. See {reinitializer}.
207	*/
208	function _getInitializedVersion() internal view returns (uint64) {
209	return _getInitializableStorage()._initialized;
210	}
211
212	/**
213	* @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
214	*/
215	function _isInitializing() internal view returns (bool) {
216	return _getInitializableStorage()._initializing;
217	}
218
219	/**
220	* @dev Pointer to storage slot. Allows integrators to override it with a custom storage location.
221	*
222	* NOTE: Consider following the ERC-7201 formula to derive storage locations.
223	*/
224	function _initializableStorageSlot() internal pure virtual returns (bytes32) {
225	return INITIALIZABLE_STORAGE;
226	}
227
228	/**
229	* @dev Returns a pointer to the storage namespace.
230	*/
231	// solhint-disable-next-line var-name-mixedcase
232	function _getInitializableStorage() private pure returns (InitializableStorage storage $) {
233	bytes32 slot = _initializableStorageSlot();
234	assembly {
235	$.slot := slot
236	}
237	}
238	}
239

1	// SPDX-License-Identifier: MIT
2	pragma solidity ^0.8.0;
3
4	abstract contract Asserts {
5	function gt(uint256 a, uint256 b, string memory reason) internal virtual;
6
7	function gte(uint256 a, uint256 b, string memory reason) internal virtual;
8
9	function lt(uint256 a, uint256 b, string memory reason) internal virtual;
10
11	function lte(uint256 a, uint256 b, string memory reason) internal virtual;
12
13	function eq(uint256 a, uint256 b, string memory reason) internal virtual;
14
15	function t(bool b, string memory reason) internal virtual;
16
17	function between(uint256 value, uint256 low, uint256 high) internal virtual returns (uint256);
18
19	function between(int256 value, int256 low, int256 high) internal virtual returns (int256);
20
21	function precondition(bool p) internal virtual;
22	}
23

1	// SPDX-License-Identifier: MIT
2	pragma solidity ^0.8.0;
3
4	import {BaseSetup} from "./BaseSetup.sol";
5
6	abstract contract BaseProperties is BaseSetup {}
7

1	// SPDX-License-Identifier: MIT
2	pragma solidity ^0.8.0;
3
4	abstract contract BaseSetup {
5	function setup() internal virtual;
6	}
7

1	// SPDX-License-Identifier: MIT
2	pragma solidity ^0.8.0;
3
4	import {BaseProperties} from "./BaseProperties.sol";
5	import {Asserts} from "./Asserts.sol";
6
7	abstract contract BaseTargetFunctions is BaseProperties, Asserts {}
8

1	// SPDX-License-Identifier: MIT
2	pragma solidity ^0.8.0;
3
4	// slither-disable-start shadowing-local
5
6	interface IHevm {
7	// Set block.timestamp to newTimestamp
8	function warp(uint256 newTimestamp) external;
9
10	// Set block.number to newNumber
11	function roll(uint256 newNumber) external;
12
13	// Add the condition b to the assumption base for the current branch
14	// This function is almost identical to require
15	function assume(bool b) external;
16
17	// Sets the eth balance of usr to amt
18	function deal(address usr, uint256 amt) external;
19
20	// Loads a storage slot from an address
21	function load(address where, bytes32 slot) external returns (bytes32);
22
23	// Stores a value to an address' storage slot
24	function store(address where, bytes32 slot, bytes32 value) external;
25
26	// Signs data (privateKey, digest) => (v, r, s)
27	function sign(uint256 privateKey, bytes32 digest) external returns (uint8 v, bytes32 r, bytes32 s);
28
29	// Gets address for a given private key
30	function addr(uint256 privateKey) external returns (address addr);
31
32	// Performs a foreign function call via terminal
33	function ffi(string[] calldata inputs) external returns (bytes memory result);
34
35	// Performs the next smart contract call with specified `msg.sender`
36	function prank(address newSender) external;
37
38	// Creates a new fork with the given endpoint and the latest block and returns the identifier of the fork
39	function createFork(string calldata urlOrAlias) external returns (uint256);
40
41	// Takes a fork identifier created by createFork and sets the corresponding forked state as active
42	function selectFork(uint256 forkId) external;
43
44	// Returns the identifier of the current fork
45	function activeFork() external returns (uint256);
46
47	// Labels the address in traces
48	function label(address addr, string calldata label) external;
49
50	/// Sets an address' code.
51	function etch(address target, bytes calldata newRuntimeBytecode) external;
52	}
53
54	IHevm constant vm = IHevm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
55
56	// slither-disable-end shadowing-local
57

1	// SPDX-License-Identifier: GPL-2.0
2	pragma solidity ^0.8.0;
3
4	import {BaseSetup} from "@chimera/BaseSetup.sol";
5	import {vm} from "@chimera/Hevm.sol";
6	import {EnumerableSet} from "./EnumerableSet.sol";
7
8	/// @dev This is the source of truth for the actors being used in the test
9	/// @notice No actors should be used in the suite without being added here first
10	abstract contract ActorManager {
11	using EnumerableSet for EnumerableSet.AddressSet;
12
13	///@notice The current actor being used
14	address private _actor;
15
16	///@notice The list of all actors being used
17	EnumerableSet.AddressSet private _actors;
18
19	// If the current target is address(0) then it has not been setup yet and should revert
20	error ActorNotSetup();
21	// Do not allow duplicates
22	error ActorExists();
23	// If the actor does not exist
24	error ActorNotAdded();
25	// Do not allow the default actor
26	error DefaultActor();
27
28	/// @notice address(this) is the default actor
29	constructor() {
30	_actors.add(address(this));
31	_actor = address(this);
32	}
33
34	/// @notice Returns the current active actor
35	function _getActor() internal view returns (address) {
36	return _actor;
37	}
38
39	/// @notice Returns all actors being used
40	function _getActors() internal view returns (address[] memory) {
41	return _actors.values();
42	}
43
44	/// @notice Adds an actor to the list of actors
45	function _addActor(address target) internal {
46	if (_actors.contains(target)) {
47	revert ActorExists();
48	}
49
50	if (target == address(this)) {
51	revert DefaultActor();
52	}
53
54	_actors.add(target);
55	}
56
57	/// @notice Removes an actor from the list of actors
58	function _removeActor(address target) internal {
59	if (!_actors.contains(target)) {
60	revert ActorNotAdded();
61	}
62
63	if (target == address(this)) {
64	revert DefaultActor();
65	}
66
67	_actors.remove(target);
68	}
69
70	/// @dev Expose this in the `TargetFunctions` contract to let the fuzzer switch actors
71	/// NOTE: We revert if the entropy is greater than the number of actors, for Halmos compatibility
72	/// @dev This may reduce fuzzing performance if using multiple actors, if so add explicitly clamped handlers to ManagersTargets using the index of all added actors
73	/// @notice Switches the current actor based on the entropy
74	/// @param entropy The entropy to choose a random actor in the array for switching
75	/// @return target The new active actor
76	function _switchActor(uint256 entropy) internal returns (address target) {
77	target = _actors.at(entropy);
78	_actor = target;
79	}
80	}
81

1	// SPDX-License-Identifier: MIT
2	// OpenZeppelin Contracts (last updated v4.9.0) (utils/structs/EnumerableSet.sol)
3	// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.
4
5	pragma solidity ^0.8.0;
6
7	/**
8	* @dev Library for managing
9	* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
10	* types.
11	*
12	* Sets have the following properties:
13	*
14	* - Elements are added, removed, and checked for existence in constant time
15	* (O(1)).
16	* - Elements are enumerated in O(n). No guarantees are made on the ordering.
17	*
18	* ```solidity
19	* contract Example {
20	* // Add the library methods
21	* using EnumerableSet for EnumerableSet.AddressSet;
22	*
23	* // Declare a set state variable
24	* EnumerableSet.AddressSet private mySet;
25	* }
26	* ```
27	*
28	* As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
29	* and `uint256` (`UintSet`) are supported.
30	*
31	* [WARNING]
32	* ====
33	* Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
34	* unusable.
35	* See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
36	*
37	* In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
38	* array of EnumerableSet.
39	* ====
40	*/
41	library EnumerableSet {
42	// To implement this library for multiple types with as little code
43	// repetition as possible, we write it in terms of a generic Set type with
44	// bytes32 values.
45	// The Set implementation uses private functions, and user-facing
46	// implementations (such as AddressSet) are just wrappers around the
47	// underlying Set.
48	// This means that we can only create new EnumerableSets for types that fit
49	// in bytes32.
50
51	struct Set {
52	// Storage of set values
53	bytes32[] _values;
54	// Position of the value in the `values` array, plus 1 because index 0
55	// means a value is not in the set.
56	mapping(bytes32 => uint256) _indexes;
57	}
58
59	/**
60	* @dev Add a value to a set. O(1).
61	*
62	* Returns true if the value was added to the set, that is if it was not
63	* already present.
64	*/
65	function _add(Set storage set, bytes32 value) private returns (bool) {
66	if (!_contains(set, value)) {
67	set._values.push(value);
68	// The value is stored at length-1, but we add 1 to all indexes
69	// and use 0 as a sentinel value
70	set._indexes[value] = set._values.length;
71	return true;
72	} else {
73	return false;
74	}
75	}
76
77	/**
78	* @dev Removes a value from a set. O(1).
79	*
80	* Returns true if the value was removed from the set, that is if it was
81	* present.
82	*/
83	function _remove(Set storage set, bytes32 value) private returns (bool) {
84	// We read and store the value's index to prevent multiple reads from the same storage slot
85	uint256 valueIndex = set._indexes[value];
86
87	if (valueIndex != 0) {
88	// Equivalent to contains(set, value)
89	// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
90	// the array, and then remove the last element (sometimes called as 'swap and pop').
91	// This modifies the order of the array, as noted in {at}.
92
93	uint256 toDeleteIndex = valueIndex - 1;
94	uint256 lastIndex = set._values.length - 1;
95
96	if (lastIndex != toDeleteIndex) {
97	bytes32 lastValue = set._values[lastIndex];
98
99	// Move the last value to the index where the value to delete is
100	set._values[toDeleteIndex] = lastValue;
101	// Update the index for the moved value
102	set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
103	}
104
105	// Delete the slot where the moved value was stored
106	set._values.pop();
107
108	// Delete the index for the deleted slot
109	delete set._indexes[value];
110
111	return true;
112	} else {
113	return false;
114	}
115	}
116
117	/**
118	* @dev Returns true if the value is in the set. O(1).
119	*/
120	function _contains(Set storage set, bytes32 value) private view returns (bool) {
121	return set._indexes[value] != 0;
122	}
123
124	/**
125	* @dev Returns the number of values on the set. O(1).
126	*/
127	function _length(Set storage set) private view returns (uint256) {
128	return set._values.length;
129	}
130
131	/**
132	* @dev Returns the value stored at position `index` in the set. O(1).
133	*
134	* Note that there are no guarantees on the ordering of values inside the
135	* array, and it may change when more values are added or removed.
136	*
137	* Requirements:
138	*
139	* - `index` must be strictly less than {length}.
140	*/
141	function _at(Set storage set, uint256 index) private view returns (bytes32) {
142	return set._values[index];
143	}
144
145	/**
146	* @dev Return the entire set in an array
147	*
148	* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
149	* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
150	* this function has an unbounded cost, and using it as part of a state-changing function may render the function
151	* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
152	*/
153	function _values(Set storage set) private view returns (bytes32[] memory) {
154	return set._values;
155	}
156
157	// Bytes32Set
158
159	struct Bytes32Set {
160	Set _inner;
161	}
162
163	/**
164	* @dev Add a value to a set. O(1).
165	*
166	* Returns true if the value was added to the set, that is if it was not
167	* already present.
168	*/
169	function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
170	return _add(set._inner, value);
171	}
172
173	/**
174	* @dev Removes a value from a set. O(1).
175	*
176	* Returns true if the value was removed from the set, that is if it was
177	* present.
178	*/
179	function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
180	return _remove(set._inner, value);
181	}
182
183	/**
184	* @dev Returns true if the value is in the set. O(1).
185	*/
186	function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
187	return _contains(set._inner, value);
188	}
189
190	/**
191	* @dev Returns the number of values in the set. O(1).
192	*/
193	function length(Bytes32Set storage set) internal view returns (uint256) {
194	return _length(set._inner);
195	}
196
197	/**
198	* @dev Returns the value stored at position `index` in the set. O(1).
199	*
200	* Note that there are no guarantees on the ordering of values inside the
201	* array, and it may change when more values are added or removed.
202	*
203	* Requirements:
204	*
205	* - `index` must be strictly less than {length}.
206	*/
207	function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
208	return _at(set._inner, index);
209	}
210
211	/**
212	* @dev Return the entire set in an array
213	*
214	* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
215	* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
216	* this function has an unbounded cost, and using it as part of a state-changing function may render the function
217	* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
218	*/
219	function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
220	bytes32[] memory store = _values(set._inner);
221	bytes32[] memory result;
222
223	/// @solidity memory-safe-assembly
224	assembly {
225	result := store
226	}
227
228	return result;
229	}
230
231	// AddressSet
232
233	struct AddressSet {
234	Set _inner;
235	}
236
237	/**
238	* @dev Add a value to a set. O(1).
239	*
240	* Returns true if the value was added to the set, that is if it was not
241	* already present.
242	*/
243	function add(AddressSet storage set, address value) internal returns (bool) {
244	return _add(set._inner, bytes32(uint256(uint160(value))));
245	}
246
247	/**
248	* @dev Removes a value from a set. O(1).
249	*
250	* Returns true if the value was removed from the set, that is if it was
251	* present.
252	*/
253	function remove(AddressSet storage set, address value) internal returns (bool) {
254	return _remove(set._inner, bytes32(uint256(uint160(value))));
255	}
256
257	/**
258	* @dev Returns true if the value is in the set. O(1).
259	*/
260	function contains(AddressSet storage set, address value) internal view returns (bool) {
261	return _contains(set._inner, bytes32(uint256(uint160(value))));
262	}
263
264	/**
265	* @dev Returns the number of values in the set. O(1).
266	*/
267	function length(AddressSet storage set) internal view returns (uint256) {
268	return _length(set._inner);
269	}
270
271	/**
272	* @dev Returns the value stored at position `index` in the set. O(1).
273	*
274	* Note that there are no guarantees on the ordering of values inside the
275	* array, and it may change when more values are added or removed.
276	*
277	* Requirements:
278	*
279	* - `index` must be strictly less than {length}.
280	*/
281	function at(AddressSet storage set, uint256 index) internal view returns (address) {
282	return address(uint160(uint256(_at(set._inner, index))));
283	}
284
285	/**
286	* @dev Return the entire set in an array
287	*
288	* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
289	* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
290	* this function has an unbounded cost, and using it as part of a state-changing function may render the function
291	* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
292	*/
293	function values(AddressSet storage set) internal view returns (address[] memory) {
294	bytes32[] memory store = _values(set._inner);
295	address[] memory result;
296
297	/// @solidity memory-safe-assembly
298	assembly {
299	result := store
300	}
301
302	return result;
303	}
304
305	// UintSet
306
307	struct UintSet {
308	Set _inner;
309	}
310
311	/**
312	* @dev Add a value to a set. O(1).
313	*
314	* Returns true if the value was added to the set, that is if it was not
315	* already present.
316	*/
317	function add(UintSet storage set, uint256 value) internal returns (bool) {
318	return _add(set._inner, bytes32(value));
319	}
320
321	/**
322	* @dev Removes a value from a set. O(1).
323	*
324	* Returns true if the value was removed from the set, that is if it was
325	* present.
326	*/
327	function remove(UintSet storage set, uint256 value) internal returns (bool) {
328	return _remove(set._inner, bytes32(value));
329	}
330
331	/**
332	* @dev Returns true if the value is in the set. O(1).
333	*/
334	function contains(UintSet storage set, uint256 value) internal view returns (bool) {
335	return _contains(set._inner, bytes32(value));
336	}
337
338	/**
339	* @dev Returns the number of values in the set. O(1).
340	*/
341	function length(UintSet storage set) internal view returns (uint256) {
342	return _length(set._inner);
343	}
344
345	/**
346	* @dev Returns the value stored at position `index` in the set. O(1).
347	*
348	* Note that there are no guarantees on the ordering of values inside the
349	* array, and it may change when more values are added or removed.
350	*
351	* Requirements:
352	*
353	* - `index` must be strictly less than {length}.
354	*/
355	function at(UintSet storage set, uint256 index) internal view returns (uint256) {
356	return uint256(_at(set._inner, index));
357	}
358
359	/**
360	* @dev Return the entire set in an array
361	*
362	* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
363	* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
364	* this function has an unbounded cost, and using it as part of a state-changing function may render the function
365	* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
366	*/
367	function values(UintSet storage set) internal view returns (uint256[] memory) {
368	bytes32[] memory store = _values(set._inner);
369	uint256[] memory result;
370
371	/// @solidity memory-safe-assembly
372	assembly {
373	result := store
374	}
375
376	return result;
377	}
378	}
379

1	// SPDX-License-Identifier: AGPL-3.0-only
2	pragma solidity ^0.8.0;
3
4	/// @notice Modern and gas efficient ERC20 + EIP-2612 implementation.
5	/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC20.sol)
6	/// @author Modified from Uniswap (https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol)
7	/// @dev Do not manually set balances without updating totalSupply, as the sum of all user balances must not exceed it.
8	abstract contract ERC20 {
9	/*//////////////////////////////////////////////////////////////
10	ERRORS
11	//////////////////////////////////////////////////////////////*/
12
13	/// @notice Thrown when attempting to transfer more tokens than available balance
14	error InsufficientBalance(address from, uint256 balance, uint256 amount);
15
16	/// @notice Thrown when attempting to transfer more tokens than allowed
17	error InsufficientAllowance(address owner, address spender, uint256 allowance, uint256 amount);
18
19	/// @notice Thrown when minting would cause overflow
20	error MintOverflow(uint256 currentSupply, uint256 amount);
21
22	/*//////////////////////////////////////////////////////////////
23	EVENTS
24	//////////////////////////////////////////////////////////////*/
25
26	event Transfer(address indexed from, address indexed to, uint256 amount);
27
28	event Approval(address indexed owner, address indexed spender, uint256 amount);
29
30	/*//////////////////////////////////////////////////////////////
31	METADATA STORAGE
32	//////////////////////////////////////////////////////////////*/
33
34	string public name;
35
36	string public symbol;
37
38	uint8 public immutable decimals;
39
40	/*//////////////////////////////////////////////////////////////
41	ERC20 STORAGE
42	//////////////////////////////////////////////////////////////*/
43
44	uint256 public totalSupply;
45
46	mapping(address => uint256) public balanceOf;
47
48	mapping(address => mapping(address => uint256)) public allowance;
49
50	/*//////////////////////////////////////////////////////////////
51	EIP-2612 STORAGE
52	//////////////////////////////////////////////////////////////*/
53
54	uint256 internal immutable INITIAL_CHAIN_ID;
55
56	bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;
57
58	mapping(address => uint256) public nonces;
59
60	/*//////////////////////////////////////////////////////////////
61	CONSTRUCTOR
62	//////////////////////////////////////////////////////////////*/
63
64	constructor(string memory _name, string memory _symbol, uint8 _decimals) {
65	name = _name;
66	symbol = _symbol;
67	decimals = _decimals;
68
69	INITIAL_CHAIN_ID = block.chainid;
70	INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();
71	}
72
73	/*//////////////////////////////////////////////////////////////
74	ERC20 LOGIC
75	//////////////////////////////////////////////////////////////*/
76
77	function approve(address spender, uint256 amount) public virtual returns (bool) {
78	allowance[msg.sender][spender] = amount;
79
80	emit Approval(msg.sender, spender, amount);
81
82	return true;
83	}
84
85	function transfer(address to, uint256 amount) public virtual returns (bool) {
86	uint256 fromBalance = balanceOf[msg.sender];
87	if (fromBalance < amount) revert InsufficientBalance(msg.sender, fromBalance, amount);
88
89	balanceOf[msg.sender] = fromBalance - amount;
90
91	// Cannot overflow because the sum of all user
92	// balances can't exceed the max uint256 value.
93	unchecked {
94	balanceOf[to] += amount;
95	}
96
97	emit Transfer(msg.sender, to, amount);
98
99	return true;
100	}
101
102	function transferFrom(address from, address to, uint256 amount) public virtual returns (bool) {
103	uint256 allowed = allowance[from][msg.sender]; // Saves gas for limited approvals.
104	uint256 fromBalance = balanceOf[from];
105
106	if (allowed != type(uint256).max) {
107	if (allowed < amount) revert InsufficientAllowance(from, msg.sender, allowed, amount);
108	allowance[from][msg.sender] = allowed - amount;
109	}
110
111	if (fromBalance < amount) revert InsufficientBalance(from, fromBalance, amount);
112	balanceOf[from] = fromBalance - amount;
113
114	// Cannot overflow because the sum of all user
115	// balances can't exceed the max uint256 value.
116	unchecked {
117	balanceOf[to] += amount;
118	}
119
120	emit Transfer(from, to, amount);
121
122	return true;
123	}
124
125	/*//////////////////////////////////////////////////////////////
126	EIP-2612 LOGIC
127	//////////////////////////////////////////////////////////////*/
128
129	function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s)
130	public
131	virtual
132	{
133	require(deadline >= block.timestamp, "PERMIT_DEADLINE_EXPIRED");
134
135	// Unchecked because the only math done is incrementing
136	// the owner's nonce which cannot realistically overflow.
137	unchecked {
138	address recoveredAddress = ecrecover(
139	keccak256(
140	abi.encodePacked(
141	"\x19\x01",
142	DOMAIN_SEPARATOR(),
143	keccak256(
144	abi.encode(
145	keccak256(
146	"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
147	),
148	owner,
149	spender,
150	value,
151	nonces[owner]++,
152	deadline
153	)
154	)
155	)
156	),
157	v,
158	r,
159	s
160	);
161
162	require(recoveredAddress != address(0) && recoveredAddress == owner, "INVALID_SIGNER");
163
164	allowance[recoveredAddress][spender] = value;
165	}
166
167	emit Approval(owner, spender, value);
168	}
169
170	function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
171	return block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator();
172	}
173
174	function computeDomainSeparator() internal view virtual returns (bytes32) {
175	return keccak256(
176	abi.encode(
177	keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
178	keccak256(bytes(name)),
179	keccak256("1"),
180	block.chainid,
181	address(this)
182	)
183	);
184	}
185
186	/*//////////////////////////////////////////////////////////////
187	INTERNAL MINT/BURN LOGIC
188	//////////////////////////////////////////////////////////////*/
189
190	function _mint(address to, uint256 amount) internal virtual {
191	uint256 newTotalSupply = totalSupply + amount;
192	if (newTotalSupply < totalSupply) revert MintOverflow(totalSupply, amount);
193	totalSupply = newTotalSupply;
194
195	// Cannot overflow because the sum of all user
196	// balances can't exceed the max uint256 value.
197	unchecked {
198	balanceOf[to] += amount;
199	}
200
201	emit Transfer(address(0), to, amount);
202	}
203
204	function _burn(address from, uint256 amount) internal virtual {
205	uint256 fromBalance = balanceOf[from];
206	if (fromBalance < amount) revert InsufficientBalance(from, fromBalance, amount);
207
208	balanceOf[from] = fromBalance - amount;
209
210	// Cannot underflow because a user's balance
211	// will never be larger than the total supply.
212	unchecked {
213	totalSupply -= amount;
214	}
215
216	emit Transfer(from, address(0), amount);
217	}
218	}
219
220	contract MockERC20 is ERC20 {
221	constructor(string memory _name, string memory _symbol, uint8 _decimals) ERC20(_name, _symbol, _decimals) {}
222
223	function mint(address to, uint256 value) public virtual {
224	_mint(to, value);
225	}
226
227	function burn(address from, uint256 value) public virtual {
228	_burn(from, value);
229	}
230	}
231

1	// SPDX-License-Identifier: GPL-2.0
2	pragma solidity ^0.8.0;
3
4	library Panic {
5	// compiler panics
6	string constant assertionPanic = "Panic(1)";
7	string constant arithmeticPanic = "Panic(17)";
8	string constant divisionPanic = "Panic(18)";
9	string constant enumPanic = "Panic(33)";
10	string constant arrayPanic = "Panic(34)";
11	string constant emptyArrayPanic = "Panic(49)";
12	string constant outOfBoundsPanic = "Panic(50)";
13	string constant memoryPanic = "Panic(65)";
14	string constant functionPanic = "Panic(81)";
15	}
16

1	// SPDX-License-Identifier: GPL-2.0
2	pragma solidity ^0.8.0;
3
4	import {Panic} from "./Panic.sol";
5
6	contract Utils {
7	/// @dev check if the error returned from a call is the same as the expected error
8	/// @param err the error returned from a call
9	/// @param expected the expected error
10	/// @return true if the error is the same as the expected error, false otherwise
11	function checkError(bytes memory err, string memory expected) internal pure returns (bool) {
12	(string memory revertMsg, bool customError) = _getRevertMsg(err);
13
14	bytes32 errorBytes;
15	bytes32 expectedBytes;
16
17	if (customError) {
18	// Custom error returns the keccak256 hash of the error, so don't need to hash it again
19	errorBytes = bytes32(abi.encodePacked(revertMsg, bytes28(0)));
20	expectedBytes = bytes4(keccak256(abi.encodePacked(expected)));
21	} else {
22	errorBytes = keccak256(abi.encodePacked(revertMsg));
23	expectedBytes = keccak256(abi.encodePacked(expected));
24	}
25
26	// Check if error contains expected string
27	return errorBytes == expectedBytes;
28	}
29
30	/// @dev get the revert message from a call
31	/// @notice based on https://ethereum.stackexchange.com/a/83577
32	/// @param returnData the return data from a call
33	/// @return the revert message and a boolean indicating if it's a custom error
34	function _getRevertMsg(bytes memory returnData) internal pure returns (string memory, bool) {
35	// If the returnData length is 0, then the transaction failed silently (without a revert message)
36	if (returnData.length == 0) return ("", false);
37
38	// 1. Panic(uint256)
39	// Check that the data has the right size: 4 bytes for signature + 32 bytes for panic code
40	if (returnData.length == 4 + 32) {
41	// Check that the data starts with the Panic signature
42	bool panic = _checkIfPanic(returnData);
43
44	if (panic) {
45	return _getPanicCode(returnData);
46	}
47	}
48
49	// Get the error selector from returnData
50	bytes4 errorSelector = _getErrorSelector(returnData);
51
52	// 2. Error(string) - If it's a standard revert string
53	bytes4 errorStringSelector = bytes4(keccak256("Error(string)")); // Get the standard Error(string) selector
54
55	if (errorSelector == errorStringSelector) {
56	assembly {
57	// slice the sighash of the error so we can decode the string
58	returnData := add(returnData, 0x04)
59	}
60	return (abi.decode(returnData, (string)), false);
61	}
62
63	// 3. Custom error - Return the custom error selector as a string
64	return (string(abi.encodePacked(errorSelector)), true);
65	}
66
67	function _checkIfPanic(bytes memory returnData) internal pure returns (bool) {
68	bytes4 panicSignature = bytes4(keccak256(bytes("Panic(uint256)")));
69
70	for (uint256 i = 0; i < 4; i++) {
71	if (returnData[i] != panicSignature[i]) {
72	return false;
73	}
74	}
75
76	return true;
77	}
78
79	function _getPanicCode(bytes memory returnData) internal pure returns (string memory, bool) {
80	uint256 panicCode;
81	for (uint256 i = 4; i < 36; i++) {
82	panicCode = panicCode << 8;
83	panicCode \|= uint8(returnData[i]);
84	}
85
86	// Convert the panic code into its string representation
87	if (panicCode == 1) {
88	// call assert with an argument that evaluates to false
89	return (Panic.assertionPanic, false);
90	} else if (panicCode == 17) {
91	// arithmetic operation results in underflow or overflow
92	return (Panic.arithmeticPanic, false);
93	} else if (panicCode == 18) {
94	// division or modulo by zero
95	return (Panic.divisionPanic, false);
96	} else if (panicCode == 33) {
97	// converting a value that's too big or negative into an enum type
98	return (Panic.enumPanic, false);
99	} else if (panicCode == 34) {
100	// access a storage byte array that is incorrectly encoded
101	return (Panic.arrayPanic, false);
102	} else if (panicCode == 49) {
103	// call .pop() on an empty array
104	return (Panic.emptyArrayPanic, false);
105	} else if (panicCode == 50) {
106	// array access out of bounds
107	return (Panic.outOfBoundsPanic, false);
108	} else if (panicCode == 65) {
109	// allocate too much memory or create an array that is too large
110	return (Panic.memoryPanic, false);
111	} else if (panicCode == 81) {
112	// call a zero-initialized variable of internal function type
113	return (Panic.functionPanic, false);
114	}
115
116	return ("Undefined panic code", false);
117	}
118
119	function _getErrorSelector(bytes memory returnData) internal pure returns (bytes4 errorSelector) {
120	assembly {
121	errorSelector := mload(add(returnData, 0x20))
122	}
123	return errorSelector;
124	}
125	}
126

1	// SPDX-License-Identifier: MIT
2	pragma solidity >=0.8.23 <0.9.0;
3
4	/* solhint-disable no-unused-import */
5
6	// Types
7	import { CallType, ExecType, ModeCode } from "../lib/ModeLib.sol";
8
9	// Structs
10	struct Execution {
11	address target;
12	uint256 value;
13	bytes callData;
14	}
15
16	interface IERC7579Account {
17	event ModuleInstalled(uint256 moduleTypeId, address module);
18	event ModuleUninstalled(uint256 moduleTypeId, address module);
19
20	/**
21	* @dev Executes a transaction on behalf of the account.
22	* This function is intended to be called by ERC-4337 EntryPoint.sol
23	* @dev Ensure adequate authorization control: i.e. onlyEntryPointOrSelf
24	*
25	* @dev MSA MUST implement this function signature.
26	* If a mode is requested that is not supported by the Account, it MUST revert
27	* @param mode The encoded execution mode of the transaction. See ModeLib.sol for details
28	* @param executionCalldata The encoded execution call data
29	*/
30	function execute(ModeCode mode, bytes calldata executionCalldata) external payable;
31
32	/**
33	* @dev Executes a transaction on behalf of the account.
34	* This function is intended to be called by Executor Modules
35	* @dev Ensure adequate authorization control: i.e. onlyExecutorModule
36	*
37	* @dev MSA MUST implement this function signature.
38	* If a mode is requested that is not supported by the Account, it MUST revert
39	* @param mode The encoded execution mode of the transaction. See ModeLib.sol for details
40	* @param executionCalldata The encoded execution call data
41	*/
42	function executeFromExecutor(
43	ModeCode mode,
44	bytes calldata executionCalldata
45	)
46	external
47	payable
48	returns (bytes[] memory returnData);
49
50	/**
51	* @dev ERC-1271 isValidSignature
52	* This function is intended to be used to validate a smart account signature
53	* and may forward the call to a validator module
54	*
55	* @param hash The hash of the data that is signed
56	* @param data The data that is signed
57	*/
58	function isValidSignature(bytes32 hash, bytes calldata data) external view returns (bytes4);
59
60	/**
61	* @dev installs a Module of a certain type on the smart account
62	* @dev Implement Authorization control of your chosing
63	* @param moduleTypeId the module type ID according the ERC-7579 spec
64	* @param module the module address
65	* @param initData arbitrary data that may be required on the module during `onInstall`
66	* initialization.
67	*/
68	function installModule(
69	uint256 moduleTypeId,
70	address module,
71	bytes calldata initData
72	)
73	external
74	payable;
75
76	/**
77	* @dev uninstalls a Module of a certain type on the smart account
78	* @dev Implement Authorization control of your chosing
79	* @param moduleTypeId the module type ID according the ERC-7579 spec
80	* @param module the module address
81	* @param deInitData arbitrary data that may be required on the module during `onUninstall`
82	* de-initialization.
83	*/
84	function uninstallModule(
85	uint256 moduleTypeId,
86	address module,
87	bytes calldata deInitData
88	)
89	external
90	payable;
91
92	/**
93	* Function to check if the account supports a certain CallType or ExecType (see ModeLib.sol)
94	* @param encodedMode the encoded mode
95	*/
96	function supportsExecutionMode(ModeCode encodedMode) external view returns (bool);
97
98	/**
99	* Function to check if the account supports installation of a certain module type Id
100	* @param moduleTypeId the module type ID according the ERC-7579 spec
101	*/
102	function supportsModule(uint256 moduleTypeId) external view returns (bool);
103
104	/**
105	* Function to check if the account has a certain module installed
106	* @param moduleTypeId the module type ID according the ERC-7579 spec
107	* Note: keep in mind that some contracts can be multiple module types at the same time. It
108	* thus may be necessary to query multiple module types
109	* @param module the module address
110	* @param additionalContext additional context data that the smart account may interpret to
111	* identifiy conditions under which the module is installed.
112	* usually this is not necessary, but for some special hooks that
113	* are stored in mappings, this param might be needed
114	*/
115	function isModuleInstalled(
116	uint256 moduleTypeId,
117	address module,
118	bytes calldata additionalContext
119	)
120	external
121	view
122	returns (bool);
123
124	/**
125	* @dev Returns the account id of the smart account
126	* @return accountImplementationId the account id of the smart account
127	* the accountId should be structured like so:
128	* "vendorname.accountname.semver"
129	*/
130	function accountId() external view returns (string memory accountImplementationId);
131	}
132

1	// SPDX-License-Identifier: GPL-3.0
2	pragma solidity >=0.8.0 <0.9.0;
3
4	/**
5	* @title ModeLib
6	* @author rhinestone \| zeroknots.eth, Konrad Kopp (@kopy-kat)
7	* To allow smart accounts to be very simple, but allow for more complex execution, A custom mode
8	* encoding is used.
9	* Function Signature of execute function:
10	* function execute(ModeCode mode, bytes calldata executionCalldata) external payable;
11	* This allows for a single bytes32 to be used to encode the execution mode, calltype, execType and
12	* context.
13	* NOTE: Simple Account implementations only have to scope for the most significant byte. Account that
14	* implement
15	* more complex execution modes may use the entire bytes32.
16	*
17	* \|--------------------------------------------------------------------\|
18	* \| CALLTYPE \| EXECTYPE \| UNUSED \| ModeSelector \| ModePayload \|
19	* \|--------------------------------------------------------------------\|
20	* \| 1 byte \| 1 byte \| 4 bytes \| 4 bytes \| 22 bytes \|
21	* \|--------------------------------------------------------------------\|
22	*
23	* CALLTYPE: 1 byte
24	* CallType is used to determine how the executeCalldata paramter of the execute function has to be
25	* decoded.
26	* It can be either single, batch or delegatecall. In the future different calls could be added.
27	* CALLTYPE can be used by a validation module to determine how to decode <userOp.callData[36:]>.
28	*
29	* EXECTYPE: 1 byte
30	* ExecType is used to determine how the account should handle the execution.
31	* It can indicate if the execution should revert on failure or continue execution.
32	* In the future more execution modes may be added.
33	* Default Behavior (EXECTYPE = 0x00) is to revert on a single failed execution. If one execution in
34	* a batch fails, the entire batch is reverted
35	*
36	* UNUSED: 4 bytes
37	* Unused bytes are reserved for future use.
38	*
39	* ModeSelector: bytes4
40	* The "optional" mode selector can be used by account vendors, to implement custom behavior in
41	* their accounts.
42	* the way a ModeSelector is to be calculated is bytes4(keccak256("vendorname.featurename"))
43	* this is to prevent collisions between different vendors, while allowing innovation and the
44	* development of new features without coordination between ERC-7579 implementing accounts
45	*
46	* ModePayload: 22 bytes
47	* Mode payload is used to pass additional data to the smart account execution, this may be
48	* interpreted depending on the ModeSelector
49	*
50	* ExecutionCallData: n bytes
51	* single, delegatecall or batch exec abi.encoded as bytes
52	*/
53
54	// Custom type for improved developer experience
55	type ModeCode is bytes32;
56
57	type CallType is bytes1;
58
59	type ExecType is bytes1;
60
61	type ModeSelector is bytes4;
62
63	type ModePayload is bytes22;
64
65	// Default CallType
66	CallType constant CALLTYPE_SINGLE = CallType.wrap(0x00);
67	// Batched CallType
68	CallType constant CALLTYPE_BATCH = CallType.wrap(0x01);
69	CallType constant CALLTYPE_STATIC = CallType.wrap(0xFE);
70	// @dev Implementing delegatecall is OPTIONAL!
71	// implement delegatecall with extreme care.
72	CallType constant CALLTYPE_DELEGATECALL = CallType.wrap(0xFF);
73
74	// @dev default behavior is to revert on failure
75	// To allow very simple accounts to use mode encoding, the default behavior is to revert on failure
76	// Since this is value 0x00, no additional encoding is required for simple accounts
77	ExecType constant EXECTYPE_DEFAULT = ExecType.wrap(0x00);
78	// @dev account may elect to change execution behavior. For example "try exec" / "allow fail"
79	ExecType constant EXECTYPE_TRY = ExecType.wrap(0x01);
80
81	ModeSelector constant MODE_DEFAULT = ModeSelector.wrap(bytes4(0x00000000));
82	// Example declaration of a custom mode selector
83	ModeSelector constant MODE_OFFSET = ModeSelector.wrap(bytes4(keccak256("default.mode.offset")));
84
85	/**
86	* @dev ModeLib is a helper library to encode/decode ModeCodes
87	*/
88	library ModeLib {
89	function decode(ModeCode mode)
90	internal
91	pure
92	returns (
93	CallType _calltype,
94	ExecType _execType,
95	ModeSelector _modeSelector,
96	ModePayload _modePayload
97	)
98	{
99	// solhint-disable-next-line no-inline-assembly
100	assembly {
101	_calltype := mode
102	_execType := shl(8, mode)
103	_modeSelector := shl(48, mode)
104	_modePayload := shl(80, mode)
105	}
106	}
107
108	function encode(
109	CallType callType,
110	ExecType execType,
111	ModeSelector mode,
112	ModePayload payload
113	)
114	internal
115	pure
116	returns (ModeCode)
117	{
118	return ModeCode.wrap(
119	bytes32(
120	abi.encodePacked(callType, execType, bytes4(0), ModeSelector.unwrap(mode), payload)
121	)
122	);
123	}
124
125	function encodeSimpleBatch() internal pure returns (ModeCode mode) {
126	mode = encode(CALLTYPE_BATCH, EXECTYPE_DEFAULT, MODE_DEFAULT, ModePayload.wrap(0x00));
127	}
128
129	function encodeSimpleSingle() internal pure returns (ModeCode mode) {
130	mode = encode(CALLTYPE_SINGLE, EXECTYPE_DEFAULT, MODE_DEFAULT, ModePayload.wrap(0x00));
131	}
132
133	function getCallType(ModeCode mode) internal pure returns (CallType calltype) {
134	// solhint-disable-next-line no-inline-assembly
135	assembly {
136	calltype := mode
137	}
138	}
139	}
140
141	using { eqModeSelector as == } for ModeSelector global;
142	using { eqCallType as == } for CallType global;
143	using { neqCallType as != } for CallType global;
144	using { eqExecType as == } for ExecType global;
145
146	function eqCallType(CallType a, CallType b) pure returns (bool) {
147	return CallType.unwrap(a) == CallType.unwrap(b);
148	}
149
150	function neqCallType(CallType a, CallType b) pure returns (bool) {
151	return CallType.unwrap(a) == CallType.unwrap(b);
152	}
153
154	function eqExecType(ExecType a, ExecType b) pure returns (bool) {
155	return ExecType.unwrap(a) == ExecType.unwrap(b);
156	}
157
158	function eqModeSelector(ModeSelector a, ModeSelector b) pure returns (bool) {
159	return ModeSelector.unwrap(a) == ModeSelector.unwrap(b);
160	}
161

1	// SPDX-License-Identifier: MIT
2	// OpenZeppelin Contracts (last updated v5.3.0) (access/IAccessControl.sol)
3
4	pragma solidity >=0.8.4;
5
6	/**
7	* @dev External interface of AccessControl declared to support ERC-165 detection.
8	*/
9	interface IAccessControl {
10	/**
11	* @dev The `account` is missing a role.
12	*/
13	error AccessControlUnauthorizedAccount(address account, bytes32 neededRole);
14
15	/**
16	* @dev The caller of a function is not the expected one.
17	*
18	* NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.
19	*/
20	error AccessControlBadConfirmation();
21
22	/**
23	* @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
24	*
25	* `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
26	* {RoleAdminChanged} not being emitted to signal this.
27	*/
28	event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
29
30	/**
31	* @dev Emitted when `account` is granted `role`.
32	*
33	* `sender` is the account that originated the contract call. This account bears the admin role (for the granted role).
34	* Expected in cases where the role was granted using the internal {AccessControl-_grantRole}.
35	*/
36	event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
37
38	/**
39	* @dev Emitted when `account` is revoked `role`.
40	*
41	* `sender` is the account that originated the contract call:
42	* - if using `revokeRole`, it is the admin role bearer
43	* - if using `renounceRole`, it is the role bearer (i.e. `account`)
44	*/
45	event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
46
47	/**
48	* @dev Returns `true` if `account` has been granted `role`.
49	*/
50	function hasRole(bytes32 role, address account) external view returns (bool);
51
52	/**
53	* @dev Returns the admin role that controls `role`. See {grantRole} and
54	* {revokeRole}.
55	*
56	* To change a role's admin, use {AccessControl-_setRoleAdmin}.
57	*/
58	function getRoleAdmin(bytes32 role) external view returns (bytes32);
59
60	/**
61	* @dev Grants `role` to `account`.
62	*
63	* If `account` had not been already granted `role`, emits a {RoleGranted}
64	* event.
65	*
66	* Requirements:
67	*
68	* - the caller must have ``role``'s admin role.
69	*/
70	function grantRole(bytes32 role, address account) external;
71
72	/**
73	* @dev Revokes `role` from `account`.
74	*
75	* If `account` had been granted `role`, emits a {RoleRevoked} event.
76	*
77	* Requirements:
78	*
79	* - the caller must have ``role``'s admin role.
80	*/
81	function revokeRole(bytes32 role, address account) external;
82
83	/**
84	* @dev Revokes `role` from the calling account.
85	*
86	* Roles are often managed via {grantRole} and {revokeRole}: this function's
87	* purpose is to provide a mechanism for accounts to lose their privileges
88	* if they are compromised (such as when a trusted device is misplaced).
89	*
90	* If the calling account had been granted `role`, emits a {RoleRevoked}
91	* event.
92	*
93	* Requirements:
94	*
95	* - the caller must be `callerConfirmation`.
96	*/
97	function renounceRole(bytes32 role, address callerConfirmation) external;
98	}
99

1	// SPDX-License-Identifier: MIT
2	// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC1363.sol)
3
4	pragma solidity >=0.6.2;
5
6	import {IERC20} from "./IERC20.sol";
7	import {IERC165} from "./IERC165.sol";
8
9	/**
10	* @title IERC1363
11	* @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].
12	*
13	* Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract
14	* after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.
15	*/
16	interface IERC1363 is IERC20, IERC165 {
17	/*
18	* Note: the ERC-165 identifier for this interface is 0xb0202a11.
19	* 0xb0202a11 ===
20	* bytes4(keccak256('transferAndCall(address,uint256)')) ^
21	* bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
22	* bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
23	* bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^
24	* bytes4(keccak256('approveAndCall(address,uint256)')) ^
25	* bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
26	*/
27
28	/**
29	* @dev Moves a `value` amount of tokens from the caller's account to `to`
30	* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
31	* @param to The address which you want to transfer to.
32	* @param value The amount of tokens to be transferred.
33	* @return A boolean value indicating whether the operation succeeded unless throwing.
34	*/
35	function transferAndCall(address to, uint256 value) external returns (bool);
36
37	/**
38	* @dev Moves a `value` amount of tokens from the caller's account to `to`
39	* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
40	* @param to The address which you want to transfer to.
41	* @param value The amount of tokens to be transferred.
42	* @param data Additional data with no specified format, sent in call to `to`.
43	* @return A boolean value indicating whether the operation succeeded unless throwing.
44	*/
45	function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);
46
47	/**
48	* @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
49	* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
50	* @param from The address which you want to send tokens from.
51	* @param to The address which you want to transfer to.
52	* @param value The amount of tokens to be transferred.
53	* @return A boolean value indicating whether the operation succeeded unless throwing.
54	*/
55	function transferFromAndCall(address from, address to, uint256 value) external returns (bool);
56
57	/**
58	* @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
59	* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
60	* @param from The address which you want to send tokens from.
61	* @param to The address which you want to transfer to.
62	* @param value The amount of tokens to be transferred.
63	* @param data Additional data with no specified format, sent in call to `to`.
64	* @return A boolean value indicating whether the operation succeeded unless throwing.
65	*/
66	function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);
67
68	/**
69	* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
70	* caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
71	* @param spender The address which will spend the funds.
72	* @param value The amount of tokens to be spent.
73	* @return A boolean value indicating whether the operation succeeded unless throwing.
74	*/
75	function approveAndCall(address spender, uint256 value) external returns (bool);
76
77	/**
78	* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
79	* caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
80	* @param spender The address which will spend the funds.
81	* @param value The amount of tokens to be spent.
82	* @param data Additional data with no specified format, sent in call to `spender`.
83	* @return A boolean value indicating whether the operation succeeded unless throwing.
84	*/
85	function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
86	}
87

1	// SPDX-License-Identifier: MIT
2	// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC165.sol)
3
4	pragma solidity >=0.4.16;
5
6	import {IERC165} from "../utils/introspection/IERC165.sol";
7

1	// SPDX-License-Identifier: Apache-2.0
2	pragma solidity 0.8.30;
3
4	// External
5	import { Execution } from "modulekit/accounts/erc7579/lib/ExecutionLib.sol";
6
7	// Superform
8	import { HookDataDecoder } from "../libraries/HookDataDecoder.sol";
9	import { ISuperHook, ISuperHookSetter, ISuperHookResult, ISuperHookInspector } from "../interfaces/ISuperHook.sol";
10
11	/// @title BaseHook
12	/// @author Superform Labs
13	/// @notice Base implementation for all hooks in the Superform system
14	/// @dev Provides core security validation and execution flow management for hooks
15	/// All specialized hooks should inherit from this base contract
16	/// Implements the ISuperHook interface defined lifecycle methods
17	/// Uses a transient storage pattern for stateful execution context
18	abstract contract BaseHook is ISuperHook, ISuperHookSetter, ISuperHookResult, ISuperHookInspector {
19	using HookDataDecoder for bytes;
20
21	/*//////////////////////////////////////////////////////////////
22	STORAGE
23	//////////////////////////////////////////////////////////////*/
24
25	/// @notice The number of shares used by this hook's operation
26	/// @dev Used for accounting and tracking consumption of position shares
27	uint256 public transient usedShares;
28
29	/// @notice The special token address (if any) associated with this hook's operation
30	/// @dev May be used to track token addresses for various operations
31	address public transient spToken;
32
33	/// @notice The primary asset address this hook operates on
34	/// @dev Typically the base token or asset being processed
35	address public transient asset;
36
37	/// @notice Execution nonce for creating unique contexts
38	uint256 public transient executionNonce;
39
40	/// @notice Last execution context caller
41	address public transient lastCaller;
42
43	// Storage offsets for different state variables
44	uint256 private constant OUT_AMOUNT_OFFSET = 1;
45	uint256 private constant PRE_EXECUTE_MUTEX_OFFSET = 2;
46	uint256 private constant POST_EXECUTE_MUTEX_OFFSET = 3;
47
48	/// @notice Base storage key for hook execution state
49	bytes32 private constant HOOK_EXECUTION_STORAGE = keccak256("hook.execution.state");
50
51	/// @notice Storage key for account context mapping
52	bytes32 private constant ACCOUNT_CONTEXT_STORAGE = keccak256("hook.account.context");
53
54	/// @notice The specific subtype identifier for this hook
55	/// @dev Used to identify specialized hook types beyond the basic HookType enum
56	bytes32 public immutable SUB_TYPE;
57
58	/// @notice The type of hook (NONACCOUNTING, INFLOW, OUTFLOW)
59	/// @dev Determines how the hook impacts accounting in the system
60	ISuperHook.HookType public hookType;
61
62	/*//////////////////////////////////////////////////////////////
63	ERRORS
64	//////////////////////////////////////////////////////////////*/
65	/// @notice Thrown when a caller attempts to execute hook methods without proper authorization
66	/// @dev Used by security validation to prevent unauthorized hook execution
67	error NOT_AUTHORIZED();
68
69	/// @notice Thrown when an amount parameter is invalid (e.g., zero or overflow)
70	/// @dev Used in validation checks for asset amounts and share values
71	error AMOUNT_NOT_VALID();
72
73	/// @notice Thrown when an address parameter is invalid (e.g., zero address)
74	/// @dev Used in validation checks for tokens, accounts, and other addresses
75	error ADDRESS_NOT_VALID();
76
77	/// @notice Thrown when a caller is not authorized to execute hook methods
78	/// @dev Used by security validation to prevent unauthorized hook execution
79	error UNAUTHORIZED_CALLER();
80
81	/// @notice Thrown when preExecute is called more than once
82	/// @dev Used to prevent reentrancy attacks and ensure proper execution flow
83	error PRE_EXECUTE_ALREADY_CALLED();
84
85	/// @notice Thrown when postExecute is called more than once
86	/// @dev Used to prevent reentrancy attacks and ensure proper execution flow
87	error POST_EXECUTE_ALREADY_CALLED();
88
89	/// @notice Thrown when a hook execution is incomplete
90	/// @dev Used to prevent incomplete hook execution
91	error INCOMPLETE_HOOK_EXECUTION();
92
93	/// @notice Thrown when trying to set outAmount after preExecute or postExecute
94	/// @dev Used to prevent setting outAmount after preExecute or postExecute
95	error CANNOT_SET_OUT_AMOUNT();
96
97	/// @notice Initializes the hook with its type and subtype
98	/// @dev Sets immutable parameters that define the hook's behavior
99	/// @param hookType_ The type classification for this hook (NONACCOUNTING, INFLOW, OUTFLOW)
100	/// @param subType_ The specific subtype identifier for specialized hook functionality
101	constructor(ISuperHook.HookType hookType_, bytes32 subType_) {
102	hookType = hookType_;
103	SUB_TYPE = subType_;
104	}
105
106	modifier onlyLastCaller() {
107	if (msg.sender != lastCaller) revert UNAUTHORIZED_CALLER();
108	_;
109	}
110
111	/*//////////////////////////////////////////////////////////////
112	EXECUTION SECURITY
113	//////////////////////////////////////////////////////////////*/
114	/// @inheritdoc ISuperHook
115	function setExecutionContext(address caller) external {
116	_createExecutionContext(caller);
117	lastCaller = msg.sender;
118	}
119
120	/// @dev Standard build pattern - MUST include preExecute first, postExecute last
121	/// @inheritdoc ISuperHook
122	function build(
123	address prevHook,
124	address account,
125	bytes calldata hookData
126	)
127	external
128	view
129	virtual
130	returns (Execution[] memory executions)
131	{
132	// Get hook-specific executions
133	Execution[] memory hookExecutions = _buildHookExecutions(prevHook, account, hookData);
134
135	// Always include pre + hook + post
136	executions = new Execution[](hookExecutions.length + 2);
137
138	// FIRST: preExecute
139	executions[0] = Execution({
140	target: address(this),
141	value: 0,
142	callData: abi.encodeCall(this.preExecute, (prevHook, account, hookData))
143	});
144
145	// MIDDLE: hook-specific operations
146	for (uint256 i = 0; i < hookExecutions.length; i++) {
147	executions[i + 1] = hookExecutions[i];
148	}
149
150	// LAST: postExecute
151	executions[executions.length - 1] = Execution({
152	target: address(this),
153	value: 0,
154	callData: abi.encodeCall(this.postExecute, (prevHook, account, hookData))
155	});
156	}
157
158	/// @inheritdoc ISuperHook
159	function preExecute(address prevHook, address account, bytes calldata data) external {
160	if (msg.sender != account) revert UNAUTHORIZED_CALLER();
161	uint256 context = _getCurrentExecutionContext(account);
162	if (_getPreExecuteMutex(context)) revert PRE_EXECUTE_ALREADY_CALLED();
163	_setPreExecuteMutex(context, true);
164	_preExecute(prevHook, account, data);
165	}
166
167	/// @inheritdoc ISuperHook
168	function postExecute(address prevHook, address account, bytes calldata data) external {
169	if (msg.sender != account) revert UNAUTHORIZED_CALLER();
170	uint256 context = _getCurrentExecutionContext(account);
171	if (_getPostExecuteMutex(context)) revert POST_EXECUTE_ALREADY_CALLED();
172	_setPostExecuteMutex(context, true);
173	_postExecute(prevHook, account, data);
174	}
175
176	/// @inheritdoc ISuperHookSetter
177	function setOutAmount(uint256 _outAmount, address caller) external {
178	uint256 context = _getCurrentExecutionContext(caller);
179	if (_getPreExecuteMutex(context) \|\| _getPostExecuteMutex(context)) {
180	revert CANNOT_SET_OUT_AMOUNT();
181	}
182
183	bytes32 key = _makeKey(context, OUT_AMOUNT_OFFSET);
184	assembly {
185	tstore(key, _outAmount)
186	}
187	}
188
189	function getOutAmount(address caller) public view returns (uint256) {
190	return _getOutAmount(_getCurrentExecutionContext(caller));
191	}
192
193	/// @inheritdoc ISuperHook
194	function resetExecutionState(address caller) external onlyLastCaller {
195	uint256 context = _getCurrentExecutionContext(caller);
196	if (!_getPreExecuteMutex(context) \|\| !_getPostExecuteMutex(context)) {
197	revert INCOMPLETE_HOOK_EXECUTION();
198	}
199
200	_clearExecutionState(context);
201	}
202
203	/*//////////////////////////////////////////////////////////////
204	VIEW METHODS
205	//////////////////////////////////////////////////////////////*/
206	/// @inheritdoc ISuperHook
207	function subtype() external view returns (bytes32) {
208	return SUB_TYPE;
209	}
210
211	/// @inheritdoc ISuperHookInspector
212	function inspect(bytes calldata) external view virtual returns (bytes memory) { }
213
214	/*//////////////////////////////////////////////////////////////
215	INTERNAL METHODS
216	//////////////////////////////////////////////////////////////*/
217	/// @notice Internal implementation of build
218	/// @dev Abstract function to be implemented by derived hooks
219	/// Called during build to generate hook-specific execution sequences
220	/// @param prevHook The previous hook in the chain, or address(0) if first hook
221	/// @param account The account that operations will be performed for
222	/// @param data Hook-specific parameters and configuration data
223	/// @return executions Array of execution objects containing target, value, and callData
224	function _buildHookExecutions(
225	address prevHook,
226	address account,
227	bytes calldata data
228	)
229	internal
230	view
231	virtual
232	returns (Execution[] memory executions);
233
234	/// @notice Internal implementation of preExecute
235	/// @dev Abstract function to be implemented by derived hooks
236	/// Called before execution to validate inputs and prepare the hook's state
237	/// Typically sets up the hook context by parsing parameters from data
238	/// May check balances, permissions, or other preconditions
239	/// @param prevHook The previous hook in the chain, or address(0) if first hook
240	/// @param account The account that operations will be performed for
241	/// @param data Hook-specific parameters and configuration data
242	function _preExecute(address prevHook, address account, bytes calldata data) internal virtual { }
243
244	/// @notice Internal implementation of postExecute
245	/// @dev Abstract function to be implemented by derived hooks
246	/// Called after execution to finalize the hook's state and set output values
247	/// Typically calculates final results and sets outAmount, usedShares, etc.
248	/// May perform additional validations on execution results
249	/// @param prevHook The previous hook in the chain, or address(0) if first hook
250	/// @param account The account operations were performed for
251	/// @param data Hook-specific parameters and configuration data
252	function _postExecute(address prevHook, address account, bytes calldata data) internal virtual { }
253
254	/// @notice Decodes a boolean value from a byte array at the specified offset
255	/// @dev Helper function for extracting boolean values from packed data
256	/// Used when parsing hook-specific data parameters
257	/// @param data The byte array containing the encoded data
258	/// @param offset The position in the array to read from
259	/// @return The decoded boolean value (true if byte is non-zero)
260	function _decodeBool(bytes memory data, uint256 offset) internal pure returns (bool) {
261	return data[offset] != 0;
262	}
263
264	/// @notice Replaces an amount value within a byte array at the specified offset
265	/// @dev Used to modify hook calldata for amount adjustments without full re-encoding
266	/// Particularly useful for modifying amounts in multi-hook execution chains
267	/// Directly modifies the bytes in-place for gas efficiency
268	/// @param data The original byte array containing encoded calldata
269	/// @param amount The new amount value to insert
270	/// @param offset The position in the array where the amount starts
271	/// @return The modified byte array with the replaced amount
272	function _replaceCalldataAmount(
273	bytes memory data,
274	uint256 amount,
275	uint256 offset
276	)
277	internal
278	pure
279	returns (bytes memory)
280	{
281	bytes memory newAmountEncoded = abi.encodePacked(amount);
282	for (uint256 i; i < 32; ++i) {
283	data[offset + i] = newAmountEncoded[i];
284	}
285	return data;
286	}
287
288	function _makeAccountContextKey(address account) private pure returns (bytes32) {
289	return keccak256(abi.encodePacked(ACCOUNT_CONTEXT_STORAGE, account));
290	}
291
292	function _createExecutionContext(address caller) private returns (uint256) {
293	// Always increment nonce for new execution context
294	executionNonce++;
295	bytes32 key = _makeAccountContextKey(caller);
296
297	// Store this context for the current caller
298	uint256 currentNonce = executionNonce; // Load into local variable for assembly
299	assembly {
300	tstore(key, currentNonce)
301	}
302
303	return executionNonce;
304	}
305
306	function _getCurrentExecutionContext(address caller) private view returns (uint256 context) {
307	bytes32 key = _makeAccountContextKey(caller);
308	assembly {
309	context := tload(key)
310	}
311	}
312
313	function _makeKey(uint256 context, uint256 offset) private pure returns (bytes32) {
314	return keccak256(abi.encodePacked(HOOK_EXECUTION_STORAGE, context, offset));
315	}
316
317	function _getOutAmount(uint256 context) private view returns (uint256 value) {
318	bytes32 key = _makeKey(context, OUT_AMOUNT_OFFSET);
319	assembly {
320	value := tload(key)
321	}
322	}
323
324	function _setOutAmount(uint256 value, address caller) internal {
325	uint256 context = _getCurrentExecutionContext(caller);
326	bytes32 key = _makeKey(context, OUT_AMOUNT_OFFSET);
327	assembly {
328	tstore(key, value)
329	}
330	}
331
332	function _getPreExecuteMutex(uint256 context) private view returns (bool value) {
333	bytes32 key = _makeKey(context, PRE_EXECUTE_MUTEX_OFFSET);
334	assembly {
335	value := tload(key)
336	}
337	}
338
339	function _setPreExecuteMutex(uint256 context, bool value) private {
340	bytes32 key = _makeKey(context, PRE_EXECUTE_MUTEX_OFFSET);
341	assembly {
342	tstore(key, value)
343	}
344	}
345
346	function _getPostExecuteMutex(uint256 context) private view returns (bool value) {
347	bytes32 key = _makeKey(context, POST_EXECUTE_MUTEX_OFFSET);
348	assembly {
349	value := tload(key)
350	}
351	}
352
353	function _setPostExecuteMutex(uint256 context, bool value) private {
354	bytes32 key = _makeKey(context, POST_EXECUTE_MUTEX_OFFSET);
355	assembly {
356	tstore(key, value)
357	}
358	}
359
360	function _clearExecutionState(uint256 context) private {
361	_setPreExecuteMutex(context, false);
362	_setPostExecuteMutex(context, false);
363	}
364	}
365

1	// SPDX-License-Identifier: Apache-2.0
2	pragma solidity 0.8.30;
3
4	import { BytesLib } from "../vendor/BytesLib.sol";
5
6	/// @title HookDataDecoder
7	/// @author Superform Labs
8	/// @notice Library for decoding hook data
9	library HookDataDecoder {
10	function extractYieldSourceOracleId(bytes memory data) internal pure returns (bytes32) {
11	return bytes32(BytesLib.slice(data, 0, 32));
12	}
13
14	function extractYieldSource(bytes memory data) internal pure returns (address) {
15	return BytesLib.toAddress(data, 32);
16	}
17	}
18

1	// SPDX-License-Identifier: Apache-2.0
2	pragma solidity 0.8.30;
3
4	/// @title HookSubTypes
5	/// @author Superform Labs
6	/// @notice Library for hook subtypes
7	library HookSubTypes {
8	bytes32 public constant BRIDGE = keccak256(bytes("Bridge"));
9	bytes32 public constant CANCEL_DEPOSIT = keccak256(bytes("CancelDeposit"));
10	bytes32 public constant CANCEL_DEPOSIT_REQUEST = keccak256(bytes("CancelDepositRequest"));
11	bytes32 public constant CANCEL_REDEEM = keccak256(bytes("CancelRedeem"));
12	bytes32 public constant CANCEL_REDEEM_REQUEST = keccak256(bytes("CancelRedeemRequest"));
13	bytes32 public constant CLAIM = keccak256(bytes("Claim"));
14	bytes32 public constant CLAIM_CANCEL_DEPOSIT_REQUEST = keccak256(bytes("ClaimCancelDepositRequest"));
15	bytes32 public constant CLAIM_CANCEL_REDEEM_REQUEST = keccak256(bytes("ClaimCancelRedeemRequest"));
16	bytes32 public constant COOLDOWN = keccak256(bytes("Cooldown"));
17	bytes32 public constant ETHENA = keccak256(bytes("Ethena"));
18	bytes32 public constant ERC4626 = keccak256(bytes("ERC4626"));
19	bytes32 public constant ERC5115 = keccak256(bytes("ERC5115"));
20	bytes32 public constant ERC7540 = keccak256(bytes("ERC7540"));
21	bytes32 public constant LOAN = keccak256(bytes("Loan"));
22	bytes32 public constant LOAN_REPAY = keccak256(bytes("LoanRepay"));
23	bytes32 public constant MISC = keccak256(bytes("Misc"));
24	bytes32 public constant STAKE = keccak256(bytes("Stake"));
25	bytes32 public constant SWAP = keccak256(bytes("Swap"));
26	bytes32 public constant TOKEN = keccak256(bytes("Token"));
27	bytes32 public constant UNSTAKE = keccak256(bytes("Unstake"));
28	bytes32 public constant PTYT = keccak256(bytes("PTYT"));
29	bytes32 public constant VAULT_BANK = keccak256(bytes("VaultBank"));
30
31	function getHookSubType(string memory hookSubtype) internal pure returns (bytes32) {
32	return keccak256(bytes(hookSubtype));
33	}
34	}
35

Files

1	// SPDX-License-Identifier: Unlicense
2	/*
3	* @title Solidity Bytes Arrays Utils
4	* @author Gonçalo Sá <goncalo.sa@consensys.net>
5	*
6	* @dev Bytes tightly packed arrays utility library for ethereum contracts written in Solidity.
7	* The library lets you concatenate, slice and type cast bytes arrays both in memory and storage.
8	*/
9	pragma solidity 0.8.30;
10
11	library BytesLib {
12	function concat(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bytes memory) {
13	bytes memory tempBytes;
14
15	assembly {
16	// Get a location of some free memory and store it in tempBytes as
17	// Solidity does for memory variables.
18	tempBytes := mload(0x40)
19
20	// Store the length of the first bytes array at the beginning of
21	// the memory for tempBytes.
22	let length := mload(_preBytes)
23	mstore(tempBytes, length)
24
25	// Maintain a memory counter for the current write location in the
26	// temp bytes array by adding the 32 bytes for the array length to
27	// the starting location.
28	let mc := add(tempBytes, 0x20)
29	// Stop copying when the memory counter reaches the length of the
30	// first bytes array.
31	let end := add(mc, length)
32
33	for {
34	// Initialize a copy counter to the start of the _preBytes data,
35	// 32 bytes into its memory.
36	let cc := add(_preBytes, 0x20)
37	} lt(mc, end) {
38	// Increase both counters by 32 bytes each iteration.
39	mc := add(mc, 0x20)
40	cc := add(cc, 0x20)
41	} {
42	// Write the _preBytes data into the tempBytes memory 32 bytes
43	// at a time.
44	mstore(mc, mload(cc))
45	}
46
47	// Add the length of _postBytes to the current length of tempBytes
48	// and store it as the new length in the first 32 bytes of the
49	// tempBytes memory.
50	length := mload(_postBytes)
51	mstore(tempBytes, add(length, mload(tempBytes)))
52
53	// Move the memory counter back from a multiple of 0x20 to the
54	// actual end of the _preBytes data.
55	mc := end
56	// Stop copying when the memory counter reaches the new combined
57	// length of the arrays.
58	end := add(mc, length)
59
60	for { let cc := add(_postBytes, 0x20) } lt(mc, end) {
61	mc := add(mc, 0x20)
62	cc := add(cc, 0x20)
63	} { mstore(mc, mload(cc)) }
64
65	// Update the free-memory pointer by padding our last write location
66	// to 32 bytes: add 31 bytes to the end of tempBytes to move to the
67	// next 32 byte block, then round down to the nearest multiple of
68	// 32. If the sum of the length of the two arrays is zero then add
69	// one before rounding down to leave a blank 32 bytes (the length block with 0).
70	mstore(
71	0x40,
72	and(
73	add(add(end, iszero(add(length, mload(_preBytes)))), 31),
74	not(31) // Round down to the nearest 32 bytes.
75	)
76	)
77	}
78
79	return tempBytes;
80	}
81
82	function concatStorage(bytes storage _preBytes, bytes memory _postBytes) internal {
83	assembly {
84	// Read the first 32 bytes of _preBytes storage, which is the length
85	// of the array. (We don't need to use the offset into the slot
86	// because arrays use the entire slot.)
87	let fslot := sload(_preBytes.slot)
88	// Arrays of 31 bytes or less have an even value in their slot,
89	// while longer arrays have an odd value. The actual length is
90	// the slot divided by two for odd values, and the lowest order
91	// byte divided by two for even values.
92	// If the slot is even, bitwise and the slot with 255 and divide by
93	// two to get the length. If the slot is odd, bitwise and the slot
94	// with -1 and divide by two.
95	let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
96	let mlength := mload(_postBytes)
97	let newlength := add(slength, mlength)
98	// slength can contain both the length and contents of the array
99	// if length < 32 bytes so let's prepare for that
100	// v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
101	switch add(lt(slength, 32), lt(newlength, 32))
102	case 2 {
103	// Since the new array still fits in the slot, we just need to
104	// update the contents of the slot.
105	// uint256(bytes_storage) = uint256(bytes_storage) + uint256(bytes_memory) + new_length
106	sstore(
107	_preBytes.slot,
108	// all the modifications to the slot are inside this
109	// next block
110	add(
111	// we can just add to the slot contents because the
112	// bytes we want to change are the LSBs
113	fslot,
114	add(
115	mul(
116	div(
117	// load the bytes from memory
118	mload(add(_postBytes, 0x20)),
119	// zero all bytes to the right
120	exp(0x100, sub(32, mlength))
121	),
122	// and now shift left the number of bytes to
123	// leave space for the length in the slot
124	exp(0x100, sub(32, newlength))
125	),
126	// increase length by the double of the memory
127	// bytes length
128	mul(mlength, 2)
129	)
130	)
131	)
132	}
133	case 1 {
134	// The stored value fits in the slot, but the combined value
135	// will exceed it.
136	// get the keccak hash to get the contents of the array
137	mstore(0x0, _preBytes.slot)
138	let sc := add(keccak256(0x0, 0x20), div(slength, 32))
139
140	// save new length
141	sstore(_preBytes.slot, add(mul(newlength, 2), 1))
142
143	// The contents of the _postBytes array start 32 bytes into
144	// the structure. Our first read should obtain the `submod`
145	// bytes that can fit into the unused space in the last word
146	// of the stored array. To get this, we read 32 bytes starting
147	// from `submod`, so the data we read overlaps with the array
148	// contents by `submod` bytes. Masking the lowest-order
149	// `submod` bytes allows us to add that value directly to the
150	// stored value.
151
152	let submod := sub(32, slength)
153	let mc := add(_postBytes, submod)
154	let end := add(_postBytes, mlength)
155	let mask := sub(exp(0x100, submod), 1)
156
157	sstore(
158	sc,
159	add(
160	and(fslot, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00),
161	and(mload(mc), mask)
162	)
163	)
164
165	for {
166	mc := add(mc, 0x20)
167	sc := add(sc, 1)
168	} lt(mc, end) {
169	sc := add(sc, 1)
170	mc := add(mc, 0x20)
171	} { sstore(sc, mload(mc)) }
172
173	mask := exp(0x100, sub(mc, end))
174
175	sstore(sc, mul(div(mload(mc), mask), mask))
176	}
177	default {
178	// get the keccak hash to get the contents of the array
179	mstore(0x0, _preBytes.slot)
180	// Start copying to the last used word of the stored array.
181	let sc := add(keccak256(0x0, 0x20), div(slength, 32))
182
183	// save new length
184	sstore(_preBytes.slot, add(mul(newlength, 2), 1))
185
186	// Copy over the first `submod` bytes of the new data as in
187	// case 1 above.
188	let slengthmod := mod(slength, 32)
189	let mlengthmod := mod(mlength, 32)
190	let submod := sub(32, slengthmod)
191	let mc := add(_postBytes, submod)
192	let end := add(_postBytes, mlength)
193	let mask := sub(exp(0x100, submod), 1)
194
195	sstore(sc, add(sload(sc), and(mload(mc), mask)))
196
197	for {
198	sc := add(sc, 1)
199	mc := add(mc, 0x20)
200	} lt(mc, end) {
201	sc := add(sc, 1)
202	mc := add(mc, 0x20)
203	} { sstore(sc, mload(mc)) }
204
205	mask := exp(0x100, sub(mc, end))
206
207	sstore(sc, mul(div(mload(mc), mask), mask))
208	}
209	}
210	}
211
212	function slice(bytes memory _bytes, uint256 _start, uint256 _length) internal pure returns (bytes memory) {
213	// We're using the unchecked block below because otherwise execution ends
214	// with the native overflow error code.
215	unchecked {
216	require(_length + 31 >= _length, "slice_overflow");
217	}
218	require(_bytes.length >= _start + _length, "slice_outOfBounds");
219
220	bytes memory tempBytes;
221
222	assembly {
223	switch iszero(_length)
224	case 0 {
225	// Get a location of some free memory and store it in tempBytes as
226	// Solidity does for memory variables.
227	tempBytes := mload(0x40)
228
229	// The first word of the slice result is potentially a partial
230	// word read from the original array. To read it, we calculate
231	// the length of that partial word and start copying that many
232	// bytes into the array. The first word we copy will start with
233	// data we don't care about, but the last `lengthmod` bytes will
234	// land at the beginning of the contents of the new array. When
235	// we're done copying, we overwrite the full first word with
236	// the actual length of the slice.
237	let lengthmod := and(_length, 31)
238
239	// The multiplication in the next line is necessary
240	// because when slicing multiples of 32 bytes (lengthmod == 0)
241	// the following copy loop was copying the origin's length
242	// and then ending prematurely not copying everything it should.
243	let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
244	let end := add(mc, _length)
245
246	for {
247	// The multiplication in the next line has the same exact purpose
248	// as the one above.
249	let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)
250	} lt(mc, end) {
251	mc := add(mc, 0x20)
252	cc := add(cc, 0x20)
253	} { mstore(mc, mload(cc)) }
254
255	mstore(tempBytes, _length)
256
257	//update free-memory pointer
258	//allocating the array padded to 32 bytes like the compiler does now
259	mstore(0x40, and(add(mc, 31), not(31)))
260	}
261	//if we want a zero-length slice let's just return a zero-length array
262	default {
263	tempBytes := mload(0x40)
264	//zero out the 32 bytes slice we are about to return
265	//we need to do it because Solidity does not garbage collect
266	mstore(tempBytes, 0)
267
268	mstore(0x40, add(tempBytes, 0x20))
269	}
270	}
271
272	return tempBytes;
273	}
274
275	function toAddress(bytes memory _bytes, uint256 _start) internal pure returns (address) {
276	require(_bytes.length >= _start + 20, "toAddress_outOfBounds");
277	address tempAddress;
278
279	assembly {
280	tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)
281	}
282
283	return tempAddress;
284	}
285
286	function toUint8(bytes memory _bytes, uint256 _start) internal pure returns (uint8) {
287	require(_bytes.length >= _start + 1, "toUint8_outOfBounds");
288	uint8 tempUint;
289
290	assembly {
291	tempUint := mload(add(add(_bytes, 0x1), _start))
292	}
293
294	return tempUint;
295	}
296
297	function toUint16(bytes memory _bytes, uint256 _start) internal pure returns (uint16) {
298	require(_bytes.length >= _start + 2, "toUint16_outOfBounds");
299	uint16 tempUint;
300
301	assembly {
302	tempUint := mload(add(add(_bytes, 0x2), _start))
303	}
304
305	return tempUint;
306	}
307
308	function toUint32(bytes memory _bytes, uint256 _start) internal pure returns (uint32) {
309	require(_bytes.length >= _start + 4, "toUint32_outOfBounds");
310	uint32 tempUint;
311
312	assembly {
313	tempUint := mload(add(add(_bytes, 0x4), _start))
314	}
315
316	return tempUint;
317	}
318
319	function toUint64(bytes memory _bytes, uint256 _start) internal pure returns (uint64) {
320	require(_bytes.length >= _start + 8, "toUint64_outOfBounds");
321	uint64 tempUint;
322
323	assembly {
324	tempUint := mload(add(add(_bytes, 0x8), _start))
325	}
326
327	return tempUint;
328	}
329
330	function toUint96(bytes memory _bytes, uint256 _start) internal pure returns (uint96) {
331	require(_bytes.length >= _start + 12, "toUint96_outOfBounds");
332	uint96 tempUint;
333
334	assembly {
335	tempUint := mload(add(add(_bytes, 0xc), _start))
336	}
337
338	return tempUint;
339	}
340
341	function toUint128(bytes memory _bytes, uint256 _start) internal pure returns (uint128) {
342	require(_bytes.length >= _start + 16, "toUint128_outOfBounds");
343	uint128 tempUint;
344
345	assembly {
346	tempUint := mload(add(add(_bytes, 0x10), _start))
347	}
348
349	return tempUint;
350	}
351
352	function toUint256(bytes memory _bytes, uint256 _start) internal pure returns (uint256) {
353	require(_bytes.length >= _start + 32, "toUint256_outOfBounds");
354	uint256 tempUint;
355
356	assembly {
357	tempUint := mload(add(add(_bytes, 0x20), _start))
358	}
359
360	return tempUint;
361	}
362
363	function toBytes32(bytes memory _bytes, uint256 _start) internal pure returns (bytes32) {
364	require(_bytes.length >= _start + 32, "toBytes32_outOfBounds");
365	bytes32 tempBytes32;
366
367	assembly {
368	tempBytes32 := mload(add(add(_bytes, 0x20), _start))
369	}
370
371	return tempBytes32;
372	}
373
374	function equal(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bool) {
375	bool success = true;
376
377	assembly {
378	let length := mload(_preBytes)
379
380	// if lengths don't match the arrays are not equal
381	switch eq(length, mload(_postBytes))
382	case 1 {
383	// cb is a circuit breaker in the for loop since there's
384	// no said feature for inline assembly loops
385	// cb = 1 - don't breaker
386	// cb = 0 - break
387	let cb := 1
388
389	let mc := add(_preBytes, 0x20)
390	let end := add(mc, length)
391
392	for { let cc := add(_postBytes, 0x20) }
393	// the next line is the loop condition:
394	// while(uint256(mc < end) + cb == 2)
395	eq(add(lt(mc, end), cb), 2) {
396	mc := add(mc, 0x20)
397	cc := add(cc, 0x20)
398	} {
399	// if any of these checks fails then arrays are not equal
400	if iszero(eq(mload(mc), mload(cc))) {
401	// unsuccess:
402	success := 0
403	cb := 0
404	}
405	}
406	}
407	default {
408	// unsuccess:
409	success := 0
410	}
411	}
412
413	return success;
414	}
415
416	function equalStorage(bytes storage _preBytes, bytes memory _postBytes) internal view returns (bool) {
417	bool success = true;
418
419	assembly {
420	// we know _preBytes_offset is 0
421	let fslot := sload(_preBytes.slot)
422	// Decode the length of the stored array like in concatStorage().
423	let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
424	let mlength := mload(_postBytes)
425
426	// if lengths don't match the arrays are not equal
427	switch eq(slength, mlength)
428	case 1 {
429	// slength can contain both the length and contents of the array
430	// if length < 32 bytes so let's prepare for that
431	// v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
432	if iszero(iszero(slength)) {
433	switch lt(slength, 32)
434	case 1 {
435	// blank the last byte which is the length
436	fslot := mul(div(fslot, 0x100), 0x100)
437
438	if iszero(eq(fslot, mload(add(_postBytes, 0x20)))) {
439	// unsuccess:
440	success := 0
441	}
442	}
443	default {
444	// cb is a circuit breaker in the for loop since there's
445	// no said feature for inline assembly loops
446	// cb = 1 - don't breaker
447	// cb = 0 - break
448	let cb := 1
449
450	// get the keccak hash to get the contents of the array
451	mstore(0x0, _preBytes.slot)
452	let sc := keccak256(0x0, 0x20)
453
454	let mc := add(_postBytes, 0x20)
455	let end := add(mc, mlength)
456
457	// the next line is the loop condition:
458	// while(uint256(mc < end) + cb == 2)
459	for { } eq(add(lt(mc, end), cb), 2) {
460	sc := add(sc, 1)
461	mc := add(mc, 0x20)
462	} {
463	if iszero(eq(sload(sc), mload(mc))) {
464	// unsuccess:
465	success := 0
466	cb := 0
467	}
468	}
469	}
470	}
471	}
472	default {
473	// unsuccess:
474	success := 0
475	}
476	}
477
478	return success;
479	}
480	}
481

1	// SPDX-License-Identifier: UNLICENSED
2	pragma solidity ^0.8.20;
3
4	/// @title Common interface for price oracles.
5	/// @dev Implements the spec at https://eips.ethereum.org/EIPS/eip-7726
6	interface IOracle {
7	/// @notice The oracle does not support the given base/quote pair.
8	/// @param base The asset that the user needs to know the value or price for.
9	/// @param quote The asset in which the user needs to value or price the base.
10	error OracleUnsupportedPair(address base, address quote);
11
12	/// @notice The oracle is not capable to provide data within a degree of confidence.
13	/// @param base The asset that the user needs to know the value or price for.
14	/// @param quote The asset in which the user needs to value or price the base.
15	error OracleUntrustedData(address base, address quote);
16
17	/// @notice Returns the value of `baseAmount` of `base` in `quote` terms.
18	/// @dev MUST round down towards 0.
19	/// MUST revert with `OracleUnsupportedPair` if not capable to provide data for the specified `base` and `quote`
20	/// pair.
21	/// MUST revert with `OracleUntrustedData` if not capable to provide data within a degree of confidence publicly
22	/// specified.
23	/// @param baseAmount The amount of `base` to convert.
24	/// @param base The asset that the user needs to know the value for.
25	/// @param quote The asset in which the user needs to value the base.
26	/// @return quoteAmount The value of `baseAmount` of `base` in `quote` terms
27	function getQuote(uint256 baseAmount, address base, address quote) external view returns (uint256 quoteAmount);
28	}
29

1	// SPDX-License-Identifier: GPL-3.0-or-later
2	/*
3	* MIT License
4	* ===========
5	*
6	* Permission is hereby granted, free of charge, to any person obtaining a copy
7	* of this software and associated documentation files (the "Software"), to deal
8	* in the Software without restriction, including without limitation the rights
9	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10	* copies of the Software, and to permit persons to whom the Software is
11	* furnished to do so, subject to the following conditions:
12	*
13	* The above copyright notice and this permission notice shall be included in all
14	* copies or substantial portions of the Software.
15	*
16	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22	*/
23
24	pragma solidity ^0.8.0;
25
26	import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
27
28	interface IStandardizedYield is IERC20Metadata {
29	/// @dev Emitted when any base tokens is deposited to mint shares
30	event Deposit(
31	address indexed caller,
32	address indexed receiver,
33	address indexed tokenIn,
34	uint256 amountDeposited,
35	uint256 amountSyOut
36	);
37
38	/// @dev Emitted when any shares are redeemed for base tokens
39	event Redeem(
40	address indexed caller,
41	address indexed receiver,
42	address indexed tokenOut,
43	uint256 amountSyToRedeem,
44	uint256 amountTokenOut
45	);
46
47	/// @dev check `assetInfo()` for more information
48	enum AssetType {
49	TOKEN,
50	LIQUIDITY
51	}
52
53	/// @dev Emitted when (`user`) claims their rewards
54	event ClaimRewards(address indexed user, address[] rewardTokens, uint256[] rewardAmounts);
55
56	/**
57	* @notice mints an amount of shares by depositing a base token.
58	* @param receiver shares recipient address
59	* @param tokenIn address of the base tokens to mint shares
60	* @param amountTokenToDeposit amount of base tokens to be transferred from (`msg.sender`)
61	* @param minSharesOut reverts if amount of shares minted is lower than this
62	* @return amountSharesOut amount of shares minted
63	* @dev Emits a {Deposit} event
64	*
65	* Requirements:
66	* - (`tokenIn`) must be a valid base token.
67	*/
68	function deposit(
69	address receiver,
70	address tokenIn,
71	uint256 amountTokenToDeposit,
72	uint256 minSharesOut
73	)
74	external
75	payable
76	returns (uint256 amountSharesOut);
77
78	/**
79	* @notice redeems an amount of base tokens by burning some shares
80	* @param receiver recipient address
81	* @param amountSharesToRedeem amount of shares to be burned
82	* @param tokenOut address of the base token to be redeemed
83	* @param minTokenOut reverts if amount of base token redeemed is lower than this
84	* @param burnFromInternalBalance if true, burns from balance of `address(this)`, otherwise burns from `msg.sender`
85	* @return amountTokenOut amount of base tokens redeemed
86	* @dev Emits a {Redeem} event
87	*
88	* Requirements:
89	* - (`tokenOut`) must be a valid base token.
90	*/
91	function redeem(
92	address receiver,
93	uint256 amountSharesToRedeem,
94	address tokenOut,
95	uint256 minTokenOut,
96	bool burnFromInternalBalance
97	)
98	external
99	returns (uint256 amountTokenOut);
100
101	/**
102	* @notice exchangeRate * syBalance / 1e18 must return the asset balance of the account
103	* @notice vice-versa, if a user uses some amount of tokens equivalent to X asset, the amount of sy
104	* he can mint must be X * exchangeRate / 1e18
105	* @dev SYUtils's assetToSy & syToAsset should be used instead of raw multiplication
106	* & division
107	*/
108	function exchangeRate() external view returns (uint256 res);
109
110	/**
111	* @notice claims reward for (`user`)
112	* @param user the user receiving their rewards
113	* @return rewardAmounts an array of reward amounts in the same order as `getRewardTokens`
114	* @dev
115	* Emits a `ClaimRewards` event
116	* See {getRewardTokens} for list of reward tokens
117	*/
118	function claimRewards(address user) external returns (uint256[] memory rewardAmounts);
119
120	/**
121	* @notice get the amount of unclaimed rewards for (`user`)
122	* @param user the user to check for
123	* @return rewardAmounts an array of reward amounts in the same order as `getRewardTokens`
124	*/
125	function accruedRewards(address user) external view returns (uint256[] memory rewardAmounts);
126
127	function rewardIndexesCurrent() external returns (uint256[] memory indexes);
128
129	function rewardIndexesStored() external view returns (uint256[] memory indexes);
130
131	/**
132	* @notice returns the list of reward token addresses
133	*/
134	function getRewardTokens() external view returns (address[] memory);
135
136	/**
137	* @notice returns the address of the underlying yield token
138	*/
139	function yieldToken() external view returns (address);
140
141	/**
142	* @notice returns all tokens that can mint this SY
143	*/
144	function getTokensIn() external view returns (address[] memory res);
145
146	/**
147	* @notice returns all tokens that can be redeemed by this SY
148	*/
149	function getTokensOut() external view returns (address[] memory res);
150
151	function isValidTokenIn(address token) external view returns (bool);
152
153	function isValidTokenOut(address token) external view returns (bool);
154
155	function previewDeposit(
156	address tokenIn,
157	uint256 amountTokenToDeposit
158	)
159	external
160	view
161	returns (uint256 amountSharesOut);
162
163	function previewRedeem(
164	address tokenOut,
165	uint256 amountSharesToRedeem
166	)
167	external
168	view
169	returns (uint256 amountTokenOut);
170
171	/**
172	* @notice This function contains information to interpret what the asset is
173	* @return assetType the type of the asset (0 for ERC20 tokens, 1 for AMM liquidity tokens,
174	* 2 for bridged yield bearing tokens like wstETH, rETH on Arbi whose the underlying asset doesn't exist on the
175	* chain)
176	* @return assetAddress the address of the asset
177	* @return assetDecimals the decimals of the asset
178	*/
179	function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals);
180	}
181

1	// SPDX-License-Identifier: AGPL-3.0-only
2	pragma solidity >=0.8.0;
3
4	import { IERC7741 } from "../ERC7741/IERC7741.sol";
5
6	interface IERC7540Operator {
7	/**
8	* @dev The event emitted when an operator is set.
9	*
10	* @param controller The address of the controller.
11	* @param operator The address of the operator.
12	* @param approved The approval status.
13	*/
14	event OperatorSet(address indexed controller, address indexed operator, bool approved);
15
16	/**
17	* @dev Sets or removes an operator for the caller.
18	*
19	* @param operator The address of the operator.
20	* @param approved The approval status.
21	* @return Whether the call was executed successfully or not
22	*/
23	function setOperator(address operator, bool approved) external returns (bool);
24
25	/**
26	* @dev Returns `true` if the `operator` is approved as an operator for an `controller`.
27	*
28	* @param controller The address of the controller.
29	* @param operator The address of the operator.
30	* @return status The approval status
31	*/
32	function isOperator(address controller, address operator) external view returns (bool status);
33	}
34
35	interface IERC7540Deposit is IERC7540Operator {
36	event DepositRequest(
37	address indexed controller, address indexed owner, uint256 indexed requestId, address sender, uint256 assets
38	);
39	/**
40	* @dev Transfers assets from sender into the Vault and submits a Request for asynchronous deposit.
41	*
42	* - MUST support ERC-20 approve / transferFrom on asset as a deposit Request flow.
43	* - MUST revert if all of assets cannot be requested for deposit.
44	* - owner MUST be msg.sender unless some unspecified explicit approval is given by the caller,
45	* approval of ERC-20 tokens from owner to sender is NOT enough.
46	*
47	* @param assets the amount of deposit assets to transfer from owner
48	* @param controller the controller of the request who will be able to operate the request
49	* @param owner the source of the deposit assets
50	*
51	* NOTE: most implementations will require pre-approval of the Vault with the Vault's underlying asset token.
52	*/
53
54	function requestDeposit(uint256 assets, address controller, address owner) external returns (uint256 requestId);
55
56	/**
57	* @dev Returns the amount of requested assets in Pending state.
58	*
59	* - MUST NOT include any assets in Claimable state for deposit or mint.
60	* - MUST NOT show any variations depending on the caller.
61	* - MUST NOT revert unless due to integer overflow caused by an unreasonably large input.
62	*/
63	function pendingDepositRequest(
64	uint256 requestId,
65	address controller
66	)
67	external
68	view
69	returns (uint256 pendingAssets);
70
71	/**
72	* @dev Returns the amount of requested assets in Claimable state for the controller to deposit or mint.
73	*
74	* - MUST NOT include any assets in Pending state.
75	* - MUST NOT show any variations depending on the caller.
76	* - MUST NOT revert unless due to integer overflow caused by an unreasonably large input.
77	*/
78	function claimableDepositRequest(
79	uint256 requestId,
80	address controller
81	)
82	external
83	view
84	returns (uint256 claimableAssets);
85
86	/**
87	* @dev Mints shares Vault shares to receiver by claiming the Request of the controller.
88	*
89	* - MUST emit the Deposit event.
90	* - controller MUST equal msg.sender unless the controller has approved the msg.sender as an operator.
91	*/
92	function deposit(uint256 assets, address receiver, address controller) external returns (uint256 shares);
93
94	/**
95	* @dev Mints exactly shares Vault shares to receiver by claiming the Request of the controller.
96	*
97	* - MUST emit the Deposit event.
98	* - controller MUST equal msg.sender unless the controller has approved the msg.sender as an operator.
99	*/
100	function mint(uint256 shares, address receiver, address controller) external returns (uint256 assets);
101	}
102
103	interface IERC7540Redeem is IERC7540Operator {
104	event RedeemRequest(
105	address indexed controller, address indexed owner, uint256 indexed requestId, address sender, uint256 assets
106	);
107
108	/**
109	* @dev Assumes control of shares from sender into the Vault and submits a Request for asynchronous redeem.
110	*
111	* - MUST support a redeem Request flow where the control of shares is taken from sender directly
112	* where msg.sender has ERC-20 approval over the shares of owner.
113	* - MUST revert if all of shares cannot be requested for redeem.
114	*
115	* @param shares the amount of shares to be redeemed to transfer from owner
116	* @param controller the controller of the request who will be able to operate the request
117	* @param owner the source of the shares to be redeemed
118	*
119	* NOTE: most implementations will require pre-approval of the Vault with the Vault's share token.
120	*/
121	function requestRedeem(uint256 shares, address controller, address owner) external returns (uint256 requestId);
122
123	/**
124	* @dev Returns the amount of requested shares in Pending state.
125	*
126	* - MUST NOT include any shares in Claimable state for redeem or withdraw.
127	* - MUST NOT show any variations depending on the caller.
128	* - MUST NOT revert unless due to integer overflow caused by an unreasonably large input.
129	*/
130	function pendingRedeemRequest(
131	uint256 requestId,
132	address controller
133	)
134	external
135	view
136	returns (uint256 pendingShares);
137
138	/**
139	* @dev Returns the amount of requested shares in Claimable state for the controller to redeem or withdraw.
140	*
141	* - MUST NOT include any shares in Pending state for redeem or withdraw.
142	* - MUST NOT show any variations depending on the caller.
143	* - MUST NOT revert unless due to integer overflow caused by an unreasonably large input.
144	*/
145	function claimableRedeemRequest(
146	uint256 requestId,
147	address controller
148	)
149	external
150	view
151	returns (uint256 claimableShares);
152	}
153
154	interface IERC7540CancelDeposit {
155	event CancelDepositRequest(address indexed controller, uint256 indexed requestId, address sender);
156	event CancelDepositClaim(
157	address indexed receiver, address indexed controller, uint256 indexed requestId, address sender, uint256 assets
158	);
159
160	/**
161	* @dev Submits a Request for cancelling the pending deposit Request
162	*
163	* - controller MUST be msg.sender unless some unspecified explicit approval is given by the caller,
164	* approval of ERC-20 tokens from controller to sender is NOT enough.
165	* - MUST set pendingCancelDepositRequest to `true` for the returned requestId after request
166	* - MUST increase claimableCancelDepositRequest for the returned requestId after fulfillment
167	* - SHOULD be claimable using `claimCancelDepositRequest`
168	* Note: while `pendingCancelDepositRequest` is `true`, `requestDeposit` cannot be called
169	*/
170	function cancelDepositRequest(uint256 requestId, address controller) external;
171
172	/**
173	* @dev Returns whether the deposit Request is pending cancelation
174	*
175	* - MUST NOT show any variations depending on the caller.
176	*/
177	function pendingCancelDepositRequest(
178	uint256 requestId,
179	address controller
180	)
181	external
182	view
183	returns (bool isPending);
184
185	/**
186	* @dev Returns the amount of assets that were canceled from a deposit Request, and can now be claimed.
187	*
188	* - MUST NOT show any variations depending on the caller.
189	*/
190	function claimableCancelDepositRequest(
191	uint256 requestId,
192	address controller
193	)
194	external
195	view
196	returns (uint256 claimableAssets);
197
198	/**
199	* @dev Claims the canceled deposit assets, and removes the pending cancelation Request
200	*
201	* - controller MUST be msg.sender unless some unspecified explicit approval is given by the caller,
202	* approval of ERC-20 tokens from controller to sender is NOT enough.
203	* - MUST set pendingCancelDepositRequest to `false` for the returned requestId after request
204	* - MUST set claimableCancelDepositRequest to 0 for the returned requestId after fulfillment
205	*/
206	function claimCancelDepositRequest(
207	uint256 requestId,
208	address receiver,
209	address controller
210	)
211	external
212	returns (uint256 assets);
213	}
214
215	interface IERC7540CancelRedeem {
216	event CancelRedeemRequest(address indexed controller, uint256 indexed requestId, address sender);
217	event CancelRedeemClaim(
218	address indexed receiver, address indexed controller, uint256 indexed requestId, address sender, uint256 shares
219	);
220
221	/**
222	* @dev Submits a Request for cancelling the pending redeem Request
223	*
224	* - controller MUST be msg.sender unless some unspecified explicit approval is given by the caller,
225	* approval of ERC-20 tokens from controller to sender is NOT enough.
226	* - MUST set pendingCancelRedeemRequest to `true` for the returned requestId after request
227	* - MUST increase claimableCancelRedeemRequest for the returned requestId after fulfillment
228	* - SHOULD be claimable using `claimCancelRedeemRequest`
229	* Note: while `pendingCancelRedeemRequest` is `true`, `requestRedeem` cannot be called
230	*/
231	function cancelRedeemRequest(uint256 requestId, address controller) external;
232
233	/**
234	* @dev Returns whether the redeem Request is pending cancelation
235	*
236	* - MUST NOT show any variations depending on the caller.
237	*/
238	function pendingCancelRedeemRequest(uint256 requestId, address controller) external view returns (bool isPending);
239
240	/**
241	* @dev Returns the amount of shares that were canceled from a redeem Request, and can now be claimed.
242	*
243	* - MUST NOT show any variations depending on the caller.
244	*/
245	function claimableCancelRedeemRequest(
246	uint256 requestId,
247	address controller
248	)
249	external
250	view
251	returns (uint256 claimableShares);
252
253	/**
254	* @dev Claims the canceled redeem shares, and removes the pending cancelation Request
255	*
256	* - controller MUST be msg.sender unless some unspecified explicit approval is given by the caller,
257	* approval of ERC-20 tokens from controller to sender is NOT enough.
258	* - MUST set pendingCancelRedeemRequest to `false` for the returned requestId after request
259	* - MUST set claimableCancelRedeemRequest to 0 for the returned requestId after fulfillment
260	*/
261	function claimCancelRedeemRequest(
262	uint256 requestId,
263	address receiver,
264	address controller
265	)
266	external
267	returns (uint256 shares);
268	}
269
270	/**
271	* @title IERC7540
272	* @dev Fully async ERC7540 implementation according to the standard
273	* @dev Adapted from Centrifuge's IERC7540 implementation
274	*/
275	interface IERC7540 is IERC7540Deposit, IERC7540Redeem { }
276
277	/**
278	* @title IERC7540Vault
279	* @dev This is the specific set of interfaces used by the SuperVaults
280	*/
281	interface IERC7540Vault is IERC7540, IERC7741 {
282	event DepositClaimable(address indexed controller, uint256 indexed requestId, uint256 assets, uint256 shares);
283	event RedeemClaimable(address indexed controller, uint256 indexed requestId, uint256 assets, uint256 shares);
284	}
285

1	// SPDX-License-Identifier: AGPL-3.0-only
2	pragma solidity >=0.8.0;
3
4	interface IERC7741 {
5	/**
6	* @dev Grants or revokes permissions for `operator` to manage Requests on behalf of the
7	* `msg.sender`, using an [EIP-712](./eip-712.md) signature.
8	*/
9	function authorizeOperator(
10	address controller,
11	address operator,
12	bool approved,
13	bytes32 nonce,
14	uint256 deadline,
15	bytes memory signature
16	)
17	external
18	returns (bool);
19
20	/**
21	* @dev Revokes the given `nonce` for `msg.sender` as the `owner`.
22	*/
23	function invalidateNonce(bytes32 nonce) external;
24
25	/**
26	* @dev Returns whether the given `nonce` has been used for the `controller`.
27	*/
28	function authorizations(address controller, bytes32 nonce) external view returns (bool used);
29
30	/**
31	* @dev Returns the `DOMAIN_SEPARATOR` as defined according to EIP-712. The `DOMAIN_SEPARATOR
32	* should be unique to the contract and chain to prevent replay attacks from other domains,
33	* and satisfy the requirements of EIP-712, but is otherwise unconstrained.
34	*/
35	function DOMAIN_SEPARATOR() external view returns (bytes32);
36	}
37

1	// SPDX-License-Identifier: UNLICENSED
2	pragma solidity 0.8.30;
3
4	/// @title ISuperVault
5	/// @notice Interface for SuperVault core contract that manages share minting
6	/// @author Superform Labs
7	interface ISuperVault {
8	/*//////////////////////////////////////////////////////////////
9	ERRORS
10	//////////////////////////////////////////////////////////////*/
11	error ALREADY_INITIALIZED();
12	error INVALID_ASSET();
13	error INVALID_STRATEGY();
14	error INVALID_ESCROW();
15	error ZERO_ADDRESS();
16	error ZERO_AMOUNT();
17	error INVALID_OWNER_OR_OPERATOR();
18	error INVALID_AMOUNT();
19	error REQUEST_NOT_FOUND();
20	error UNAUTHORIZED();
21	error TIMELOCK_NOT_EXPIRED();
22	error INVALID_SIGNATURE();
23	error NOT_IMPLEMENTED();
24	error INVALID_NONCE();
25	error INVALID_WITHDRAW_PRICE();
26	error TRANSFER_FAILED();
27	error CAP_EXCEEDED();
28	error INVALID_PPS();
29	error INVALID_CONTROLLER();
30
31	/*//////////////////////////////////////////////////////////////
32	EVENTS
33	//////////////////////////////////////////////////////////////*/
34
35	event RedeemClaimable(
36	address indexed user,
37	uint256 indexed requestId,
38	uint256 assets,
39	uint256 shares,
40	uint256 averageWithdrawPrice,
41	uint256 accumulatorShares,
42	uint256 accumulatorCostBasis
43	);
44
45	event NonceInvalidated(address indexed sender, bytes32 indexed nonce);
46
47	event RedeemRequestCancelled(address indexed controller, address indexed sender);
48
49	/*//////////////////////////////////////////////////////////////
50	EXTERNAL METHODS
51	//////////////////////////////////////////////////////////////*/
52
53	function cancelRedeem(address controller) external;
54
55	/// @notice Mint new shares, only callable by strategy
56	/// @param amount The amount of shares to mint
57	function mintShares(uint256 amount) external;
58
59	/// @notice Burn shares, only callable by strategy
60	/// @param amount The amount of shares to burn
61	function burnShares(uint256 amount) external;
62
63	/// @notice Callback function for when a redeem becomes claimable
64	/// @param user The user whose redeem is claimable
65	/// @param assets The amount of assets to be received
66	/// @param shares The amount of shares redeemed
67	/// @param averageWithdrawPrice The average price of the redeem
68	/// @param accumulatorShares The amount of shares in the accumulator
69	/// @param accumulatorCostBasis The cost basis of the accumulator
70	function onRedeemClaimable(
71	address user,
72	uint256 assets,
73	uint256 shares,
74	uint256 averageWithdrawPrice,
75	uint256 accumulatorShares,
76	uint256 accumulatorCostBasis
77	)
78	external;
79	}
80

1	// SPDX-License-Identifier: UNLICENSED
2	pragma solidity 0.8.30;
3
4	interface IERC7575 {
5	event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares);
6	event Withdraw(
7	address indexed sender, address indexed receiver, address indexed owner, uint256 assets, uint256 shares
8	);
9
10	/**
11	* @dev Returns the address of the underlying token used for the Vault for accounting, depositing, and withdrawing.
12	*
13	* - MUST be an ERC-20 token contract.
14	* - MUST NOT revert.
15	*/
16	function asset() external view returns (address assetTokenAddress);
17
18	/**
19	* @dev Returns the address of the share token
20	*
21	* - MUST be an ERC-20 token contract.
22	* - MUST NOT revert.
23	*/
24	function share() external view returns (address shareTokenAddress);
25
26	/**
27	* @dev Returns the amount of shares that the Vault would exchange for the amount of assets provided, in an ideal
28	* scenario where all the conditions are met.
29	*
30	* - MUST NOT be inclusive of any fees that are charged against assets in the Vault.
31	* - MUST NOT show any variations depending on the caller.
32	* - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.
33	* - MUST NOT revert.
34	*
35	* NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the
36	* “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and
37	* from.
38	*/
39	function convertToShares(uint256 assets) external view returns (uint256 shares);
40
41	/**
42	* @dev Returns the amount of assets that the Vault would exchange for the amount of shares provided, in an ideal
43	* scenario where all the conditions are met.
44	*
45	* - MUST NOT be inclusive of any fees that are charged against assets in the Vault.
46	* - MUST NOT show any variations depending on the caller.
47	* - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.
48	* - MUST NOT revert.
49	*
50	* NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the
51	* “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and
52	* from.
53	*/
54	function convertToAssets(uint256 shares) external view returns (uint256 assets);
55
56	/**
57	* @dev Returns the total amount of the underlying asset that is “managed” by Vault.
58	*
59	* - SHOULD include any compounding that occurs from yield.
60	* - MUST be inclusive of any fees that are charged against assets in the Vault.
61	* - MUST NOT revert.
62	*/
63	function totalAssets() external view returns (uint256 totalManagedAssets);
64
65	/**
66	* @dev Returns the maximum amount of the underlying asset that can be deposited into the Vault for the receiver,
67	* through a deposit call.
68	*
69	* - MUST return a limited value if receiver is subject to some deposit limit.
70	* - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of assets that may be deposited.
71	* - MUST NOT revert.
72	*/
73	function maxDeposit(address receiver) external view returns (uint256 maxAssets);
74
75	/**
76	* @dev Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given
77	* current on-chain conditions.
78	*
79	* - MUST return as close to and no more than the exact amount of Vault shares that would be minted in a deposit
80	* call in the same transaction. I.e. deposit should return the same or more shares as previewDeposit if called
81	* in the same transaction.
82	* - MUST NOT account for deposit limits like those returned from maxDeposit and should always act as though the
83	* deposit would be accepted, regardless if the user has enough tokens approved, etc.
84	* - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.
85	* - MUST NOT revert.
86	*
87	* NOTE: any unfavorable discrepancy between convertToShares and previewDeposit SHOULD be considered slippage in
88	* share price or some other type of condition, meaning the depositor will lose assets by depositing.
89	*/
90	function previewDeposit(uint256 assets) external view returns (uint256 shares);
91
92	/**
93	* @dev Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens.
94	*
95	* - MUST emit the Deposit event.
96	* - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
97	* deposit execution, and are accounted for during deposit.
98	* - MUST revert if all of assets cannot be deposited (due to deposit limit being reached, slippage, the user not
99	* approving enough underlying tokens to the Vault contract, etc).
100	*
101	* NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.
102	*/
103	function deposit(uint256 assets, address receiver) external returns (uint256 shares);
104
105	/**
106	* @dev Returns the maximum amount of the Vault shares that can be minted for the receiver, through a mint call.
107	* - MUST return a limited value if receiver is subject to some mint limit.
108	* - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of shares that may be minted.
109	* - MUST NOT revert.
110	*/
111	function maxMint(address receiver) external view returns (uint256 maxShares);
112
113	/**
114	* @dev Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given
115	* current on-chain conditions.
116	*
117	* - MUST return as close to and no fewer than the exact amount of assets that would be deposited in a mint call
118	* in the same transaction. I.e. mint should return the same or fewer assets as previewMint if called in the
119	* same transaction.
120	* - MUST NOT account for mint limits like those returned from maxMint and should always act as though the mint
121	* would be accepted, regardless if the user has enough tokens approved, etc.
122	* - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.
123	* - MUST NOT revert.
124	*
125	* NOTE: any unfavorable discrepancy between convertToAssets and previewMint SHOULD be considered slippage in
126	* share price or some other type of condition, meaning the depositor will lose assets by minting.
127	*/
128	function previewMint(uint256 shares) external view returns (uint256 assets);
129
130	/**
131	* @dev Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens.
132	*
133	* - MUST emit the Deposit event.
134	* - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the mint
135	* execution, and are accounted for during mint.
136	* - MUST revert if all of shares cannot be minted (due to deposit limit being reached, slippage, the user not
137	* approving enough underlying tokens to the Vault contract, etc).
138	*
139	* NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.
140	*/
141	function mint(uint256 shares, address receiver) external returns (uint256 assets);
142
143	/**
144	* @dev Returns the maximum amount of the underlying asset that can be withdrawn from the owner balance in the
145	* Vault, through a withdraw call.
146	*
147	* - MUST return a limited value if owner is subject to some withdrawal limit or timelock.
148	* - MUST NOT revert.
149	*/
150	function maxWithdraw(address owner) external view returns (uint256 maxAssets);
151
152	/**
153	* @dev Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block,
154	* given current on-chain conditions.
155	*
156	* - MUST return as close to and no fewer than the exact amount of Vault shares that would be burned in a withdraw
157	* call in the same transaction. I.e. withdraw should return the same or fewer shares as previewWithdraw if
158	* called
159	* in the same transaction.
160	* - MUST NOT account for withdrawal limits like those returned from maxWithdraw and should always act as though
161	* the withdrawal would be accepted, regardless if the user has enough shares, etc.
162	* - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.
163	* - MUST NOT revert.
164	*
165	* NOTE: any unfavorable discrepancy between convertToShares and previewWithdraw SHOULD be considered slippage in
166	* share price or some other type of condition, meaning the depositor will lose assets by depositing.
167	*/
168	function previewWithdraw(uint256 assets) external view returns (uint256 shares);
169
170	/**
171	* @dev Burns shares from owner and sends exactly assets of underlying tokens to receiver.
172	*
173	* - MUST emit the Withdraw event.
174	* - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
175	* withdraw execution, and are accounted for during withdraw.
176	* - MUST revert if all of assets cannot be withdrawn (due to withdrawal limit being reached, slippage, the owner
177	* not having enough shares, etc).
178	*
179	* Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed.
180	* Those methods should be performed separately.
181	*/
182	function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);
183
184	/**
185	* @dev Returns the maximum amount of Vault shares that can be redeemed from the owner balance in the Vault,
186	* through a redeem call.
187	*
188	* - MUST return a limited value if owner is subject to some withdrawal limit or timelock.
189	* - MUST return balanceOf(owner) if owner is not subject to any withdrawal limit or timelock.
190	* - MUST NOT revert.
191	*/
192	function maxRedeem(address owner) external view returns (uint256 maxShares);
193
194	/**
195	* @dev Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block,
196	* given current on-chain conditions.
197	*
198	* - MUST return as close to and no more than the exact amount of assets that would be withdrawn in a redeem call
199	* in the same transaction. I.e. redeem should return the same or more assets as previewRedeem if called in the
200	* same transaction.
201	* - MUST NOT account for redemption limits like those returned from maxRedeem and should always act as though the
202	* redemption would be accepted, regardless if the user has enough shares, etc.
203	* - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.
204	* - MUST NOT revert.
205	*
206	* NOTE: any unfavorable discrepancy between convertToAssets and previewRedeem SHOULD be considered slippage in
207	* share price or some other type of condition, meaning the depositor will lose assets by redeeming.
208	*/
209	function previewRedeem(uint256 shares) external view returns (uint256 assets);
210
211	/**
212	* @dev Burns exactly shares from owner and sends assets of underlying tokens to receiver.
213	*
214	* - MUST emit the Withdraw event.
215	* - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
216	* redeem execution, and are accounted for during redeem.
217	* - MUST revert if all of shares cannot be redeemed (due to withdrawal limit being reached, slippage, the owner
218	* not having enough shares, etc).
219	*
220	* NOTE: some implementations will require pre-requesting to the Vault before a withdrawal may be performed.
221	* Those methods should be performed separately.
222	*/
223	function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);
224	}
225	// As defined by https://eips.ethereum.org/EIPS/eip-7540#request-flows
226
227	interface IERC7540 is IERC7575 {
228	event DepositRequest(
229	address indexed controller, address indexed owner, uint256 indexed requestId, address sender, uint256 assets
230	);
231
232	event RedeemRequest(
233	address indexed controller, address indexed owner, uint256 indexed requestId, address sender, uint256 assets
234	);
235
236	/*//////////////////////////////////////////////////////////////
237	VIEW METHODS
238	//////////////////////////////////////////////////////////////*/
239	/// @notice Check if the contract supports an interface
240	/// @param interfaceId The selector of the interface to check
241	function supportsInterface(bytes4 interfaceId) external view returns (bool);
242
243	/// @notice Preview the amount of assets that would be received for a given amount of shares
244	/// @param shares The amount of shares to redeem
245	function previewRedeem(uint256 shares) external view returns (uint256 assets);
246
247	/// @notice Check if a deposit request is pending
248	/// @param requestId The id of the request to check
249	/// @param controller The address of the controller
250	function pendingDepositRequest(uint256 requestId, address controller) external view returns (uint256);
251
252	/// @notice Check if a deposit request is pending cancellation
253	/// @param requestId The id of the request to check
254	/// @param controller The address of the controller
255	function pendingCancelDepositRequest(uint256 requestId, address controller) external view returns (bool);
256
257	/// @notice Check if a redeem request is pending
258	/// @param requestId The id of the request to check
259	/// @param controller The address of the controller
260	function pendingRedeemRequest(uint256 requestId, address controller) external view returns (uint256);
261
262	/// @notice Get the amount of assets that can be claimed from a deposit request
263	/// @param requestId The id of the request to check
264	/// @param controller The address of the controller
265	function claimableDepositRequest(uint256 requestId, address controller) external view returns (uint256);
266
267	/// @notice Get the amount of shares that can be claimed from a redeem request
268	/// @param requestId The id of the request to check
269	/// @param controller The address of the controller
270	function claimableRedeemRequest(uint256 requestId, address controller) external view returns (uint256);
271
272	/// @notice Check if a redeem request is pending cancellation
273	/// @param requestId The id of the request to check
274	/// @param controller The address of the controller
275	function pendingCancelRedeemRequest(uint256 requestId, address controller) external view returns (bool);
276
277	/*//////////////////////////////////////////////////////////////
278	EXTERNAL METHODS
279	//////////////////////////////////////////////////////////////*/
280	/// @notice Mints amount of shares by claiming the controller's request
281	/// @dev sender must be the controller or an operator approved by the controller
282	/// @param assets The amount of assets to deposit
283	/// @param receiver The address of the receiver
284	/// @param controller The address of the controller
285	function deposit(uint256 assets, address receiver, address controller) external returns (uint256 shares);
286
287	/// @notice Mint exact amount of shares into the vault by claiming the controller's request
288	/// @param shares The amount of shares to mint
289	/// @param receiver The address of the receiver
290	/// @param controller The address of the controller
291	function mint(uint256 shares, address receiver, address controller) external returns (uint256 assets);
292
293	/// @notice Burn shares from the vault and sends exact amount of assets to the receiver
294	/// @param assets The amount of assets to withdraw
295	/// @param receiver The address of the receiver
296	/// @param owner The address of the owner
297	function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);
298
299	/// @notice Burns exact shares from the vault and sends assets to the receiver
300	/// @param shares The amount of shares to redeem
301	/// @param receiver The address of the receiver
302	/// @param owner The address of the owner
303	function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);
304
305	/// @notice Request a deposit of assets
306	/// @param assets The amount of assets to deposit
307	/// @param controller The address of the controller
308	/// @param owner The address of the owner
309	function requestDeposit(uint256 assets, address controller, address owner) external returns (uint256 requestId);
310
311	/// @notice Request a redeem of shares
312	/// @param shares The amount of shares to redeem
313	/// @param controller The address of the controller
314	/// @param owner The address of the owner
315	function requestRedeem(uint256 shares, address controller, address owner) external returns (uint256 requestId);
316
317	/// @notice Cancel a deposit request
318	/// @param requestId The id of the request to cancel
319	/// @param controller The address of the controller
320	function cancelDepositRequest(uint256 requestId, address controller) external;
321
322	/// @notice Claims the canceled deposit assets, and removes the pending cancelation Request
323	/// @dev sender must be the controller
324	/// @param requestId The id of the request to claim
325	/// @param receiver The address of the receiver
326	/// @param controller The address of the controller
327	function claimCancelDepositRequest(
328	uint256 requestId,
329	address receiver,
330	address controller
331	)
332	external
333	returns (uint256 assets);
334
335	/// @notice Cancel a redeem request
336	/// @param requestId The id of the request to cancel
337	/// @param controller The address of the controller
338	function cancelRedeemRequest(uint256 requestId, address controller) external;
339
340	/// @notice Claims the canceled redeem shares, and removes the pending cancelation Request
341	/// @dev sender must be the controller
342	/// @param requestId The id of the request to claim
343	/// @param receiver The address of the receiver
344	/// @param controller The address of the controller
345	function claimCancelRedeemRequest(
346	uint256 requestId,
347	address receiver,
348	address controller
349	)
350	external
351	returns (uint256 shares);
352
353	/// @notice Get the pool id
354	function poolId() external view returns (uint64);
355
356	/// @notice Get the tranche id
357	function trancheId() external view returns (bytes16);
358
359	/*//////////////////////////////////////////////////////////////
360	OWNER METHODS
361	//////////////////////////////////////////////////////////////*/
362	function setOperator(address operator, bool approved) external returns (bool);
363	function isOperator(address controller, address operator) external view returns (bool status);
364	}
365

1	// SPDX-License-Identifier: UNLICENSED
2	pragma solidity 0.8.30;
3
4	import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
5	import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
6
7	/// @title SuperVaultEscrow
8	/// @author Superform Labs
9	/// @notice Escrow contract for SuperVault shares during request/claim process
10	contract SuperVaultEscrow {
11	using SafeERC20 for IERC20;
12
13	/*//////////////////////////////////////////////////////////////
14	ERRORS
15	//////////////////////////////////////////////////////////////*/
16	error ALREADY_INITIALIZED();
17	error UNAUTHORIZED();
18	error ZERO_ADDRESS();
19
20	/*//////////////////////////////////////////////////////////////
21	STATE
22	//////////////////////////////////////////////////////////////*/
23	bool public initialized;
24	address public vault;
25	address public strategy;
26
27	/*//////////////////////////////////////////////////////////////
28	MODIFIERS
29	//////////////////////////////////////////////////////////////*/
30	modifier onlyVault() {
31	if (msg.sender != vault) revert UNAUTHORIZED();
32	_;
33	}
34
35	/*//////////////////////////////////////////////////////////////
36	INITIALIZATION
37	//////////////////////////////////////////////////////////////*/
38
39	/// @notice Initialize the escrow with required parameters
40	/// @param vaultAddress The vault contract address
41	/// @param strategyAddress The strategy contract address
42	function initialize(address vaultAddress, address strategyAddress) external {
43	if (initialized) revert ALREADY_INITIALIZED();
44	if (vaultAddress == address(0) \|\| strategyAddress == address(0)) revert ZERO_ADDRESS();
45
46	initialized = true;
47	vault = vaultAddress;
48	strategy = strategyAddress;
49	}
50
51	/*//////////////////////////////////////////////////////////////
52	VAULT FUNCTIONS
53	//////////////////////////////////////////////////////////////*/
54
55	/// @notice Transfer shares from user to escrow during redeem request
56	/// @param from The address to transfer shares from
57	/// @param amount The amount of shares to transfer
58	function escrowShares(address from, uint256 amount) external onlyVault {
59	IERC20(vault).safeTransferFrom(from, address(this), amount);
60	}
61
62	/// @notice Return shares from escrow to user during redeem cancellation
63	/// @param to The address to return shares to
64	/// @param amount The amount of shares to return
65	function returnShares(address to, uint256 amount) external onlyVault {
66	IERC20(vault).safeTransfer(to, amount);
67	}
68	}
69

1	// SPDX-License-Identifier: MIT
2	pragma solidity 0.8.30;
3
4	/**
5	* @title ISuperAssetFactory
6	* @notice Interface for the SuperAssetFactory contract which deploys SuperAsset and its dependencies
7	*/
8	interface ISuperAssetFactory {
9	/*//////////////////////////////////////////////////////////////
10	EVENTS
11	//////////////////////////////////////////////////////////////*/
12
13	/// @notice Emitted when a new SuperAsset and its dependencies are created
14	/// @param superAsset Address of the deployed SuperAsset contract
15	/// @param incentiveFund Address of the deployed IncentiveFundContract
16	/// @param incentiveCalc Address of the deployed IncentiveCalculationContract
17	/// @param name Name of the SuperAsset token
18	/// @param symbol Symbol of the SuperAsset token
19	event SuperAssetCreated(
20	address indexed superAsset, address indexed incentiveFund, address incentiveCalc, string name, string symbol
21	);
22
23	/*//////////////////////////////////////////////////////////////
24	ERRORS
25	//////////////////////////////////////////////////////////////*/
26
27	/// @notice Thrown when an address parameter is zero
28	error ZERO_ADDRESS();
29
30	/// @notice Thrown when the caller is not authorized
31	error UNAUTHORIZED();
32
33	/// @notice Thrown when ICC is not whitelisted
34	error ICC_NOT_WHITELISTED();
35
36	/*//////////////////////////////////////////////////////////////
37	STRUCTS
38	//////////////////////////////////////////////////////////////*/
39
40	/// @notice Parameters required for creating a new SuperAsset
41	/// @param name Name of the SuperAsset token
42	/// @param symbol Symbol of the SuperAsset token
43	/// @param swapFeeInPercentage Initial swap fee percentage for deposits
44	/// @param swapFeeOutPercentage Initial swap fee percentage for redemptions
45	/// @param asset Address of the primary asset
46	/// @param superAssetManager Address of the manager
47	/// @param superAssetStrategist Address of the strategist
48	/// @param incentiveFundManager Address of the incentive fund manager
49	/// @param incentiveCalculationContract Address of the incentive calculation contract
50	/// @param tokenInIncentive Address of the token for incoming incentives
51	/// @param tokenOutIncentive Address of the token for outgoing incentives
52	struct AssetCreationParams {
53	string name;
54	string symbol;
55	uint256 swapFeeInPercentage;
56	uint256 swapFeeOutPercentage;
57	address asset;
58	address superAssetManager;
59	address superAssetStrategist;
60	address incentiveFundManager;
61	address incentiveCalculationContract;
62	address tokenInIncentive;
63	address tokenOutIncentive;
64	}
65
66	/// @notice Data for a SuperAsset
67	/// @param superAssetStrategist Address of the strategist
68	/// @param superAssetManager Address of the manager
69	/// @param incentiveFundManager Address of the incentive fund manager
70	/// @param incentiveCalculationContract Address of the incentive calculation contract
71	/// @param incentiveFundContract Address of the incentive fund contract
72	struct SuperAssetData {
73	address superAssetStrategist;
74	address superAssetManager;
75	address incentiveFundManager;
76	address incentiveCalculationContract;
77	address incentiveFundContract;
78	}
79
80	/*//////////////////////////////////////////////////////////////
81	EXTERNAL METHODS
82	//////////////////////////////////////////////////////////////*/
83
84	/// @notice Sets the manager for a SuperAsset
85	/// @param superAsset Address of the SuperAsset contract
86	/// @param _superAssetManager Address of the manager
87	function setSuperAssetManager(address superAsset, address _superAssetManager) external;
88
89	/// @notice Sets the strategist for a SuperAsset
90	/// @param superAsset Address of the SuperAsset contract
91	/// @param _superAssetStrategist Address of the strategist
92	function setSuperAssetStrategist(address superAsset, address _superAssetStrategist) external;
93
94	/// @notice Sets the incentive fund manager for a SuperAsset
95	/// @param superAsset Address of the SuperAsset contract
96	/// @param _incentiveFundManager Address of the incentive fund manager
97	function setIncentiveFundManager(address superAsset, address _incentiveFundManager) external;
98
99	/// @notice Sets the incentive calculation contract for a SuperAsset
100	/// @param superAsset Address of the SuperAsset contract
101	/// @param incentiveCalculationContract Address of the incentive calculation contract
102	function setIncentiveCalculationContract(address superAsset, address incentiveCalculationContract) external;
103
104	/// @notice Gets the manager for a SuperAsset
105	/// @param superAsset Address of the SuperAsset contract
106	/// @return superAssetManager Address of the manager
107	function getSuperAssetManager(address superAsset) external view returns (address);
108
109	/// @notice Gets the strategist for a SuperAsset
110	/// @param superAsset Address of the SuperAsset contract
111	/// @return superAssetStrategist Address of the strategist
112	function getSuperAssetStrategist(address superAsset) external view returns (address);
113
114	/// @notice Gets the incentive fund manager for a SuperAsset
115	/// @param superAsset Address of the SuperAsset contract
116	/// @return incentiveFundManager Address of the incentive fund manager
117	function getIncentiveFundManager(address superAsset) external view returns (address);
118
119	/// @notice Gets the incentive calculation contract for a SuperAsset
120	/// @param superAsset Address of the SuperAsset contract
121	/// @return incentiveCalculationContract Address of the incentive calculation contract
122	function getIncentiveCalculationContract(address superAsset) external view returns (address);
123
124	/// @notice Gets the incentive fund contract for a SuperAsset
125	/// @param superAsset Address of the SuperAsset contract
126	/// @return incentiveFundContract Address of the incentive fund contract
127	function getIncentiveFundContract(address superAsset) external view returns (address);
128
129	/// @notice Adds an Incentive Calculation Contract to the whitelist
130	/// @param icc Address of the Incentive Calculation Contract
131	function addICCToWhitelist(address icc) external;
132
133	/// @notice Removes an Incentive Calculation Contract from the whitelist
134	/// @param icc Address of the Incentive Calculation Contract
135	function removeICCFromWhitelist(address icc) external;
136
137	/// @notice Checks if an Incentive Calculation Contract is whitelisted
138	/// @param icc Address of the Incentive Calculation Contract
139	/// @return isValid Whether the Incentive Calculation Contract is whitelisted
140	function isICCWhitelisted(address icc) external view returns (bool);
141
142	/// @notice Creates a new SuperAsset instance with its dependencies
143	/// @param params Parameters for creating the SuperAsset
144	/// @return superAsset Address of the deployed SuperAsset contract
145	/// @return incentiveFund Address of the deployed IncentiveFundContract
146	function createSuperAsset(AssetCreationParams calldata params)
147	external
148	returns (address superAsset, address incentiveFund);
149	}
150

1	// SPDX-License-Identifier: UNLICENSED
2	pragma solidity 0.8.30;
3
4	/// @title ISuperVaultEscrow
5	/// @notice Interface for SuperVault escrow contract that holds shares during request/claim process
6	/// @author Superform Labs
7	interface ISuperVaultEscrow {
8	/*//////////////////////////////////////////////////////////////
9	ERRORS
10	//////////////////////////////////////////////////////////////*/
11	error ALREADY_INITIALIZED();
12	error UNAUTHORIZED();
13	error ZERO_ADDRESS();
14
15	/*//////////////////////////////////////////////////////////////
16	INITIALIZATION
17	//////////////////////////////////////////////////////////////*/
18
19	/// @notice Initialize the escrow with required parameters
20	/// @param vaultAddress The vault contract address
21	/// @param strategyAddress The strategy contract address
22	function initialize(address vaultAddress, address strategyAddress) external;
23
24	/*//////////////////////////////////////////////////////////////
25	VAULT FUNCTIONS
26	//////////////////////////////////////////////////////////////*/
27
28	/// @notice Transfer shares from user to escrow during redeem request
29	/// @param from The address to transfer shares from
30	/// @param amount The amount of shares to transfer
31	function escrowShares(address from, uint256 amount) external;
32
33	/// @notice Return shares from escrow to user during redeem cancellation
34	/// @param to The address to return shares to
35	/// @param amount The amount of shares to return
36	function returnShares(address to, uint256 amount) external;
37	}
38