Recon Coverage Report

Files 92 files

Files

Lines

23530

Coverage

57%

4122 / 7230

Actions

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

Lines covered: 114 / 123 (92%)

// 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% lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol

Lines covered: 27 / 30 (90%)

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

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

Lines covered: 57 / 67 (85%)

// 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% lib/openzeppelin-contracts-upgradeable/contracts/utils/ContextUpgradeable.sol

Lines covered: 1 / 1 (100%)

// 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% lib/openzeppelin-contracts-upgradeable/contracts/utils/ReentrancyGuardUpgradeable.sol

Lines covered: 12 / 13 (92%)

// 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% lib/openzeppelin-contracts-upgradeable/contracts/utils/cryptography/EIP712Upgradeable.sol

Lines covered: 8 / 47 (17%)

// 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("");
            }
        }
    }
}

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

Lines covered: 21 / 23 (91%)

// 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% lib/setup-helpers/lib/chimera/src/Hevm.sol

Lines covered: 1 / 1 (100%)

// 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% lib/setup-helpers/src/ActorManager.sol

Lines covered: 13 / 15 (86%)

// 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% lib/setup-helpers/src/AssetManager.sol

Lines covered: 31 / 33 (93%)

// 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% lib/setup-helpers/src/EnumerableSet.sol

Lines covered: 23 / 25 (92%)

// 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% lib/setup-helpers/src/MockERC20.sol

Lines covered: 55 / 75 (73%)

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

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

Lines covered: 17 / 54 (31%)

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

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

Lines covered: 11 / 36 (30%)

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

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

Lines covered: 9 / 31 (29%)

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

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

Lines covered: 16 / 17 (94%)

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

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

Lines covered: 1 / 2 (50%)

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

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

Lines covered: 5 / 6 (83%)

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

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

Lines covered: 32 / 58 (55%)

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

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

Lines covered: 2 / 22 (9%)

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

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

Lines covered: 35 / 40 (87%)

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

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

Lines covered: 89 / 102 (87%)

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

95% lib/v2-core/src/hooks/vaults/4626/ApproveAndDeposit4626VaultHook.sol

Lines covered: 39 / 41 (95%)

// 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% lib/v2-core/src/hooks/vaults/4626/Deposit4626VaultHook.sol

Lines covered: 20 / 32 (62%)

// 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% lib/v2-core/src/hooks/vaults/4626/Redeem4626VaultHook.sol

Lines covered: 46 / 47 (97%)

// 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% lib/v2-core/src/hooks/vaults/5115/ApproveAndDeposit5115VaultHook.sol

Lines covered: 40 / 45 (88%)

// 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% lib/v2-core/src/hooks/vaults/5115/Deposit5115VaultHook.sol

Lines covered: 18 / 39 (46%)

// 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% lib/v2-core/src/hooks/vaults/5115/Redeem5115VaultHook.sol

Lines covered: 27 / 44 (61%)

// 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% lib/v2-core/src/hooks/vaults/7540/ApproveAndRequestDeposit7540VaultHook.sol

Lines covered: 22 / 42 (52%)

// 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% lib/v2-core/src/hooks/vaults/7540/CancelDepositRequest7540Hook.sol

Lines covered: 13 / 13 (100%)

// 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% lib/v2-core/src/hooks/vaults/7540/CancelRedeemRequest7540Hook.sol

Lines covered: 13 / 13 (100%)

// 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% lib/v2-core/src/hooks/vaults/7540/ClaimCancelDepositRequest7540Hook.sol

Lines covered: 27 / 29 (93%)

// 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% lib/v2-core/src/hooks/vaults/7540/ClaimCancelRedeemRequest7540Hook.sol

Lines covered: 25 / 27 (92%)

// 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% lib/v2-core/src/hooks/vaults/7540/Deposit7540VaultHook.sol

Lines covered: 19 / 32 (59%)

// 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% lib/v2-core/src/hooks/vaults/7540/Redeem7540VaultHook.sol

Lines covered: 41 / 41 (100%)

// 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% lib/v2-core/src/hooks/vaults/7540/RequestDeposit7540VaultHook.sol

Lines covered: 19 / 32 (59%)

// 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% lib/v2-core/src/hooks/vaults/7540/RequestRedeem7540VaultHook.sol

Lines covered: 19 / 32 (59%)

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

51% lib/v2-core/src/hooks/vaults/7540/Withdraw7540VaultHook.sol

Lines covered: 21 / 41 (51%)

// 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% lib/v2-core/src/hooks/vaults/super-vault/CancelRedeemHook.sol

Lines covered: 17 / 20 (85%)

// 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% lib/v2-core/src/hooks/vaults/super-vault/Withdraw7540VaultHook.sol

Lines covered: 2 / 41 (4%)

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

40% lib/v2-core/src/libraries/HookDataDecoder.sol

Lines covered: 2 / 5 (40%)

// 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% lib/v2-core/src/libraries/HookSubTypes.sol

Lines covered: 8 / 23 (34%)

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

15% lib/v2-core/src/vendor/BytesLib.sol

Lines covered: 6 / 40 (15%)

// 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% src/Bank.sol

Lines covered: 0 / 35 (0%)

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.30;

// external
import { MerkleProof } from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import { ReentrancyGuard } from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

// Superform
import { IHookExecutionData } from "./interfaces/IHookExecutionData.sol";
import { ISuperHook, Execution } from "@superform-v2-core/src/interfaces/ISuperHook.sol";

abstract contract Bank is ReentrancyGuard {
    /*//////////////////////////////////////////////////////////////
                                ERRORS
    //////////////////////////////////////////////////////////////*/
    error INVALID_HOOK();
    error INVALID_MERKLE_PROOF();
    error HOOK_EXECUTION_FAILED();
    error ZERO_LENGTH_ARRAY();
    error INVALID_ARRAY_LENGTH();

    /*//////////////////////////////////////////////////////////////
                                EVENTS
    //////////////////////////////////////////////////////////////*/
    /// @notice Emitted when hooks are executed.
    /// @param hooks The addresses of the hooks that were executed.
    /// @param data The data passed to each hook.
    event HooksExecuted(address[] hooks, bytes[] data);

    /*//////////////////////////////////////////////////////////////
                                INTERNAL FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    function _getMerkleRootForHook(address hookAddress) internal view virtual returns (bytes32);

    function _executeHooks(IHookExecutionData.HookExecutionData calldata executionData) internal virtual nonReentrant {
        uint256 hooksLength = executionData.hooks.length;
        if (hooksLength == 0) revert ZERO_LENGTH_ARRAY();

        // Validate arrays have matching lengths
        if (hooksLength != executionData.data.length || hooksLength != executionData.merkleProofs.length) {
            revert INVALID_ARRAY_LENGTH();
        }

        address prevHook;
        address hookAddress;
        bytes memory hookData;
        bytes32[] memory merkleProof;
        ISuperHook hook;
        bytes32 merkleRoot;
        Execution[] memory executions;
        Execution memory executionStep;
        bytes32 targetLeaf;
        bool success;

        for (uint256 i; i < hooksLength; i++) {
            hookAddress = executionData.hooks[i];
            hookData = executionData.data[i];
            merkleProof = executionData.merkleProofs[i];

            hook = ISuperHook(hookAddress);

            // 1. Get the Merkle root specific to this hook
            merkleRoot = _getMerkleRootForHook(hookAddress);

            ISuperHook(hookAddress).setExecutionContext(address(this));

            // 2. Build Execution Steps
            executions = hook.build(prevHook, address(this), hookData);

            // 3. Execute Target Calls and verify each target
            for (uint256 j; j < executions.length; ++j) {
                executionStep = executions[j];

                // valid hooks encapsulate execution between a `.preExecute` and ` .postExecute`
                // target for preExecute and postExecute is the hook address
                // keep the original behavior for validating the tree against the actual execution steps
                if (executionStep.target != hookAddress) {
                    // Verify that this target is allowed for this hook using the Merkle proof
                    // The leaf is the hash of the target address
                    targetLeaf = keccak256(bytes.concat(keccak256(abi.encodePacked(executionStep.target))));
                    // Verify this target is allowed using the corresponding Merkle proof
                    if (!MerkleProof.verify(merkleProof, merkleRoot, targetLeaf)) {
                        revert INVALID_MERKLE_PROOF();
                    }
                }

                // Execute the call after verification
                (success,) = executionStep.target.call{ value: executionStep.value }(executionStep.callData);
                if (!success) {
                    revert HOOK_EXECUTION_FAILED();
                }
            }

            // Reset execution state after each hook
            ISuperHook(hookAddress).resetExecutionState(address(this));

            prevHook = hookAddress;
        }

        emit HooksExecuted(executionData.hooks, executionData.data);
    }
}

0% src/SuperAsset/IncentiveCalculationContract.sol

Lines covered: 0 / 39 (0%)

// SPDX-License-Identifier: MIT
pragma solidity 0.8.30;

import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";
import { IIncentiveCalculationContract } from "../interfaces/SuperAsset/IIncentiveCalculationContract.sol";

/// @title IncentiveCalculationContract
/// @author Superform Labs
/// @notice A stateless contract for calculating incentives.
contract IncentiveCalculationContract is IIncentiveCalculationContract {
    using Math for uint256;

    // --- Constants ---
    uint256 public constant PRECISION = 1e18;
    uint256 public constant PERC = 100e18;

    // --- View Functions ---
    /// @inheritdoc IIncentiveCalculationContract
    function energy(
        uint256[] memory currentAllocation,
        uint256[] memory allocationTarget,
        uint256[] memory weights,
        uint256 totalCurrentAllocation,
        uint256 totalAllocationTarget
    )
        public
        pure
        returns (uint256 res, bool isSuccess)
    {
        if (currentAllocation.length != allocationTarget.length || currentAllocation.length != weights.length) {
            // NOTE: This is a really corner a case that should never happen, this is why we let it revert even though
            // in general we do not allow view and pure functions to revert.
            revert INVALID_ARRAY_LENGTH();
        }

        // NOTE: This is to ensure we won't divide by zero in the subsequent calculations
        if (totalCurrentAllocation == 0 || totalAllocationTarget == 0) {
            return (0, false);
        }

        uint256 length = currentAllocation.length;
        for (uint256 i; i < length; i++) {
            uint256 _currentAllocation = Math.mulDiv(currentAllocation[i], PERC, totalCurrentAllocation);
            uint256 _targetAllocation = Math.mulDiv(allocationTarget[i], PERC, totalAllocationTarget);
            int256 diff = int256(_currentAllocation) - int256(_targetAllocation);
            // Square the difference and maintain precision
            uint256 diff2 = Math.mulDiv(uint256(diff * diff), 1, PRECISION);
            // Apply weight and maintain precision
            res += Math.mulDiv(diff2, weights[i], PRECISION);
        }
        return (res, true);
    }

    /// @inheritdoc IIncentiveCalculationContract
    function calculateIncentive(
        uint256[] memory allocationPreOperation,
        uint256[] memory allocationPostOperation,
        uint256[] memory allocationTarget,
        uint256[] memory weights,
        uint256 totalAllocationPreOperation,
        uint256 totalAllocationPostOperation,
        uint256 totalAllocationTarget,
        uint256 energyToUSDExchangeRatio
    )
        public
        pure
        returns (int256 incentiveUSD, bool isSuccess)
    {
        if (
            allocationPreOperation.length != allocationPostOperation.length
                || allocationPreOperation.length != allocationTarget.length
        ) {
            revert INVALID_ARRAY_LENGTH();
        }

        uint256 energyBefore;
        uint256 energyAfter;
        bool _isSuccess;

        (energyBefore, _isSuccess) = energy(
            allocationPreOperation, allocationTarget, weights, totalAllocationPreOperation, totalAllocationTarget
        );

        if (!_isSuccess) {
            return (0, false);
        }

        (energyAfter, _isSuccess) = energy(
            allocationPostOperation, allocationTarget, weights, totalAllocationPostOperation, totalAllocationTarget
        );

        if (!_isSuccess) {
            return (0, false);
        }

        // Calculate energy difference first
        int256 energyDiff = int256(energyBefore) - int256(energyAfter);

        // Handle positive and negative cases separately for safe multiplication
        if (energyDiff >= 0) {
            incentiveUSD = int256(Math.mulDiv(uint256(energyDiff), energyToUSDExchangeRatio, PRECISION));
        } else {
            incentiveUSD = -int256(Math.mulDiv(uint256(-energyDiff), energyToUSDExchangeRatio, PRECISION));
        }
        return (incentiveUSD, true);
    }
}

0% src/SuperAsset/IncentiveFundContract.sol

Lines covered: 0 / 69 (0%)

// SPDX-License-Identifier: MIT
pragma solidity 0.8.30;

import { IERC20Metadata } from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";
import { IIncentiveFundContract } from "../interfaces/SuperAsset/IIncentiveFundContract.sol";
import { ISuperGovernor } from "../interfaces/ISuperGovernor.sol";
import { ISuperAsset } from "../interfaces/SuperAsset/ISuperAsset.sol";
import { ISuperAssetFactory } from "../interfaces/SuperAsset/ISuperAssetFactory.sol";

/// @title Incentive Fund Contract
/// @author Superform Labs
/// @notice Manages incentive tokens in the SuperAsset system
/// @dev This contract is responsible for handling the incentive fund, including paying and taking incentives.
/// @dev For now it is OK to keep Access Control but it will be managed by SuperGovernor when ready, see
/// https://github.com/superform-xyz/v2-contracts/pull/377#discussion_r2058893391
contract IncentiveFundContract is IIncentiveFundContract {
    using SafeERC20 for IERC20;

    // --- State Variables ---
    address public tokenInIncentive;
    address public tokenOutIncentive;

    ISuperAsset public superAsset;
    ISuperGovernor public superGovernor;

    bool public incentivesActive;

    // --- Modifiers ---
    modifier onlyManager() {
        ISuperAssetFactory factory = ISuperAssetFactory(superGovernor.getAddress(superGovernor.SUPER_ASSET_FACTORY()));
        address manager = factory.getIncentiveFundManager(address(superAsset));
        if (msg.sender != manager) revert UNAUTHORIZED();
        _;
    }

    /// @inheritdoc IIncentiveFundContract
    function initialize(
        address _superGovernor,
        address superAsset_,
        address tokenInIncentive_,
        address tokenOutIncentive_
    )
        external
    {
        if (_superGovernor == address(0)) revert ZERO_ADDRESS();
        superGovernor = ISuperGovernor(_superGovernor);

        // Ensure this can only be called once
        if (address(superAsset) != address(0)) revert ALREADY_INITIALIZED();

        if (superAsset_ == address(0)) revert ZERO_ADDRESS();
        if (tokenInIncentive_ == address(0)) revert ZERO_ADDRESS();
        if (tokenOutIncentive_ == address(0)) revert ZERO_ADDRESS();

        superAsset = ISuperAsset(superAsset_);
        tokenInIncentive = tokenInIncentive_;
        tokenOutIncentive = tokenOutIncentive_;
    }

    /*//////////////////////////////////////////////////////////////
                          EXTERNAL FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc IIncentiveFundContract
    function setTokenInIncentive(address token) external onlyManager {
        if (token == address(0)) revert ZERO_ADDRESS();

        bool isWhitelisted = superGovernor.isWhitelistedIncentiveToken(token);

        if (isWhitelisted) {
            tokenInIncentive = token;
        } else {
            revert TOKEN_NOT_WHITELISTED();
        }

        emit SettlementTokenInSet(token);
    }

    /// @inheritdoc IIncentiveFundContract
    function setTokenOutIncentive(address token) external onlyManager {
        if (token == address(0)) revert ZERO_ADDRESS();

        bool isWhitelisted = superGovernor.isWhitelistedIncentiveToken(token);

        if (isWhitelisted) {
            tokenOutIncentive = token;
        } else {
            revert TOKEN_NOT_WHITELISTED();
        }

        emit SettlementTokenInSet(token);
    }

    /// @inheritdoc IIncentiveFundContract
    function toggleIncentives(bool enabled) external onlyManager {
        incentivesActive = enabled;
        emit IncentivesToggled(enabled);
    }

    /// @inheritdoc IIncentiveFundContract
    function payIncentive(address receiver, uint256 amountUSD) external onlyManager returns (uint256 amountToken) {
        if (!incentivesActive) {
            return 0;
        }

        _validateInput(receiver, amountUSD);
        if (tokenOutIncentive == address(0)) revert TOKEN_OUT_NOT_SET();

        // Get token price and check circuit breakers
        (uint256 priceUSD,,,) = superAsset.getPriceAndCircuitBreakers(tokenOutIncentive);

        if (priceUSD > 0) {
            // Convert USD amount to token amount using price
            // amountToken = amountUSD / priceUSD
            amountToken = Math.mulDiv(amountUSD, IERC20Metadata(tokenInIncentive).decimals(), priceUSD);

            IERC20(tokenOutIncentive).safeTransfer(receiver, amountToken);
            emit IncentivePaid(receiver, tokenOutIncentive, amountToken);
        }

        emit IncentivePaid(receiver, tokenOutIncentive, 0);
        return 0;
    }

    /// @inheritdoc IIncentiveFundContract
    function takeIncentive(address sender, uint256 amountUSD) external onlyManager returns (uint256 amountToken) {
        if (!incentivesActive) {
            return 0;
        }

        _validateInput(sender, amountUSD);
        if (tokenInIncentive == address(0)) revert TOKEN_IN_NOT_SET();

        // Get token price and check circuit breakers
        (uint256 priceUSD,,,) = superAsset.getPriceAndCircuitBreakers(tokenInIncentive);

        if (priceUSD > 0) {
            // Convert USD amount to token amount using price
            // amountToken = amountUSD / priceUSD
            amountToken = Math.mulDiv(amountUSD, IERC20Metadata(tokenInIncentive).decimals(), priceUSD);

            IERC20(tokenInIncentive).safeTransferFrom(sender, address(this), amountToken);
            emit IncentiveTaken(sender, tokenInIncentive, amountToken);
        }

        emit IncentiveTaken(sender, tokenInIncentive, 0);
        return 0;
    }

    /// @inheritdoc IIncentiveFundContract
    function withdraw(address receiver, address tokenOut, uint256 amount) external onlyManager {
        _validateInput(receiver, amount);
        if (tokenOut == address(0)) revert ZERO_ADDRESS();

        IERC20(tokenOut).safeTransfer(receiver, amount);
        emit RebalanceWithdrawal(receiver, tokenOut, amount);
    }

    /// @inheritdoc IIncentiveFundContract
    function incentivesEnabled() external view returns (bool) {
        return incentivesActive;
    }

    /*//////////////////////////////////////////////////////////////
                INTERNAL FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    function _validateInput(address user, uint256 amount) internal pure {
        if (user == address(0)) revert ZERO_ADDRESS();
        if (amount == 0) revert ZERO_AMOUNT();
    }
}

0% src/SuperAsset/SuperAsset.sol

Lines covered: 0 / 494 (0%)

// SPDX-License-Identifier: MIT
pragma solidity 0.8.30;

import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";
import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import { IERC20Metadata } from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import { EnumerableSet } from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";

import { ISuperGovernor } from "../interfaces/ISuperGovernor.sol";
import { ISuperAsset } from "../interfaces/SuperAsset/ISuperAsset.sol";
import { SuperAssetPriceLib } from "../libraries/SuperAssetPriceLib.sol";
import { ISuperAssetFactory } from "../interfaces/SuperAsset/ISuperAssetFactory.sol";
import { IIncentiveCalculationContract } from "../interfaces/SuperAsset/IIncentiveCalculationContract.sol";
import { IIncentiveFundContract } from "../interfaces/SuperAsset/IIncentiveFundContract.sol";

/// @title SuperAsset
/// @author Superform Labs
/// @notice A meta-vault that manages deposits and redemptions across multiple underlying vaults.
/// @dev Implements ERC20 standard for better compatibility with integrators.
contract SuperAsset is ERC20, ISuperAsset {
    using EnumerableSet for EnumerableSet.AddressSet;
    using SafeERC20 for IERC20;
    using Math for uint256;

    // --- Storage for ERC20 variables ---
    string private tokenName;
    string private tokenSymbol;

    // --- Interfaces ---
    ISuperGovernor private superGovernor;
    ISuperAssetFactory private factory;

    // --- Constants ---
    uint256 private constant PRECISION = 1e18;
    uint256 private constant DECIMALS = 18;
    uint256 private constant DEPEG_LOWER_THRESHOLD = 98e16; // 0.98
    uint256 private constant DEPEG_UPPER_THRESHOLD = 102e16; // 1.02
    uint256 private constant DISPERSION_THRESHOLD = 1e16; // 1% relative standard deviation threshold

    // --- Fee Constants ---
    uint256 public constant SWAP_FEE_PERC = 10 ** 6;
    uint256 public constant MAX_SWAP_FEE_PERC = 10 ** 4; // Max 10% (1000 basis points)

    // --- State Variables ---
    mapping(address token => TokenData data) private tokenData;

    // @notice Contains supported Vaults shares and standard ERC20s
    EnumerableSet.AddressSet private _supportedAssets;

    uint256 public swapFeeInPercentage; // Swap fee as a percentage (e.g., 10 for 0.1%)
    uint256 public swapFeeOutPercentage; // Swap fee as a percentage (e.g., 10 for 0.1%)
    uint256 public energyToUSDExchangeRatio;

    // --- Addresses ---
    address private constant USD = address(840);
    address public primaryAsset;

    // SuperOracle related
    bytes32 private constant AVERAGE_PROVIDER = keccak256("AVERAGE_PROVIDER");

    /*//////////////////////////////////////////////////////////////
                        CONTRACT INITIALIZATION
    //////////////////////////////////////////////////////////////*/
    constructor() ERC20("", "") { }

    /// @inheritdoc ISuperAsset
    function initialize(
        string memory name_,
        string memory symbol_,
        address asset,
        address superGovernor_,
        uint256 swapFeeInPercentage_,
        uint256 swapFeeOutPercentage_
    )
        external
    {
        // Ensure this can only be called once
        if (address(superGovernor) != address(0)) revert ALREADY_INITIALIZED();

        if (swapFeeInPercentage_ > MAX_SWAP_FEE_PERC) revert INVALID_SWAP_FEE_PERCENTAGE();
        if (swapFeeOutPercentage_ > MAX_SWAP_FEE_PERC) revert INVALID_SWAP_FEE_PERCENTAGE();

        swapFeeInPercentage = swapFeeInPercentage_;
        swapFeeOutPercentage = swapFeeOutPercentage_;

        // Initialize ERC20 name and symbol
        tokenName = name_;
        tokenSymbol = symbol_;

        primaryAsset = asset;

        superGovernor = ISuperGovernor(superGovernor_);
        factory = ISuperAssetFactory(superGovernor.getAddress(superGovernor.SUPER_ASSET_FACTORY()));
    }

    /*//////////////////////////////////////////////////////////////
                            MANAGER FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperAsset
    function whitelistERC20(address token) external {
        _onlyManager();
        if (token == address(0)) revert ZERO_ADDRESS();
        if (tokenData[token].isSupportedERC20) revert ALREADY_WHITELISTED();

        // Set token as supported and active
        tokenData[token].isSupportedERC20 = true;
        tokenData[token].isActive = true;

        tokenData[token].oracle = superGovernor.getAddress(superGovernor.SUPER_ORACLE());
        _supportedAssets.add(token);

        emit ERC20Whitelisted(token);
    }

    /// @inheritdoc ISuperAsset
    function removeERC20(address token) external {
        _onlyManager();
        if (token == address(0)) revert ZERO_ADDRESS();

        // Mark token as inactive
        tokenData[token].isActive = false;

        // Prevent full purge if token has 0 balance
        if (IERC20(token).balanceOf(address(this)) == 0) {
            // Full removal - clear all data
            _supportedAssets.remove(token);
            tokenData[token].oracle = address(0);
            tokenData[token].isSupportedERC20 = false;
        }

        emit ERC20Removed(token);
    }

    /// @inheritdoc ISuperAsset
    function activateERC20(address token) external {
        _onlyManager();
        if (token == address(0)) revert ZERO_ADDRESS();
        if (!tokenData[token].isSupportedERC20) revert TOKEN_NOT_SUPPORTED();
        if (tokenData[token].isActive) revert TOKEN_ALREADY_ACTIVE();

        // Reactivate the token
        tokenData[token].isActive = true;

        emit ERC20Activated(token);
    }

    /// @inheritdoc ISuperAsset
    function whitelistVault(address vault, address yieldSourceOracle) external {
        _onlyManager();
        if (vault == address(0) || yieldSourceOracle == address(0)) revert ZERO_ADDRESS();
        if (tokenData[vault].isSupportedUnderlyingVault) revert ALREADY_WHITELISTED();

        // Set vault as supported and active
        tokenData[vault].isSupportedUnderlyingVault = true;
        tokenData[vault].isActive = true;

        tokenData[vault].oracle = yieldSourceOracle;
        _supportedAssets.add(vault);

        emit VaultWhitelisted(vault);
    }

    /// @inheritdoc ISuperAsset
    function removeVault(address vault) external {
        _onlyManager();
        if (vault == address(0)) revert ZERO_ADDRESS();

        // Mark vault as inactive
        tokenData[vault].isActive = false;

        // Prevent full purge if vault has 9 balance
        if (IERC20(vault).balanceOf(address(this)) == 0) {
            // Full removal - clear all data
            _supportedAssets.remove(vault);
            tokenData[vault].oracle = address(0);
            tokenData[vault].isSupportedUnderlyingVault = false;
        }

        emit VaultRemoved(vault);
    }

    /// @inheritdoc ISuperAsset
    function activateVault(address vault) external {
        _onlyManager();
        if (vault == address(0)) revert ZERO_ADDRESS();
        if (!tokenData[vault].isSupportedUnderlyingVault) revert VAULT_NOT_SUPPORTED();
        if (tokenData[vault].isActive) revert TOKEN_ALREADY_ACTIVE();

        // Reactivate the vault
        tokenData[vault].isActive = true;

        emit VaultActivated(vault);
    }

    /// @inheritdoc ISuperAsset
    function setSwapFeeInPercentage(uint256 _feePercentage) external {
        _onlyManager();
        if (_feePercentage > MAX_SWAP_FEE_PERC) revert INVALID_SWAP_FEE_PERCENTAGE();
        swapFeeInPercentage = _feePercentage;
    }

    /// @inheritdoc ISuperAsset
    function setSwapFeeOutPercentage(uint256 _feePercentage) external {
        _onlyManager();
        if (_feePercentage > MAX_SWAP_FEE_PERC) revert INVALID_SWAP_FEE_PERCENTAGE();
        swapFeeOutPercentage = _feePercentage;
    }

    /// @inheritdoc ISuperAsset
    function setWeight(address vault, uint256 weight) external {
        _onlyManager();
        if (vault == address(0)) revert ZERO_ADDRESS();
        if (!tokenData[vault].isSupportedUnderlyingVault && !tokenData[vault].isSupportedERC20) revert NOT_SUPPORTED_TOKEN();
        tokenData[vault].weights = weight;
        emit WeightSet(vault, weight);
    }

    /// @inheritdoc ISuperAsset
    function setEnergyToUSDExchangeRatio(uint256 newRatio) external {
        _onlyManager();
        energyToUSDExchangeRatio = newRatio;
        emit EnergyToUSDExchangeRatioSet(newRatio);
    }

    /// @inheritdoc ISuperAsset
    function mint(address to, uint256 amount) external {
        _onlyManager();
        _mint(to, amount);
    }

    /// @inheritdoc ISuperAsset
    function burn(address from, uint256 amount) external {
        _onlyManager();
        _burn(from, amount);
    }

    /*//////////////////////////////////////////////////////////////
                          STRATEGIST FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperAsset
    function setTargetAllocations(address[] calldata tokens, uint256[] calldata allocations) external {
        _onlyStrategist();
        uint256 lenTokens = tokens.length;
        if (lenTokens != allocations.length) revert INVALID_INPUT();

        for (uint256 i; i < lenTokens; i++) {
            if (tokens[i] == address(0)) revert ZERO_ADDRESS();
            if (!tokenData[tokens[i]].isSupportedUnderlyingVault && !tokenData[tokens[i]].isSupportedERC20) {
                revert NOT_SUPPORTED_TOKEN();
            }
        }

        for (uint256 i; i < lenTokens; i++) {
            tokenData[tokens[i]].targetAllocations = allocations[i];
            emit TargetAllocationSet(tokens[i], allocations[i]);
        }
    }

    /// @inheritdoc ISuperAsset
    function setTargetAllocation(address token, uint256 allocation) external {
        _onlyStrategist();
        if (token == address(0)) revert ZERO_ADDRESS();
        if (!tokenData[token].isSupportedUnderlyingVault && !tokenData[token].isSupportedERC20) {
            revert NOT_SUPPORTED_TOKEN();
        }

        // @dev Allocations get normalized inside the ICC so we dont need to additional checks here
        tokenData[token].targetAllocations = allocation;
        emit TargetAllocationSet(token, allocation);
    }

    /*//////////////////////////////////////////////////////////////
                            EXTERNAL FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperAsset
    function deposit(DepositArgs memory args) public returns (DepositReturnVars memory ret) {
        // First all the non state changing functions
        if (args.receiver == address(0) || args.tokenIn == address(0)) revert ZERO_ADDRESS();
        if (args.amountTokenToDeposit == 0) revert ZERO_AMOUNT();
        if (
            !tokenData[args.tokenIn].isSupportedERC20 && !tokenData[args.tokenIn].isSupportedUnderlyingVault
                || !tokenData[args.tokenIn].isActive
        ) {
            revert NOT_SUPPORTED_TOKEN();
        }

        // Create preview deposit args
        PreviewDepositArgs memory previewArgs = PreviewDepositArgs({
            tokenIn: args.tokenIn,
            amountTokenToDeposit: args.amountTokenToDeposit,
            isSoft: false
        });

        // Call previewDeposit with the new struct approach
        PreviewDepositReturnVars memory previewRet = previewDeposit(previewArgs);

        // Store results in return variable
        ret.amountSharesMinted = previewRet.amountSharesMinted;
        ret.swapFee = previewRet.swapFee;
        ret.amountIncentiveUSDDeposit = previewRet.amountIncentiveUSDDeposit;

        // incentiveCalculationSuccess == false but totalSupply == 0 for the first deposit, this check allows for the
        // first deposit (in which case calculateIncentive() will fail) to pass
        if (!previewRet.incentiveCalculationSuccess && totalSupply() != 0) revert INCENTIVE_CALCULATION_FAILED();

        // Slippage Check
        if (ret.amountSharesMinted < args.minSharesOut) revert SLIPPAGE_PROTECTION();

        if (previewRet.assetWithBreakerTriggered != address(0)) {
            // Circuit Breaker Checks
            if (previewRet.isDepeg) {
                revert SUPPORTED_ASSET_PRICE_DEPEG(previewRet.assetWithBreakerTriggered);
            }
            if (previewRet.isOracleOff) {
                revert SUPPORTED_ASSET_PRICE_ORACLE_OFF(previewRet.assetWithBreakerTriggered);
            }
            if (previewRet.isDispersion) {
                revert SUPPORTED_ASSET_PRICE_DISPERSION(previewRet.assetWithBreakerTriggered);
            }
            if (previewRet.oraclePriceUSD == 0) {
                revert SUPPORTED_ASSET_PRICE_ZERO(previewRet.assetWithBreakerTriggered);
            }
        }

        if (!previewRet.tokenInFound) {
            revert NOT_SUPPORTED_TOKEN();
        }

        // Settle Incentives
        if (ret.amountIncentiveUSDDeposit > 0) {
            _settleIncentive(args.receiver, ret.amountIncentiveUSDDeposit);
        }

        // Transfer the tokenIn from the sender to this contract
        IERC20(args.tokenIn).safeTransferFrom(msg.sender, address(this), args.amountTokenToDeposit);

        // Transfer swap fees to SuperBank
        IERC20(args.tokenIn).safeTransfer(superGovernor.getAddress(superGovernor.SUPER_BANK()), ret.swapFee);
        // Mint SuperUSD shares
        _mint(args.receiver, ret.amountSharesMinted);

        emit Deposit(
            args.receiver,
            args.tokenIn,
            args.amountTokenToDeposit,
            ret.amountSharesMinted,
            ret.swapFee,
            ret.amountIncentiveUSDDeposit
        );
    }


    /// @inheritdoc ISuperAsset
    function redeem(RedeemArgs memory args) public returns (RedeemReturnVars memory ret) {
        // First validate parameters
        if (args.receiver == address(0) || args.tokenOut == address(0)) revert ZERO_ADDRESS();
        if (args.amountSharesToRedeem == 0) revert ZERO_AMOUNT();

        // NOTE: Only revert if the token was not in the whitelist even before 
        if (!_supportedAssets.contains(args.tokenOut)) revert NOT_SUPPORTED_TOKEN();

        // Create preview redeem args
        PreviewRedeemArgs memory previewArgs = PreviewRedeemArgs({
            tokenOut: args.tokenOut,
            amountSharesToRedeem: args.amountSharesToRedeem,
            // NOTE: Here we set isSoft=true on purpose since the desired behavior is to make the redeem() flow not to revert even in case of circtuit breakers triggered
            // The reason is the redeem() allows SuperAsset to sell assets and if an asset has circuit breakers triggered then it's likely an asset whose risk profile does not match the kind of risk that we desire in the SuperAsset balance sheet
            // This can be considered opinionated and an argument could be it should be the SuperAsset manager making decision on that, we think it can be discussed
            isSoft: true // isSoft = true for soft checks that won't revert on circuit breaker triggers
         });

        // Call previewRedeem with the new struct approach
        PreviewRedeemReturnVars memory previewRet = previewRedeem(previewArgs);

        // Store results in return variable
        ret.amountTokenOutAfterFees = previewRet.amountTokenOutAfterFees;
        ret.swapFee = previewRet.swapFee;
        ret.amountIncentiveUSDRedeem = previewRet.amountIncentiveUSDRedeem;

        // --- Post-preview checks ---
        // incentiveCalculationSuccess == false but totalSupply == 0 for the first deposit, this check allows for the
        // first deposit (in which case calculateIncentive() will fail) to pass. Similar logic applies to redeem.
        if (!previewRet.incentiveCalculationSuccess && totalSupply() != 0) revert INCENTIVE_CALCULATION_FAILED();

        // Slippage Check
        if (ret.amountTokenOutAfterFees < args.minTokenOut) revert SLIPPAGE_PROTECTION();

        // Circuit Breaker Checks
        if (previewRet.assetWithBreakerTriggered != address(0)) {
            if (previewRet.isDepeg) {
                revert SUPPORTED_ASSET_PRICE_DEPEG(previewRet.assetWithBreakerTriggered);
            }
            if (previewRet.isOracleOff) {
                revert SUPPORTED_ASSET_PRICE_ORACLE_OFF(previewRet.assetWithBreakerTriggered);
            }
            if (previewRet.isDispersion) {
                revert SUPPORTED_ASSET_PRICE_DISPERSION(previewRet.assetWithBreakerTriggered);
            }
            if (previewRet.oraclePriceUSD == 0) {
                revert SUPPORTED_ASSET_PRICE_ZERO(previewRet.assetWithBreakerTriggered);
            }
        }

        if (!previewRet.tokenOutFound) {
            revert NOT_SUPPORTED_TOKEN(); // Or a more specific error if tokenOut_ was expected to be found by preview
        }

        // --- State Changing Operations ---

        // Settle Incentives
        if (ret.amountIncentiveUSDRedeem > 0) {
            _settleIncentive(args.receiver, ret.amountIncentiveUSDRedeem);
        }
        // Burn SuperUSD shares from the sender
        _burn(msg.sender, args.amountSharesToRedeem);

        // Transfer swap fees to SuperBank
        IERC20(args.tokenOut).safeTransfer(superGovernor.getAddress(superGovernor.SUPER_BANK()), ret.swapFee);

        // Transfer assets to receiver
        IERC20(args.tokenOut).safeTransfer(args.receiver, ret.amountTokenOutAfterFees);

        // --- Emit event and set return values ---
        emit Redeem(
            args.receiver,
            args.tokenOut,
            args.amountSharesToRedeem,
            ret.amountTokenOutAfterFees,
            ret.swapFee,
            ret.amountIncentiveUSDRedeem
        );
    }

    /// @inheritdoc ISuperAsset
    function swap(SwapArgs memory args) external returns (SwapReturnVars memory ret) {
        if (args.receiver == address(0) || args.tokenIn == address(0) || args.tokenOut == address(0)) {
            revert ZERO_ADDRESS();
        }

        // Create deposit args from swap args
        DepositArgs memory depositArgs = DepositArgs({
            receiver: msg.sender,
            tokenIn: args.tokenIn,
            amountTokenToDeposit: args.amountTokenToDeposit,
            minSharesOut: 0
        });
        DepositReturnVars memory depositRet = deposit(depositArgs);

        // Create redeem args from swap args and deposit result
        RedeemArgs memory redeemArgs = RedeemArgs({
            receiver: args.receiver,
            amountSharesToRedeem: depositRet.amountSharesMinted,
            tokenOut: args.tokenOut,
            minTokenOut: args.minTokenOut
        });
        RedeemReturnVars memory redeemRet = redeem(redeemArgs);

        // Fill the return struct
        ret.amountSharesIntermediateStep = depositRet.amountSharesMinted;
        ret.amountTokenOutAfterFees = redeemRet.amountTokenOutAfterFees;
        ret.swapFeeIn = depositRet.swapFee;
        ret.swapFeeOut = redeemRet.swapFee;
        ret.amountIncentivesIn = depositRet.amountIncentiveUSDDeposit;
        ret.amountIncentivesOut = redeemRet.amountIncentiveUSDRedeem;

        emit Swap(
            args.receiver,
            args.tokenIn,
            args.amountTokenToDeposit,
            args.tokenOut,
            ret.amountSharesIntermediateStep,
            ret.amountTokenOutAfterFees,
            ret.swapFeeIn,
            ret.swapFeeOut,
            ret.amountIncentivesIn,
            ret.amountIncentivesOut
        );
    }

    /*//////////////////////////////////////////////////////////////
                            PREVIEW FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperAsset
    function previewDeposit(PreviewDepositArgs memory args) public view returns (PreviewDepositReturnVars memory ret) {
        // Calculate swap fees
        ret.swapFee = Math.mulDiv(args.amountTokenToDeposit, swapFeeInPercentage, SWAP_FEE_PERC);

        // Get current and post-operation allocations using the struct-based return value
        ISuperAsset.AllocationOperationReturnVars memory allocRet = getAllocationsPrePostOperationDeposit(
            args.tokenIn, args.amountTokenToDeposit, args.amountTokenToDeposit - ret.swapFee, args.isSoft
        );

        // Copy values from allocation return struct to our local variable
        ret.amountSharesMinted = allocRet.amountAssets;

        // Copy circuit breaker info to return struct
        ret.assetWithBreakerTriggered = allocRet.assetWithBreakerTriggered;
        ret.oraclePriceUSD = allocRet.oraclePriceUSD;
        ret.isDepeg = allocRet.isDepeg;
        ret.isDispersion = allocRet.isDispersion;
        ret.isOracleOff = allocRet.isOracleOff;
        ret.tokenInFound = allocRet.tokenFound;

        if ((ret.isDepeg || ret.isDispersion || ret.isOracleOff || ret.oraclePriceUSD == 0)) {
            // Early return with empty result but with circuit breaker info
            ret.amountSharesMinted = 0;
            ret.swapFee = 0;
            ret.amountIncentiveUSDDeposit = 0;
            ret.incentiveCalculationSuccess = false;

            return ret;
        }

        // Calculate incentives (via ICC)
        if (IIncentiveFundContract(factory.getIncentiveFundContract(address(this))).incentivesEnabled()) {
            (ret.amountIncentiveUSDDeposit, ret.incentiveCalculationSuccess) = IIncentiveCalculationContract(
                factory.getIncentiveCalculationContract(address(this))
            ).calculateIncentive(
                allocRet.absoluteAllocationPreOperation,
                allocRet.absoluteAllocationPostOperation,
                allocRet.absoluteTargetAllocation,
                allocRet.vaultWeights,
                allocRet.totalAllocationPreOperation,
                allocRet.totalAllocationPostOperation,
                allocRet.totalTargetAllocation,
                energyToUSDExchangeRatio
            );
        } else {
            // if incentives disabled, soft return incentiveCalculationSuccess as true
            ret.incentiveCalculationSuccess = true;
        }
    }

    /// @inheritdoc ISuperAsset
    function previewRedeem(PreviewRedeemArgs memory args) public view returns (PreviewRedeemReturnVars memory ret) {
        // Get current and post-operation allocations using the struct-based return value
        ISuperAsset.AllocationOperationReturnVars memory allocRet =
            getAllocationsPrePostOperationRedeem(args.tokenOut, args.amountSharesToRedeem, args.isSoft);

        // Copy circuit breaker info to return struct
        ret.assetWithBreakerTriggered = allocRet.assetWithBreakerTriggered;
        ret.oraclePriceUSD = allocRet.oraclePriceUSD;
        ret.isDepeg = allocRet.isDepeg;
        ret.isDispersion = allocRet.isDispersion;
        ret.isOracleOff = allocRet.isOracleOff;
        ret.tokenOutFound = allocRet.tokenFound;

        if ((ret.isDepeg || ret.isDispersion || ret.isOracleOff || ret.oraclePriceUSD == 0)) {
            // Early return with empty result but with circuit breaker info
            ret.amountTokenOutAfterFees = 0;
            ret.swapFee = 0;
            ret.amountIncentiveUSDRedeem = 0;
            ret.incentiveCalculationSuccess = false;

            return ret;
        }

        // Calculate swap fee
        ret.swapFee = Math.mulDiv(allocRet.amountAssets, swapFeeOutPercentage, SWAP_FEE_PERC); // 0.1%
        ret.amountTokenOutAfterFees = allocRet.amountAssets - ret.swapFee;

        // Calculate incentives (via ICC)
        if (IIncentiveFundContract(factory.getIncentiveFundContract(address(this))).incentivesEnabled()) {
            (ret.amountIncentiveUSDRedeem, ret.incentiveCalculationSuccess) = IIncentiveCalculationContract(
                factory.getIncentiveCalculationContract(address(this))
            ).calculateIncentive(
                allocRet.absoluteAllocationPreOperation,
                allocRet.absoluteAllocationPostOperation,
                allocRet.absoluteTargetAllocation,
                allocRet.vaultWeights,
                allocRet.totalAllocationPreOperation,
                allocRet.totalAllocationPostOperation,
                allocRet.totalTargetAllocation,
                energyToUSDExchangeRatio
            );
        } else {
            // if incentives disabled, soft return incentiveCalculationSuccess as true
            ret.incentiveCalculationSuccess = true;
        }
    }

    /// @inheritdoc ISuperAsset
    function previewSwap(PreviewSwapArgs memory args) external view returns (PreviewSwapReturnVars memory ret) {
        uint256 amountSharesMinted;
        // Create preview deposit args
        PreviewDepositArgs memory depositArgs = PreviewDepositArgs({
            tokenIn: args.tokenIn,
            amountTokenToDeposit: args.amountTokenToDeposit,
            isSoft: args.isSoft
        });

        // Call previewDeposit with the new struct approach
        PreviewDepositReturnVars memory depositRet = previewDeposit(depositArgs);

        // Store results
        amountSharesMinted = depositRet.amountSharesMinted;
        ret.swapFeeIn = depositRet.swapFee;
        ret.amountIncentiveUSDDeposit = depositRet.amountIncentiveUSDDeposit;
        ret.assetWithBreakerTriggered = depositRet.assetWithBreakerTriggered;
        ret.oraclePriceUSD = depositRet.oraclePriceUSD;
        ret.isDepeg = depositRet.isDepeg;
        ret.isDispersion = depositRet.isDispersion;
        ret.isOracleOff = depositRet.isOracleOff;
        ret.tokenInFound = depositRet.tokenInFound;
        ret.incentiveCalculationSuccess = depositRet.incentiveCalculationSuccess;

        if (
            !ret.tokenInFound || ret.isDepeg || ret.isDispersion || ret.isOracleOff || !ret.incentiveCalculationSuccess
                || ret.oraclePriceUSD == 0
        ) {
            // Return empty result but with circuit breaker info
            ret.amountTokenOutAfterFees = 0;
            ret.swapFeeOut = 0;
            ret.amountIncentiveUSDRedeem = 0;
            return ret;
        }

        // note: it is possible to optimize the calls to oracle if the logic is extracted inside the preview functions

        // Create preview redeem args
        PreviewRedeemArgs memory redeemArgs = PreviewRedeemArgs({
            tokenOut: args.tokenOut,
            amountSharesToRedeem: amountSharesMinted,
            isSoft: args.isSoft
        });

        // Call previewRedeem with the new struct approach
        PreviewRedeemReturnVars memory redeemRet = previewRedeem(redeemArgs);

        // Store results
        ret.amountTokenOutAfterFees = redeemRet.amountTokenOutAfterFees;
        ret.swapFeeOut = redeemRet.swapFee;
        ret.amountIncentiveUSDRedeem = redeemRet.amountIncentiveUSDRedeem;
        ret.assetWithBreakerTriggered = redeemRet.assetWithBreakerTriggered;
        ret.oraclePriceUSD = redeemRet.oraclePriceUSD;
        ret.isDepeg = redeemRet.isDepeg;
        ret.isDispersion = redeemRet.isDispersion;
        ret.isOracleOff = redeemRet.isOracleOff;
        ret.tokenInFound = redeemRet.tokenOutFound; // Mapped from tokenOutFound
        ret.incentiveCalculationSuccess = redeemRet.incentiveCalculationSuccess;
    }

    /*//////////////////////////////////////////////////////////////
                        EXTERNAL GETTER FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperAsset
    function getTokenData(address token) external view returns (TokenData memory) {
        return tokenData[token];
    }

    /// @inheritdoc ISuperAsset
    function getPrecision() external pure returns (uint256) {
        return PRECISION;
    }

    /*//////////////////////////////////////////////////////////////
                        PUBLIC GETTER FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperAsset
    function getPriceAndCircuitBreakers(address token)
        public
        view
        returns (uint256 priceUSD, bool isDepeg, bool isDispersion, bool isOracleOff)
    {
        address superOracle = superGovernor.getAddress(superGovernor.SUPER_ORACLE());

        return SuperAssetPriceLib.getPriceWithCircuitBreakers(
            ISuperAsset.PriceArgs({
                superOracle: superOracle,
                superAsset: address(this),
                token: token,
                usd: USD,
                depegLowerThreshold: DEPEG_LOWER_THRESHOLD,
                depegUpperThreshold: DEPEG_UPPER_THRESHOLD,
                dispersionThreshold: DISPERSION_THRESHOLD
            })
        );
    }

    /// @inheritdoc ISuperAsset
    function getSuperAssetPPS()
        external
        view
        returns (
            address[] memory activeTokens,
            uint256[] memory pricePerTokenUSD,
            bool[] memory isDepeg,
            bool[] memory isDispersion,
            bool[] memory isOracleOff,
            uint256 pps
        )
    {
        uint256 len = _supportedAssets.length();
        activeTokens = new address[](len);
        pricePerTokenUSD = new uint256[](len);
        isDepeg = new bool[](len);
        isDispersion = new bool[](len);
        isOracleOff = new bool[](len);

        uint256 totalValueUSD;
        for (uint256 i; i < len; i++) {
            address token = _supportedAssets.at(i);
            activeTokens[i] = token;

            (uint256 priceUSD, bool isTokenDepeg, bool isTokenDispersion, bool isTokenOracleOff) =
                getPriceAndCircuitBreakers(token);

            pricePerTokenUSD[i] = priceUSD;
            isDepeg[i] = isTokenDepeg;
            isDispersion[i] = isTokenDispersion;
            isOracleOff[i] = isTokenOracleOff;

            uint256 balance = IERC20(token).balanceOf(address(this));

            if (balance > 0) {
                totalValueUSD += Math.mulDiv(balance, priceUSD, 10 ** IERC20Metadata(token).decimals());
            }
        }

        uint256 totalSupply_ = totalSupply();
        // PPS = Total Value in USD / Total Supply, normalized to PRECISION
        if (totalSupply_ == 0) {
            pps = PRECISION;
        } else {
            pps = Math.mulDiv(totalValueUSD, PRECISION, totalSupply_);
        }
    }

    /// @inheritdoc ISuperAsset
    function getAllocations()
        external
        view
        returns (
            uint256[] memory absoluteCurrentAllocation,
            uint256 totalCurrentAllocation,
            uint256[] memory absoluteTargetAllocation,
            uint256 totalTargetAllocation
        )
    {
        uint256 length = _supportedAssets.length();
        absoluteCurrentAllocation = new uint256[](length);
        absoluteTargetAllocation = new uint256[](length);
        for (uint256 i; i < length; i++) {
            address vault = _supportedAssets.at(i);
            absoluteCurrentAllocation[i] = IERC20(vault).balanceOf(address(this));
            totalCurrentAllocation += absoluteCurrentAllocation[i];
            absoluteTargetAllocation[i] = tokenData[vault].targetAllocations;
            totalTargetAllocation += absoluteTargetAllocation[i];
        }
    }

    /// @inheritdoc ISuperAsset
    function getAllocationsPrePostOperationDeposit(
        address token,
        uint256 deltaToken,
        uint256 amountToken,
        bool isSoft
    )
        public
        view
        returns (ISuperAsset.AllocationOperationReturnVars memory ret)
    {
        GetAllocationsPrePostOperationsDeposit memory s;

        s.extendedLength = _supportedAssets.length();
        // Initialize the arrays in the return struct
        ret.absoluteAllocationPreOperation = new uint256[](s.extendedLength);
        ret.absoluteAllocationPostOperation = new uint256[](s.extendedLength);
        ret.absoluteTargetAllocation = new uint256[](s.extendedLength);
        ret.vaultWeights = new uint256[](s.extendedLength);
        s.totalValueUSD = 0;
        s.priceUSDToken = 0;

        for (uint256 i; i < s.extendedLength; i++) {
            s.token = _supportedAssets.at(i);
            (ret.oraclePriceUSD, ret.isDepeg, ret.isDispersion, ret.isOracleOff) = getPriceAndCircuitBreakers(s.token);

            if (!isSoft && (ret.isDepeg || ret.isDispersion || ret.isOracleOff || ret.oraclePriceUSD == 0)) {
                // Return early with circuit breaker information
                ret.assetWithBreakerTriggered = s.token;
                return ret;
            }

            s.balance = IERC20(s.token).balanceOf(address(this));
            uint256 decimals = IERC20Metadata(s.token).decimals();
            if (s.balance > 0) {
                s.totalValueUSD += Math.mulDiv(s.balance, ret.oraclePriceUSD, 10 ** decimals);
            }
            // Convert balance to USD value using price
            ret.absoluteAllocationPreOperation[i] = Math.mulDiv(s.balance, ret.oraclePriceUSD, 10 ** decimals);
            ret.totalAllocationPreOperation += ret.absoluteAllocationPreOperation[i];
            ret.absoluteAllocationPostOperation[i] = ret.absoluteAllocationPreOperation[i];
            if (s.token == token) {
                s.priceUSDToken = ret.oraclePriceUSD;
                ret.tokenFound = true;
                s.absDeltaValue = Math.mulDiv(deltaToken, s.priceUSDToken, 10 ** decimals);
                s.deltaValue = int256(s.absDeltaValue);
                ret.absoluteAllocationPostOperation[i] =
                    uint256(int256(ret.absoluteAllocationPreOperation[i]) + s.deltaValue);
            }
            ret.totalAllocationPostOperation += ret.absoluteAllocationPostOperation[i];
            ret.absoluteTargetAllocation[i] = tokenData[s.token].targetAllocations;
            ret.totalTargetAllocation += ret.absoluteTargetAllocation[i];
            ret.vaultWeights[i] = tokenData[s.token].weights;
        }

        uint256 superAssetPPS;
        uint256 totalSupply_ = totalSupply();
        // PPS = Total Value in USD / Total Supply, normalized to PRECISION
        if (totalSupply_ == 0) {
            superAssetPPS = PRECISION;
        } else {
            superAssetPPS = Math.mulDiv(s.totalValueUSD, PRECISION, totalSupply_);
        }

        ret.amountAssets = Math.mulDiv(amountToken, s.priceUSDToken, superAssetPPS);

        uint8 decimalsToken = IERC20Metadata(token).decimals();

        // Adjust for decimals
        if (decimalsToken < DECIMALS) {
            ret.amountAssets = Math.mulDiv(ret.amountAssets, 10 ** (DECIMALS - decimalsToken), PRECISION);
        } else if (decimalsToken > DECIMALS) {
            ret.amountAssets = Math.mulDiv(ret.amountAssets, 10 ** (decimalsToken - DECIMALS), PRECISION);
        }
    }

    /// @inheritdoc ISuperAsset
    function getAllocationsPrePostOperationRedeem(
        address token,
        uint256 amountToken,
        bool isSoft
    )
        public
        view
        returns (ISuperAsset.AllocationOperationReturnVars memory ret)
    {
        // 1. if deposit, deltaToken is amountTokenToDeposit (that the user sent)
        // 2. however, if redeem, all prices are fetched first (priceUSD of token out and superAsset PPS)
        // 2.1 then, these prices are used to calculate amountTokenOutBeforeFees, which is the delta token
        GetAllocationsPrePostOperationsRedeem memory s;

        s.extendedLength = _supportedAssets.length();
        s.oraclePriceUSDs = new uint256[](s.extendedLength);
        s.balances = new uint256[](s.extendedLength);
        s.decimals = new uint256[](s.extendedLength);
        s.isDepegs = new bool[](s.extendedLength);
        s.isDispersions = new bool[](s.extendedLength);
        s.isOracleOffs = new bool[](s.extendedLength);
        s.totalValueUSD = 0;
        s.priceUSDToken = 0;

        for (uint256 i; i < s.extendedLength; i++) {
            s.token = _supportedAssets.at(i);
            (s.oraclePriceUSDs[i], s.isDepegs[i], s.isDispersions[i], s.isOracleOffs[i]) =
                getPriceAndCircuitBreakers(s.token);

            if (!isSoft && (s.isDepegs[i] || s.isDispersions[i] || s.isOracleOffs[i] || s.oraclePriceUSDs[i] == 0)) {
                // Return early with circuit breaker information
                ret.assetWithBreakerTriggered = s.token;
                ret.oraclePriceUSD = s.oraclePriceUSDs[i];
                ret.isDepeg = s.isDepegs[i];
                ret.isDispersion = s.isDispersions[i];
                ret.isOracleOff = s.isOracleOffs[i];
                return ret;
            }

            s.balances[i] = IERC20(s.token).balanceOf(address(this));
            s.decimals[i] = IERC20Metadata(s.token).decimals();
            if (s.balances[i] > 0) {
                s.totalValueUSD += Math.mulDiv(s.balances[i], s.oraclePriceUSDs[i], 10 ** s.decimals[i]);
            }
            if (s.token == token) {
                s.priceUSDToken = s.oraclePriceUSDs[i];
                ret.tokenFound = true;
            }

            if (i == s.extendedLength - 1) {
                // Assign critical info to re-assure no breaker triggered
                ret.assetWithBreakerTriggered = s.token;
                ret.oraclePriceUSD = s.oraclePriceUSDs[i];
                ret.isDepeg = s.isDepegs[i];
                ret.isDispersion = s.isDispersions[i];
                ret.isOracleOff = s.isOracleOffs[i];
            }
        }

        // Initialize the arrays in the return struct
        ret.absoluteAllocationPreOperation = new uint256[](s.extendedLength);
        ret.absoluteAllocationPostOperation = new uint256[](s.extendedLength);
        ret.absoluteTargetAllocation = new uint256[](s.extendedLength);
        ret.vaultWeights = new uint256[](s.extendedLength);

        uint256 totalSupply_ = totalSupply();
        // PPS = Total Value in USD / Total Supply, normalized to PRECISION
        if (totalSupply_ == 0) {
            s.superAssetPPS = PRECISION;
        } else {
            s.superAssetPPS = Math.mulDiv(s.totalValueUSD, PRECISION, totalSupply_);
        }

        ret.amountAssets = Math.mulDiv(amountToken, s.superAssetPPS, s.priceUSDToken);

        s.decimalsToken = IERC20Metadata(token).decimals();

        // Adjust for decimals
        if (s.decimalsToken < DECIMALS) {
            ret.amountAssets = Math.mulDiv(ret.amountAssets, 10 ** (DECIMALS - s.decimalsToken), PRECISION);
        } else if (s.decimalsToken > DECIMALS) {
            ret.amountAssets = Math.mulDiv(ret.amountAssets, 10 ** (s.decimalsToken - DECIMALS), PRECISION);
        }

        s.balanceOfDeltaToken = IERC20(token).balanceOf(address(this));
        if (ret.amountAssets > s.balanceOfDeltaToken) {
            // NOTE: Since we do not want this function to revert, we re-set the amount out to the max possible amount
            // out which is the balance of this token
            // NOTE: This should be OK since the user can control the min amount out they desire with the slippage
            // protection
            s.deltaToken = s.balanceOfDeltaToken;
        } else {
            s.deltaToken = ret.amountAssets;
        }

        for (uint256 i; i < s.extendedLength; i++) {
            s.token = _supportedAssets.at(i);
            // Convert balance to USD value using price
            ret.absoluteAllocationPreOperation[i] =
                Math.mulDiv(s.balances[i], s.oraclePriceUSDs[i], 10 ** s.decimals[i]);
            ret.totalAllocationPreOperation += ret.absoluteAllocationPreOperation[i];
            ret.absoluteAllocationPostOperation[i] = ret.absoluteAllocationPreOperation[i];
            if (s.token == token) {
                s.absDeltaValue = Math.mulDiv(s.deltaToken, s.oraclePriceUSDs[i], 10 ** s.decimals[i]);
                s.deltaValue = -int256(s.absDeltaValue);
                ret.absoluteAllocationPostOperation[i] =
                    uint256(int256(ret.absoluteAllocationPreOperation[i]) + s.deltaValue);
            }
            ret.totalAllocationPostOperation += ret.absoluteAllocationPostOperation[i];
            ret.absoluteTargetAllocation[i] = tokenData[s.token].targetAllocations;
            ret.totalTargetAllocation += ret.absoluteTargetAllocation[i];
            ret.vaultWeights[i] = tokenData[s.token].weights;
        }
    }

    /// @inheritdoc ISuperAsset
    function getPrimaryAsset() external view returns (address) {
        return primaryAsset;
    }

    /*//////////////////////////////////////////////////////////////
                            ERC20 OVERRIDES
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ERC20

    function name() public view override returns (string memory) {
        return tokenName;
    }

    /// @inheritdoc ERC20
    function symbol() public view override returns (string memory) {
        return tokenSymbol;
    }

    /*//////////////////////////////////////////////////////////////
                            INTERNAL FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    /// @dev Settles incentives for a user
    /// @param user The address of the user to settle incentives for
    /// @param amountIncentiveUSD The amount of incentives to settle
    function _settleIncentive(address user, int256 amountIncentiveUSD) internal {
        // Pay or take incentives based on the sign of amountIncentive
        if (amountIncentiveUSD > 0) {
            IIncentiveFundContract(factory.getIncentiveFundContract(address(this))).payIncentive(
                user, uint256(amountIncentiveUSD)
            );
        } else if (amountIncentiveUSD < 0) {
            IIncentiveFundContract(factory.getIncentiveFundContract(address(this))).takeIncentive(
                user, uint256(-amountIncentiveUSD)
            );
        }
    }

    // --- Modifiers ---
    function _onlyStrategist() internal view {
        if (msg.sender != factory.getSuperAssetStrategist(address(this))) revert UNAUTHORIZED();
    }

    function _onlyManager() internal view {
        if (msg.sender != factory.getSuperAssetManager(address(this))) revert UNAUTHORIZED();
    }
}

0% src/SuperAsset/SuperAssetFactory.sol

Lines covered: 0 / 70 (0%)

// SPDX-License-Identifier: MIT
pragma solidity 0.8.30;

import { Clones } from "@openzeppelin/contracts/proxy/Clones.sol";
import { ISuperAssetFactory } from "../interfaces/SuperAsset/ISuperAssetFactory.sol";
import { SuperAsset } from "./SuperAsset.sol";
import { IncentiveFundContract } from "./IncentiveFundContract.sol";
import { IncentiveCalculationContract } from "./IncentiveCalculationContract.sol";

/**
 * @title SuperAssetFactory
 * @author Superform Labs
 * @notice Factory contract that deploys SuperAsset and its dependencies
 */
contract SuperAssetFactory is ISuperAssetFactory {
    using Clones for address;

    /*//////////////////////////////////////////////////////////////
                                STATE
    //////////////////////////////////////////////////////////////*/
    address public immutable superAssetImplementation;
    address public immutable incentiveFundImplementation;
    // Single instances
    address public immutable superGovernor;

    mapping(address superAsset => SuperAssetData data) public data;
    mapping(address icc => bool isValid) public incentiveCalculationContractsWhitelist;

    /*//////////////////////////////////////////////////////////////
                            CONSTRUCTOR
    //////////////////////////////////////////////////////////////*/
    constructor(address _superGovernor) {
        if (_superGovernor == address(0)) revert ZERO_ADDRESS();
        superGovernor = _superGovernor;

        superAssetImplementation = address(new SuperAsset());
        incentiveFundImplementation = address(new IncentiveFundContract());
    }

    /// @inheritdoc ISuperAssetFactory
    function addICCToWhitelist(address icc) external {
        if (msg.sender != superGovernor) revert UNAUTHORIZED();
        incentiveCalculationContractsWhitelist[icc] = true;
    }

    /// @inheritdoc ISuperAssetFactory
    function removeICCFromWhitelist(address icc) external {
        if (msg.sender != superGovernor) revert UNAUTHORIZED();
        incentiveCalculationContractsWhitelist[icc] = false;
    }

    /// @inheritdoc ISuperAssetFactory
    function isICCWhitelisted(address icc) external view returns (bool) {
        return incentiveCalculationContractsWhitelist[icc];
    }

    /// @inheritdoc ISuperAssetFactory
    function setSuperAssetManager(address superAsset, address _superAssetManager) external {
        if (_superAssetManager == address(0)) revert ZERO_ADDRESS();
        if (
            (msg.sender != data[superAsset].superAssetManager) && (msg.sender != superGovernor) // NOTE: This role can
                // take over
        ) revert UNAUTHORIZED();
        data[superAsset].superAssetManager = _superAssetManager;
    }

    /// @inheritdoc ISuperAssetFactory
    function setSuperAssetStrategist(address superAsset, address _superAssetStrategist) external {
        if (_superAssetStrategist == address(0)) revert ZERO_ADDRESS();
        if (msg.sender != data[superAsset].superAssetManager) revert UNAUTHORIZED();
        data[superAsset].superAssetStrategist = _superAssetStrategist;
    }

    /// @inheritdoc ISuperAssetFactory
    function setIncentiveFundManager(address superAsset, address _incentiveFundManager) external {
        if (_incentiveFundManager == address(0)) revert ZERO_ADDRESS();
        if (msg.sender != data[superAsset].superAssetManager) revert UNAUTHORIZED();
        data[superAsset].incentiveFundManager = _incentiveFundManager;
    }

    /// @inheritdoc ISuperAssetFactory
    function setIncentiveCalculationContract(address superAsset, address _incentiveCalculationContract) external {
        if (_incentiveCalculationContract == address(0)) revert ZERO_ADDRESS();
        if (!incentiveCalculationContractsWhitelist[_incentiveCalculationContract]) revert ICC_NOT_WHITELISTED();
        if (msg.sender != data[superAsset].superAssetManager) revert UNAUTHORIZED();
        data[superAsset].incentiveCalculationContract = _incentiveCalculationContract;
    }

    /// @inheritdoc ISuperAssetFactory
    function getSuperAssetManager(address superAsset) external view returns (address) {
        return data[superAsset].superAssetManager;
    }

    /// @inheritdoc ISuperAssetFactory
    function getSuperAssetStrategist(address superAsset) external view returns (address) {
        return data[superAsset].superAssetStrategist;
    }

    /// @inheritdoc ISuperAssetFactory
    function getIncentiveFundManager(address superAsset) external view returns (address) {
        return data[superAsset].incentiveFundManager;
    }

    /// @inheritdoc ISuperAssetFactory
    function getIncentiveCalculationContract(address superAsset) external view returns (address) {
        return data[superAsset].incentiveCalculationContract;
    }

    /// @inheritdoc ISuperAssetFactory
    function getIncentiveFundContract(address superAsset) external view returns (address) {
        return data[superAsset].incentiveFundContract;
    }

    /*//////////////////////////////////////////////////////////////
                            EXTERNAL FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperAssetFactory
    function createSuperAsset(AssetCreationParams calldata params)
        external
        returns (address superAsset, address incentiveFundContract)
    {
        // TODO: Decide whether to make this method permissionless or permissioned

        if (params.incentiveCalculationContract == address(0)) revert ZERO_ADDRESS();
        if (!incentiveCalculationContractsWhitelist[params.incentiveCalculationContract]) revert ICC_NOT_WHITELISTED();

        // Deploy IncentiveFund (this one needs to be unique per SuperAsset)
        incentiveFundContract = incentiveFundImplementation.clone();

        // Deploy SuperAsset with its dependencies
        superAsset = superAssetImplementation.clone();
        SuperAsset(superAsset).initialize(
            params.name,
            params.symbol,
            params.asset,
            superGovernor,
            params.swapFeeInPercentage,
            params.swapFeeOutPercentage
        );

        // Initialize IncentiveFund
        IncentiveFundContract(incentiveFundContract).initialize(
            superGovernor, superAsset, params.tokenInIncentive, params.tokenOutIncentive
        );

        data[superAsset] = SuperAssetData({
            superAssetManager: params.superAssetManager,
            superAssetStrategist: params.superAssetStrategist,
            incentiveFundManager: params.incentiveFundManager,
            incentiveCalculationContract: params.incentiveCalculationContract,
            incentiveFundContract: incentiveFundContract
        });

        emit SuperAssetCreated(
            superAsset, incentiveFundContract, params.incentiveCalculationContract, params.name, params.symbol
        );
    }
}

0% src/SuperBank.sol

Lines covered: 0 / 27 (0%)

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.30;

// External
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { IAccessControl } from "@openzeppelin/contracts/access/IAccessControl.sol";

import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";

// Superform
import { ISuperBank } from "./interfaces/ISuperBank.sol";
import { ISuperGovernor, FeeType } from "./interfaces/ISuperGovernor.sol";
import { Bank } from "./Bank.sol";

/// @title SuperBank
/// @notice Compounds protocol revenue into UP and distributes it to sUP and treasury.
contract SuperBank is ISuperBank, Bank {
    using SafeERC20 for IERC20;
    using Math for uint256;

    uint256 private constant BPS_MAX = 10_000;
    ISuperGovernor public immutable SUPER_GOVERNOR;

    constructor(address superGovernor_) {
        if (superGovernor_ == address(0)) revert INVALID_ADDRESS();
        SUPER_GOVERNOR = ISuperGovernor(superGovernor_);
    }

    modifier onlyBankManager() {
        if (!IAccessControl(address(SUPER_GOVERNOR)).hasRole(SUPER_GOVERNOR.BANK_MANAGER_ROLE(), msg.sender)) {
            revert INVALID_BANK_MANAGER();
        }
        _;
    }

    /*//////////////////////////////////////////////////////////////
                        EXTERNAL FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    // Receive function to accept direct ETH transfers if needed for hooks/executions
    receive() external payable { }

    /// @inheritdoc ISuperBank
    function distribute(uint256 upAmount) external onlyBankManager {
        if (upAmount == 0) revert ZERO_LENGTH_ARRAY();

        // Get UP token address from SuperGovernor
        address upToken = SUPER_GOVERNOR.getAddress(SUPER_GOVERNOR.UP());
        address supToken = SUPER_GOVERNOR.getAddress(SUPER_GOVERNOR.SUP());
        address treasury = SUPER_GOVERNOR.getAddress(SUPER_GOVERNOR.TREASURY());

        // Get revenue share percentage from SuperGovernor
        uint256 revenueShare = SUPER_GOVERNOR.getFee(FeeType.REVENUE_SHARE);

        // Calculate amounts for sUP and Treasury
        uint256 supAmount = upAmount.mulDiv(revenueShare, BPS_MAX);

        uint256 treasuryAmount = upAmount - supAmount;

        // Get the UP token instance
        IERC20 up = IERC20(upToken);

        // Ensure we have the tokens
        if (up.balanceOf(address(this)) < upAmount) revert INVALID_UP_AMOUNT_TO_DISTRIBUTE();

        // Transfer tokens to sUP and Treasury
        if (supAmount > 0) {
            up.safeTransfer(supToken, supAmount);
        }

        if (treasuryAmount > 0) {
            up.safeTransfer(treasury, treasuryAmount);
        }

        emit RevenueDistributed(upToken, supToken, treasury, supAmount, treasuryAmount);
    }

    /// @inheritdoc ISuperBank
    function executeHooks(ISuperBank.HookExecutionData calldata executionData) external payable onlyBankManager {
        _executeHooks(executionData);
    }

    /*//////////////////////////////////////////////////////////////
                        INTERNAL FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    function _getMerkleRootForHook(address hookAddress) internal view override returns (bytes32) {
        return SUPER_GOVERNOR.getSuperBankHookMerkleRoot(hookAddress);
    }
}

24% src/SuperGovernor.sol

Lines covered: 112 / 457 (24%)

// 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% src/SuperVault/SuperVault.sol

Lines covered: 167 / 192 (86%)

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

56% src/SuperVault/SuperVaultAggregator.sol

Lines covered: 353 / 621 (56%)

// 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% src/SuperVault/SuperVaultEscrow.sol

Lines covered: 12 / 15 (80%)

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

84% src/SuperVault/SuperVaultStrategy.sol

Lines covered: 557 / 661 (84%)

// 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% src/UP/Up.sol

Lines covered: 0 / 22 (0%)

// SPDX-License-Identifier: MIT
pragma solidity 0.8.30;

import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {ERC20Permit} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {Ownable2Step} from "@openzeppelin/contracts/access/Ownable2Step.sol";

/**
 * @title Up
 * @author Superform Foundation
 */
contract Up is ERC20, ERC20Permit, Ownable2Step {
    uint256 public constant INITIAL_SUPPLY = 1_000_000_000 * 10 ** 18;
    uint256 public constant MINT_CAP_BPS = 200; // 2%
    uint256 public constant DAYS_PER_YEAR = 365 days;
    uint256 public constant INITIAL_MINT_LOCK = 3 * 365 days; // 3 years

    uint256 public lastMintTimestamp;
    uint256 public immutable INITIAL_MINT_TIMESTAMP;

    event TokensMinted(address indexed to, uint256 amount);

    error MintingTooEarly();
    error MintAmountTooHigh();
    error InitialLockPeriodNotOver();

    constructor(address initialOwner) ERC20("Superform", "UP") ERC20Permit("Superform") Ownable(initialOwner) {
        _mint(initialOwner, INITIAL_SUPPLY);
        lastMintTimestamp = block.timestamp;
        INITIAL_MINT_TIMESTAMP = block.timestamp;
    }

    /**
     * @dev Allows owner to mint new tokens once per year after 3 years, up to 2% of total supply
     * @param to Address to mint tokens to
     * @param amount Amount of tokens to mint
     */
    function mint(address to, uint256 amount) external onlyOwner {
        // Check if 3 years have passed since initial mint
        if (block.timestamp < INITIAL_MINT_TIMESTAMP + INITIAL_MINT_LOCK) {
            revert InitialLockPeriodNotOver();
        }

        // Check if enough time has passed since last mint
        if (block.timestamp < lastMintTimestamp + DAYS_PER_YEAR) {
            revert MintingTooEarly();
        }

        // Calculate maximum mint amount (2% of total supply)
        uint256 maxMintAmount = (totalSupply() * MINT_CAP_BPS) / 10_000;
        if (amount > maxMintAmount) {
            revert MintAmountTooHigh();
        }

        lastMintTimestamp = block.timestamp;
        _mint(to, amount);
        emit TokensMinted(to, amount);
    }
}

0% src/UP/UpDistributor.sol

Lines covered: 0 / 30 (0%)

// SPDX-License-Identifier: MIT
pragma solidity 0.8.30;

import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import { Ownable2Step } from "@openzeppelin/contracts/access/Ownable2Step.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import { MerkleProof } from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";

/**
 * @title UpDistributor
 * @notice A contract for distributing tokens using a merkle tree for verification
 * @dev The foundation can reclaim unclaimed tokens
 */
contract UpDistributor is Ownable2Step {
    using SafeERC20 for IERC20;

    IERC20 public immutable token;
    bytes32 public merkleRoot;

    /// @notice Track which addresses have claimed their tokens
    mapping(address => bool) public hasClaimed;

    event MerkleRootSet(bytes32 merkleRoot);
    event TokensClaimed(address indexed user, uint256 amount);
    event TokensReclaimed(uint256 amount);

    error ALREADY_CLAIMED();
    error NO_TOKENS_TO_RECLAIM();
    error INVALID_MERKLE_PROOF();
    error INVALID_TOKEN_ADDRESS();

    constructor(address _token, address initialOwner) Ownable(initialOwner) {
        if (_token == address(0)) revert INVALID_TOKEN_ADDRESS();
        token = IERC20(_token);
    }

    /**
     * @notice Set a new merkle root for the distribution
     * @param _merkleRoot The new merkle root
     */
    function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
        merkleRoot = _merkleRoot;
        emit MerkleRootSet(_merkleRoot);
    }

    /**
     * @notice Claim tokens if you are part of the merkle tree
     * @param amount The amount of tokens to claim
     * @param merkleProof A proof of inclusion in the merkle tree
     */
    function claim(uint256 amount, bytes32[] calldata merkleProof) external {
        // Verify user hasn't already claimed
        if (hasClaimed[msg.sender]) revert ALREADY_CLAIMED();

        // Verify the merkle proof
        bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(msg.sender, amount))));
        if (!MerkleProof.verify(merkleProof, merkleRoot, leaf)) revert INVALID_MERKLE_PROOF();

        // Mark as claimed and transfer tokens
        hasClaimed[msg.sender] = true;
        emit TokensClaimed(msg.sender, amount);
        token.safeTransfer(msg.sender, amount);
    }

    /**
     * @notice Claim tokens for a recipient
     * @dev This function can be called by users with smart accounts
     * @param recipient The address to claim tokens for
     * @param amount The amount of tokens to claim
     * @param merkleProof A proof of inclusion in the merkle tree
     */
    function claimOnBehalf(
        address recipient,
        uint256 amount,
        bytes32[] calldata merkleProof
    )
        external
    {
        // Verify user hasn't already claimed
        if (hasClaimed[recipient]) revert ALREADY_CLAIMED();

        // Verify the merkle proof
        bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(recipient, amount))));
        if (!MerkleProof.verify(merkleProof, merkleRoot, leaf)) revert INVALID_MERKLE_PROOF();

        // Mark as claimed and transfer tokens
        hasClaimed[recipient] = true;
        emit TokensClaimed(recipient, amount);
        token.safeTransfer(recipient, amount);
    }

    /**
     * @notice Allow the foundation to reclaim unclaimed tokens
     * @param amount The amount of tokens to reclaim
     */
    function reclaimTokens(uint256 amount) external onlyOwner {
        uint256 balance = token.balanceOf(address(this));
        if (amount > balance) revert NO_TOKENS_TO_RECLAIM();

        emit TokensReclaimed(amount);
        token.safeTransfer(owner(), amount);
    }
}

0% src/VaultBank/VaultBank.sol

Lines covered: 0 / 104 (0%)

// SPDX-License-Identifier: MIT
pragma solidity 0.8.30;

// external
import { BytesLib } from "../vendor/BytesLib.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { ICrossL2ProverV2 } from "../vendor/polymer/ICrossL2ProverV2.sol";
import { IAccessControl } from "@openzeppelin/contracts/access/IAccessControl.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

// Superform
import { VaultBankSuperPosition } from "./VaultBankSuperPosition.sol";
import { IVaultBank, IVaultBankSource } from "../interfaces/VaultBank/IVaultBank.sol";
import { ISuperGovernor } from "../interfaces/ISuperGovernor.sol";
import { VaultBankDestination } from "./VaultBankDestination.sol";
import { VaultBankSource } from "./VaultBankSource.sol";
import { Bank } from "../Bank.sol";

/// @title VaultBank
/// @author Superform Labs
/// @notice Locks assets and mints SuperPositions
contract VaultBank is IVaultBank, VaultBankSource, VaultBankDestination, Bank {
    using SafeERC20 for IERC20;
    using BytesLib for bytes;

    /*//////////////////////////////////////////////////////////////
                                 STORAGE
    //////////////////////////////////////////////////////////////*/
    ISuperGovernor public immutable SUPER_GOVERNOR;

    mapping(uint64 toChainId => uint256 nonce) public nonces;
    mapping(uint64 fromChainId => mapping(uint256 nonce => bool isUsed)) public noncesUsed;

    constructor(address governor_) {
        if (governor_ == address(0)) revert INVALID_VALUE();
        SUPER_GOVERNOR = ISuperGovernor(governor_);
    }

    modifier onlyRelayer() {
        if (!SUPER_GOVERNOR.isRelayer(msg.sender)) revert INVALID_RELAYER();
        _;
    }

    modifier onlyBankManager() {
        if (!IAccessControl(address(SUPER_GOVERNOR)).hasRole(SUPER_GOVERNOR.BANK_MANAGER_ROLE(), msg.sender)) {
            revert INVALID_BANK_MANAGER();
        }
        _;
    }

    /// @dev to receive ETH rewards
    receive() external payable { }

    /*//////////////////////////////////////////////////////////////
                                 EXTERNAL METHODS
    //////////////////////////////////////////////////////////////*/
    // ------------------ SOURCE VAULTBANK METHODS ------------------
    /// @inheritdoc IVaultBank
    function lockAsset(
        bytes32 yieldSourceOracleId,
        address account,
        address token,
        address hookAddress,
        uint256 amount,
        uint64 toChainId
    )
        external
    {
        address vaultBank = SUPER_GOVERNOR.getVaultBank(toChainId);

        if (vaultBank == address(0)) revert INVALID_VAULT_BANK_ADDRESS();
        if (!SUPER_GOVERNOR.isHookRegistered(hookAddress)) revert INVALID_HOOK();

        uint256 _nonce = nonces[toChainId];
        nonces[toChainId]++;
        _lockAssetForChain(yieldSourceOracleId, account, token, amount, toChainId, _nonce);
    }

    /// @inheritdoc IVaultBank
    function unlockAsset(
        address account,
        address token,
        uint256 amount,
        uint64 fromChainId,
        bytes32 yieldSourceOracleId,
        bytes calldata proof
    )
        external
    {
        // validate and mark `proof.nonce[fromChainId]` as used
        _validateUnlockAssetProof(account, yieldSourceOracleId, token, amount, fromChainId, proof);

        //`toChainId` is current chain
        uint256 _nonce = nonces[uint64(_chainId)];
        nonces[uint64(_chainId)]++;
        _releaseAssetFromChain(yieldSourceOracleId, account, token, amount, fromChainId, _nonce);
    }

    /// @inheritdoc IVaultBank
    function executeHooks(IVaultBank.HookExecutionData calldata executionData) external onlyBankManager {
        _executeHooks(executionData);
    }

    /// @inheritdoc IVaultBank
    function batchDistributeRewardsToSuperBank(
        address[] memory rewards,
        uint256[] memory amounts
    )
        external
        onlyRelayer
    {
        uint256 len = rewards.length;
        for (uint256 i; i < len; ++i) {
            _distributeRewardsToSuperBank(rewards[i], amounts[i]);
        }
        emit BatchDistributeRewardsToSuperBank(rewards, amounts);
    }

    // ------------------ DESTINATION VAULTBANK METHODS ------------------
    /// @inheritdoc IVaultBank
    function distributeSuperPosition(
        address account_,
        uint256 amount_,
        SourceAssetInfo calldata sourceAsset_,
        bytes calldata proof_
    )
        external
        override
        onlyRelayer
    {
        // validate and mark `proof.nonce[sourceAsset_.chainId]` as used
        _validateDistributeSPProof(account_, sourceAsset_.yieldSourceOracleId, sourceAsset_.asset, amount_, sourceAsset_.chainId, proof_);

        address spAddress = _retrieveSuperPosition(
            sourceAsset_.yieldSourceOracleId,
            sourceAsset_.chainId,
            sourceAsset_.asset,
            sourceAsset_.name,
            sourceAsset_.symbol,
            sourceAsset_.decimals
        );
        _mintSP(account_, spAddress, amount_);

        nonces[uint64(_chainId)]++;

        emit SuperpositionsMinted(
            account_, spAddress, sourceAsset_.asset, amount_, sourceAsset_.chainId, _extractNonce(proof_)
        );
    }

    /// @inheritdoc IVaultBank
    function burnSuperPosition(
        uint256 amount_,
        address spAddress_,
        uint64 forChainId_,
        bytes32 yieldSourceOracleId_
    )
        external
        override
    {
        _burnSP(msg.sender, spAddress_, amount_);
        uint256 _nonce = nonces[forChainId_];
        nonces[forChainId_]++;
        emit SuperpositionsBurned(
            msg.sender,
            spAddress_,
            _spAssetsInfo[spAddress_].spToToken[forChainId_][yieldSourceOracleId_],
            amount_,
            forChainId_,
            _nonce
        );
    }

    function transferSuperPositionOwnership(address superPos, address newOwner) external onlyBankManager {
        VaultBankSuperPosition(superPos).transferOwnership(newOwner);
    }

    /*//////////////////////////////////////////////////////////////
                          INTERNAL METHODS
    //////////////////////////////////////////////////////////////*/
    function _getMerkleRootForHook(address hookAddress) internal view override returns (bytes32) {
        return SUPER_GOVERNOR.getVaultBankHookMerkleRoot(hookAddress);
    }

    function _distributeRewardsToSuperBank(address token, uint256 amount) internal {
        // get SuperBank address
        address superBank = SUPER_GOVERNOR.getAddress(SUPER_GOVERNOR.SUPER_BANK());

        if (token == address(0)) {
            // distribute ETH
            (bool success,) = superBank.call{ value: amount }("");
            if (!success) revert INVALID_VALUE();
        } else {
            // distribute ERC20
            IERC20(token).safeTransfer(superBank, amount);
        }
    }

    function _validateDistributeSPProof(
        address account,
        bytes32 yieldSourceOracleId,
        address token,
        uint256 amount,
        uint64 fromChainId,
        bytes calldata proof
    )
        internal
    {
        (uint32 chainId, address emittingContract, bytes memory topics, bytes memory unindexedData) =
            ICrossL2ProverV2(SUPER_GOVERNOR.getProver()).validateEvent(proof);

        address vaultBank = SUPER_GOVERNOR.getVaultBank(uint64(fromChainId));

        if (emittingContract != vaultBank) revert INVALID_PROOF_EMITTER();

        _validateSPTopics(account, yieldSourceOracleId, token, topics);
        _validateSPData(amount, fromChainId, chainId, unindexedData);
    }

    function _extractNonce(bytes calldata proof_) internal view returns (uint256) {
        (,,, bytes memory unindexedData) = ICrossL2ProverV2(SUPER_GOVERNOR.getProver()).validateEvent(proof_);

        (,,, uint256 eventNonce) = abi.decode(unindexedData, (uint256, uint64, uint64, uint256));
        return eventNonce;
    }

    function _validateSPTopics(address account, bytes32 yieldSourceOracleId, address token, bytes memory topics) private pure {
         // topics[0] = event signature
        if (topics.toBytes32(0) !=  IVaultBankSource.SharesLocked.selector) revert INVALID_PROOF_EVENT();
        
        // topics[1] = yieldSourceOracleId
        if (topics.toBytes32(32) != yieldSourceOracleId) revert INVALID_PROOF_YIELD_SOURCE_ORACLE_ID();

        // topics[2] = account
        if (topics.toBytes32(64) != bytes32(uint256(uint160(account)))) revert INVALID_PROOF_ACCOUNT();

        // topics[3] = srcTokenAddress 
        if (topics.toBytes32(96) != keccak256(abi.encodePacked(token))) revert INVALID_PROOF_TOKEN();
    }

    function _validateSPData(uint256 amount, uint64 fromChainId, uint32 chainId, bytes memory unindexedData) private {
        (uint256 eventAmount, uint64 eventSrcChainId, uint64 eventDstChainId, uint256 eventNonce) =
            abi.decode(unindexedData, (uint256, uint64, uint64, uint256));

        if (eventAmount != amount) revert INVALID_PROOF_AMOUNT();
        if (eventSrcChainId != fromChainId || uint64(chainId) != fromChainId) revert INVALID_PROOF_SOURCE_CHAIN();
        if (eventDstChainId != _chainId) revert INVALID_PROOF_TARGETED_CHAIN();
        if (noncesUsed[fromChainId][eventNonce]) revert NONCE_ALREADY_USED();
        noncesUsed[fromChainId][eventNonce] = true;
    }

    function _validateUnlockAssetProof(
        address account,
        bytes32 yieldSourceOracleId,
        address token,
        uint256 amount,
        uint64 fromChainId,
        bytes calldata proof
    )
        internal
    {
        (uint32 chainId, address emittingContract, bytes memory topics, bytes memory unindexedData) =
            ICrossL2ProverV2(SUPER_GOVERNOR.getProver()).validateEvent(proof);

        if (uint64(chainId) != fromChainId) revert INVALID_PROOF_CHAIN();

        address vaultBank = SUPER_GOVERNOR.getVaultBank(uint64(fromChainId));

        if (emittingContract != vaultBank) revert INVALID_PROOF_EMITTER();

        _validateUnlockTopics(account, yieldSourceOracleId, token, topics);
        _validateUnlockData(amount, fromChainId, unindexedData);
    }

    function _validateUnlockTopics(address account, bytes32 yieldSourceOracleId, address token, bytes memory topics) private pure {
        // topics[0] = event signature
        if (topics.toBytes32(0) !=  IVaultBank.SuperpositionsBurned.selector) revert INVALID_PROOF_EVENT();
        
        // topics[1] = yieldSourceOracleId
        if (topics.toBytes32(32) != yieldSourceOracleId) revert INVALID_PROOF_YIELD_SOURCE_ORACLE_ID();

        // topics[2] = account
        if (topics.toBytes32(64) != bytes32(uint256(uint160(account)))) revert INVALID_PROOF_ACCOUNT();

        // topics[3] = token 
        if (topics.toBytes32(96) != keccak256(abi.encodePacked(token))) revert INVALID_PROOF_TOKEN();
    }

    function _validateUnlockData(uint256 amount, uint64 fromChainId, bytes memory unindexedData) private {
        (uint256 eventAmount, uint64 eventChainId, uint256 eventNonce) =
            abi.decode(unindexedData, (uint256, uint64, uint256));

        if (eventAmount != amount) revert INVALID_PROOF_AMOUNT();
        if (eventChainId != _chainId) revert INVALID_PROOF_TARGETED_CHAIN();
        if (noncesUsed[fromChainId][eventNonce]) revert NONCE_ALREADY_USED();
        noncesUsed[fromChainId][eventNonce] = true;
    }
}

0% src/VaultBank/VaultBankDestination.sol

Lines covered: 0 / 22 (0%)

// SPDX-License-Identifier: MIT
pragma solidity 0.8.30;

// Superform
import { VaultBankSuperPosition } from "./VaultBankSuperPosition.sol";
import { IVaultBankDestination } from "../interfaces/VaultBank/IVaultBank.sol";

abstract contract VaultBankDestination is IVaultBankDestination {
    /*//////////////////////////////////////////////////////////////
                                 STORAGE
    //////////////////////////////////////////////////////////////*/
    // synthetic assets
    mapping(uint64 srcChainId => mapping(bytes32 yieldSourceOracleId => mapping(address srcTokenAddress => address superPositions))) internal
        _tokenToSuperPosition;
    mapping(address spToken => SpAsset) internal _spAssetsInfo;

    /*//////////////////////////////////////////////////////////////
                                 VIEW METHODS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc IVaultBankDestination
    function getSuperPositionForAsset(uint64 srcChainId, address srcAsset, bytes32 yieldSourceOracleId) external view returns (address) {
        return _tokenToSuperPosition[srcChainId][yieldSourceOracleId][srcAsset];
    }

    /// @inheritdoc IVaultBankDestination
    function getAssetForSuperPosition(uint64 srcChainId, address superPosition, bytes32 yieldSourceOracleId) external view returns (address) {
        return _spAssetsInfo[superPosition].spToToken[srcChainId][yieldSourceOracleId];
    }

    /// @inheritdoc IVaultBankDestination
    function isSuperPositionCreated(address superPosition) external view returns (bool) {
        return _spAssetsInfo[superPosition].wasCreated;
    }

    /*//////////////////////////////////////////////////////////////
                            PRIVATE METHODS
    //////////////////////////////////////////////////////////////*/
    function _retrieveSuperPosition(
        bytes32 yieldSourceOracleId,
        uint64 srcChainId,
        address srcAsset,
        string calldata _srcName,
        string calldata _srcSymbol,
        uint8 _srcDecimals
    )
        internal
        returns (address)
    {
        address _created = _tokenToSuperPosition[srcChainId][yieldSourceOracleId][srcAsset];
        if (_created != address(0)) return _created;

        _created = address(new VaultBankSuperPosition(_srcName, _srcSymbol, _srcDecimals, yieldSourceOracleId));
        _tokenToSuperPosition[srcChainId][yieldSourceOracleId][srcAsset] = _created;
        _spAssetsInfo[_created].spToToken[srcChainId][yieldSourceOracleId] = srcAsset;
        _spAssetsInfo[_created].wasCreated = true;
        return _created;
    }

    function _mintSP(address account, address superPosition, uint256 amount) internal {
        // at this point the asset should exist
        if (!_spAssetsInfo[superPosition].wasCreated) revert SUPERPOSITION_ASSET_NOT_FOUND();

        // mint the synthetic asset
        VaultBankSuperPosition(superPosition).mint(account, amount);
    }

    function _burnSP(address account, address superPosition, uint256 amount) internal {
        // at this point the asset should exist
        if (!_spAssetsInfo[superPosition].wasCreated) revert SUPERPOSITION_ASSET_NOT_FOUND();

        if (amount > VaultBankSuperPosition(superPosition).balanceOf(account)) revert INVALID_BURN_AMOUNT();

        // burn the synthetic asset
        VaultBankSuperPosition(superPosition).burn(account, amount);
    }
}

0% src/VaultBank/VaultBankSource.sol

Lines covered: 0 / 30 (0%)

// SPDX-License-Identifier: MIT
pragma solidity 0.8.30;

// external
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import { ExcessivelySafeCall } from "excessivelySafeCall/ExcessivelySafeCall.sol";
import { EnumerableSet } from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";

// Superform
import { IVaultBankSource } from "../interfaces/VaultBank/IVaultBank.sol";

abstract contract VaultBankSource is IVaultBankSource {
    using SafeERC20 for IERC20;
    using ExcessivelySafeCall for address;
    using EnumerableSet for EnumerableSet.AddressSet;

    /*//////////////////////////////////////////////////////////////
                                 STORAGE
    //////////////////////////////////////////////////////////////*/
    // locked assets
    EnumerableSet.AddressSet internal _lockedAssets;
    mapping(address token => uint256 amount) internal _lockedAmounts;

    uint64 internal immutable _chainId;

    constructor() {
        _chainId = uint64(block.chainid);
    }

    /*//////////////////////////////////////////////////////////////
                                 VIEW METHODS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc IVaultBankSource
    function viewTotalLockedAsset(address token) external view returns (uint256) {
        return _lockedAmounts[token];
    }

    /// @inheritdoc IVaultBankSource
    function viewAllLockedAssets() external view returns (address[] memory) {
        return _lockedAssets.values();
    }

    /*//////////////////////////////////////////////////////////////
                                 INTERNAL METHODS
    //////////////////////////////////////////////////////////////*/
    // ------------------ SYNTHETIC ASSETS ------------------
    function _lockAssetForChain(
        bytes32 yieldSourceOracleId,
        address account,
        address token,
        uint256 amount,
        uint64 toChainId,
        uint256 nonce
    )
        internal
    {
        if (amount == 0) revert INVALID_AMOUNT();
        if (token == address(0)) revert INVALID_TOKEN();
        if (account == address(0)) revert INVALID_ACCOUNT();
        if (yieldSourceOracleId == bytes32(0)) revert INVALID_YIELD_SOURCE_ORACLE_ID();

        if (!_lockedAssets.contains(token)) {
            _lockedAssets.add(token);
        }
        _lockedAmounts[token] += amount;

        IERC20(token).safeTransferFrom(account, address(this), amount);
        emit SharesLocked(yieldSourceOracleId, account, token, amount, _chainId, toChainId, nonce);
    }

    function _releaseAssetFromChain(
        bytes32 yieldSourceOracleId,
        address account,
        address token,
        uint256 amount,
        uint64 fromChainId,
        uint256 nonce
    )
        internal
    {
        if (account == address(0)) revert INVALID_ACCOUNT();
        if (token == address(0)) revert INVALID_TOKEN();
        if (amount == 0 || amount > _lockedAmounts[token]) revert INVALID_AMOUNT();
        if (yieldSourceOracleId == bytes32(0)) revert INVALID_YIELD_SOURCE_ORACLE_ID();

        _lockedAmounts[token] -= amount;
        if (_lockedAmounts[token] == 0) {
            _lockedAssets.remove(token);
        }

        IERC20(token).safeTransfer(account, amount);
        emit SharesUnlocked(yieldSourceOracleId, account, token, amount, _chainId, fromChainId, nonce);
    }
    // ------------------ MANAGE REWARDS ------------------

    function _claimRewards(
        address target,
        uint256 gasLimit,
        uint256 value,
        uint16 maxReturnDataCopy,
        bytes calldata data
    )
        internal
        returns (bytes memory)
    {
        if (target == address(0) || target == address(this)) revert INVALID_CLAIM_TARGET();
        (bool success, bytes memory result) = target.excessivelySafeCall(gasLimit, value, maxReturnDataCopy, data);
        if (!success) revert CLAIM_FAILED();
        return result;
    }
}

0% src/VaultBank/VaultBankSuperPosition.sol

Lines covered: 0 / 14 (0%)

// SPDX-License-Identifier: MIT
pragma solidity 0.8.30;

import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import { Ownable2Step } from "@openzeppelin/contracts/access/Ownable2Step.sol";
import { ISuperPositions } from "../interfaces/VaultBank/ISuperPositions.sol";

contract VaultBankSuperPosition is ERC20, Ownable2Step, ISuperPositions {
    /*//////////////////////////////////////////////////////////////
                                 STORAGE
    //////////////////////////////////////////////////////////////*/
    bytes32 public yieldSourceOracleId;
    uint8 private _decimals;

    /// @dev `msg.sender` is VaultBank
    constructor(
        string memory name,
        string memory symbol,
        uint8 decimals_,
        bytes32 yieldSourceOracleId_
    ) ERC20(name, symbol) Ownable(msg.sender) {
        if (decimals_ == 0) revert INVALID_DECIMALS();
        if (yieldSourceOracleId_ == bytes32(0)) revert INVALID_YIELD_SOURCE_ORACLE_ID();
        _decimals = decimals_;
        yieldSourceOracleId = yieldSourceOracleId_;
    }

    /*//////////////////////////////////////////////////////////////
                              VIEW METHODS
    //////////////////////////////////////////////////////////////*/
    /// @notice Get the number of decimals for the token
    function decimals() public view override returns (uint8) {
        return _decimals;
    }
    /*//////////////////////////////////////////////////////////////
                            EXTERNAL METHODS
    //////////////////////////////////////////////////////////////*/
    /// @notice Mint tokens to the specified address
    /// @param to_ The address to mint tokens to
    /// @param amount_ The amount of tokens to mint
    function mint(address to_, uint256 amount_) external onlyOwner {
        _mint(to_, amount_);
    }

    /// @notice Burn tokens from the specified address
    /// @param from_ The address to burn tokens from
    /// @param amount_ The amount of tokens to burn
    function burn(address from_, uint256 amount_) external onlyOwner {
        _burn(from_, amount_);
    }
}

90% src/libraries/AssetMetadataLib.sol

Lines covered: 9 / 10 (90%)

// 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% src/libraries/SuperAssetPriceLib.sol

Lines covered: 0 / 76 (0%)

// SPDX-License-Identifier: MIT
pragma solidity 0.8.30;

import { ISuperOracle } from "../interfaces/oracles/ISuperOracle.sol";
import { ISuperAsset } from "../interfaces/SuperAsset/ISuperAsset.sol";
import { IYieldSourceOracle } from "@superform-v2-core/src/interfaces/accounting/IYieldSourceOracle.sol";

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

library SuperAssetPriceLib {
    using Math for uint256;

    /// @dev Gets the price of a token with circuit breakers
    /// @param args The arguments for the price calculation
    /// @return priceUSD The price of the token in USD
    /// @return isDepeg Whether the token is depegged
    /// @return isDispersion Whether the token has price dispersion
    /// @return isOracleOff Whether the oracle is off
    function getPriceWithCircuitBreakers(ISuperAsset.PriceArgs memory args)
        external
        view
        returns (uint256 priceUSD, bool isDepeg, bool isDispersion, bool isOracleOff)
    {
        // Get token decimals
        uint256 stddev;
        uint256 M;

        // @dev Passing oneUnit to get the price of a single unit of asset to check if it has depegged
        ISuperOracle superOracle = ISuperOracle(args.superOracle);
        ISuperAsset superAsset = ISuperAsset(args.superAsset);

        uint256 precision = superAsset.getPrecision();

        (priceUSD, stddev, M) = _getPriceInfo(superOracle, superAsset, args.usd, args.token);

        // Circuit Breaker for Oracle Off
        if (M == 0) {
            isOracleOff = true;
        } else {
            address primaryAsset = superAsset.getPrimaryAsset();
            if (primaryAsset == args.usd) {
                return (precision, false, false, false);
            }

            // Circuit Breaker for Depeg - price deviates more than ±2% from expected
            (isDepeg, isDispersion) = _getDepegAndDispersion(args, precision, priceUSD, stddev);
        }
        return (priceUSD, isDepeg, isDispersion, isOracleOff);
    }

    /// @dev Derives the price of the token from the underlying vault
    /// @param token The address of the token to derive the price of
    /// @return priceUSD The price of the token in USD
    /// @return stddev The standard deviation of the token
    /// @return M The number of quote providers
    function _derivePriceFromUnderlyingVault(
        ISuperOracle superOracle,
        ISuperAsset superAsset,
        address USD,
        address token,
        address oracle
    )
        internal
        view
        returns (uint256 priceUSD, uint256 stddev, uint256 M)
    {
        address vaultAsset = IERC4626(token).asset();
        uint256 unitVaultAsset = 10 ** IERC20Metadata(vaultAsset).decimals();

        bytes32 AVERAGE_PROVIDER = keccak256("AVERAGE_PROVIDER");

        try superOracle.getQuoteFromProvider(unitVaultAsset, vaultAsset, USD, AVERAGE_PROVIDER) returns (
            uint256 _priceUSD, uint256 _stddev, uint256, uint256 _m
        ) {
            priceUSD = _priceUSD;
            stddev = _stddev;
            M = _m;
        } catch {
            priceUSD = superOracle.getEmergencyPrice(vaultAsset);
            stddev = 0;
            M = 0;
        }

        uint256 pricePerShare = IYieldSourceOracle(oracle).getPricePerShare(token);
        if (priceUSD > 0) {
            priceUSD = pricePerShare.mulDiv(priceUSD, superAsset.getPrecision(), Math.Rounding.Floor);
        }
    }

    /// @dev Checks if the standard deviation is greater than the dispersion threshold
    /// @param stddev The standard deviation
    /// @param priceUSD The price in USD
    /// @return isDispersion True if the standard deviation is greater than the dispersion threshold
    function _isSTDDevDegged(
        address superAsset,
        uint256 stddev,
        uint256 priceUSD,
        uint256 dispersionThreshold
    )
        internal
        pure
        returns (bool)
    {
        // Calculate relative standard deviation
        uint256 relativeStdDev = Math.mulDiv(stddev, ISuperAsset(superAsset).getPrecision(), priceUSD);

        // Circuit Breaker for Dispersion
        if (relativeStdDev > dispersionThreshold) {
            return true;
        }
        return false;
    }

    /// @dev Checks if the token is depegged
    /// @param priceUSD The price of the token in USD
    /// @param assetPriceUSD The price of the asset in USD
    /// @return isDepeg True if the token is depegged
    function _isTokenDepeg(
        uint256 priceUSD,
        uint256 precision,
        uint256 assetPriceUSD,
        uint256 depegLowerThreshold,
        uint256 depegUpperThreshold
    )
        internal
        pure
        returns (bool isDepeg)
    {
        // NOTE: There should be no need to adjust for decimals since
        // the token specific decimals and
        // the Oracle Price decimals
        // can be different
        // Example, if we send 2 USDC to someone then the transferred amount is 2e6 since USDC has 6d
        // but the USDC price quoted in USD can have its own decimals, for example
        // if USDC depegs high and is worth 3 USD then its price quoted in a 18d oracle will be 3e18
        uint256 ratio = Math.mulDiv(priceUSD, precision, assetPriceUSD);

        if (ratio < depegLowerThreshold || ratio > depegUpperThreshold) {
            isDepeg = true;
        }
    }

    /// @dev Gets the price information for a token
    /// @param superOracle The super oracle
    /// @param superAsset The super asset
    /// @param USD The USD address
    /// @param token The token address
    /// @return priceUSD The price of the token in USD
    /// @return stddev The standard deviation of the token
    function _getPriceInfo(
        ISuperOracle superOracle,
        ISuperAsset superAsset,
        address USD,
        address token
    )
        internal
        view
        returns (uint256 priceUSD, uint256 stddev, uint256 M)
    {
        bytes32 AVERAGE_PROVIDER = keccak256("AVERAGE_PROVIDER");
        uint256 one = 10 ** IERC20Metadata(token).decimals();

        ISuperAsset.TokenData memory tokenData = superAsset.getTokenData(token);

        if (tokenData.isSupportedERC20) {
            try superOracle.getQuoteFromProvider(one, token, USD, AVERAGE_PROVIDER) returns (
                uint256 _priceUSD, uint256 _stddev, uint256, uint256 _m
            ) {
                priceUSD = _priceUSD;
                stddev = _stddev;
                M = _m;
            } catch {
                priceUSD = superOracle.getEmergencyPrice(token);
                M = 0;
            }
        } else if (tokenData.isSupportedUnderlyingVault) {
            (priceUSD, stddev, M) =
                _derivePriceFromUnderlyingVault(superOracle, superAsset, USD, token, tokenData.oracle);
        }
    }

    /// @dev Gets the depeg and dispersion status of a token
    /// @param args The arguments for the price calculation
    /// @param precision The precision of the token
    /// @param priceUSD The price of the token in USD
    /// @param stddev The standard deviation of the token
    /// @return isDepeg True if the token is depegged
    /// @return isDispersion True if the token has price dispersion
    function _getDepegAndDispersion(
        ISuperAsset.PriceArgs memory args,
        uint256 precision,
        uint256 priceUSD,
        uint256 stddev
    )
        internal
        view
        returns (bool isDepeg, bool isDispersion)
    {
        uint256 assetPriceUSD = _getAssetPriceUSD(args.superOracle, args.superAsset, args.usd);

        isDepeg = _isTokenDepeg(priceUSD, precision, assetPriceUSD, args.depegLowerThreshold, args.depegUpperThreshold);

        isDispersion = _isSTDDevDegged(args.superAsset, stddev, priceUSD, args.dispersionThreshold);
    }

    /// @dev Gets the price of the asset in USD
    /// @param superOracleAddress The address of the super oracle
    /// @param superAssetAddress The address of the super asset
    /// @param USD The address of the USD token
    /// @return assetPriceUSD The price of the asset in USD
    function _getAssetPriceUSD(
        address superOracleAddress,
        address superAssetAddress,
        address USD
    )
        internal
        view
        returns (uint256 assetPriceUSD)
    {
        bytes32 AVERAGE_PROVIDER = keccak256("AVERAGE_PROVIDER");
        address primaryAsset = ISuperAsset(superAssetAddress).getPrimaryAsset();
        uint256 oneUnitAsset = 10 ** IERC20Metadata(primaryAsset).decimals();

        ISuperOracle superOracle = ISuperOracle(superOracleAddress);

        try superOracle.getQuoteFromProvider(oneUnitAsset, primaryAsset, USD, AVERAGE_PROVIDER) returns (
            uint256 _priceUSD, uint256, uint256, uint256
        ) {
            assetPriceUSD = _priceUSD;
        } catch {
            assetPriceUSD = superOracle.getEmergencyPrice(primaryAsset);
        }
    }
}

0% src/oracles/ECDSAPPSOracle.sol

Lines covered: 0 / 127 (0%)

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.30;

// External
import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import { MessageHashUtils } from "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";
import { EIP712 } from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";

// Superform
import { ISuperGovernor } from "../interfaces/ISuperGovernor.sol";
import { ISuperVaultAggregator } from "../interfaces/SuperVault/ISuperVaultAggregator.sol";
import { IECDSAPPSOracle } from "../interfaces/oracles/IECDSAPPSOracle.sol";

/// @title ECDSAPPSOracle
/// @author Superform Labs
/// @notice PPS Oracle that validates price updates using ECDSA signatures
/// @dev Implements the IECDSAPPSOracle interface for validating and forwarding PPS updates
contract ECDSAPPSOracle is IECDSAPPSOracle, EIP712 {
    using ECDSA for bytes32;
    using MessageHashUtils for bytes32;

    /*//////////////////////////////////////////////////////////////
                                 STORAGE
    //////////////////////////////////////////////////////////////*/
    mapping(address _strategy => uint256 _nonce) public noncePerStrategy;

    /// @notice The SuperGovernor contract for validator verification
    ISuperGovernor public immutable SUPER_GOVERNOR;
    bytes32 public constant UPDATE_PPS_TYPEHASH = keccak256(
        "UpdatePPS(address strategy,uint256 pps,uint256 ppsStdev,uint256 validatorSet,uint256 totalValidators,uint256 timestamp, uint256 strategyNonce)"
    );

    bytes32 private constant SUPER_VAULT_AGGREGATOR = keccak256("SUPER_VAULT_AGGREGATOR");

    /*//////////////////////////////////////////////////////////////
                              CONSTRUCTOR
    //////////////////////////////////////////////////////////////*/
    /// @notice Initializes the ECDSAPPSOracle contract
    /// @param superGovernor_ Address of the SuperGovernor contract
    constructor(address superGovernor_, string memory name_, string memory version_) EIP712(name_, version_) {
        if (superGovernor_ == address(0)) revert INVALID_VALIDATOR();

        SUPER_GOVERNOR = ISuperGovernor(superGovernor_);
    }

    /*//////////////////////////////////////////////////////////////
                              VIEW FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc IECDSAPPSOracle
    function domainSeparator() external view returns (bytes32) {
        return _domainSeparatorV4();
    }

    /*//////////////////////////////////////////////////////////////
                         PPS UPDATE FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc IECDSAPPSOracle
    function updatePPS(UpdatePPSArgs calldata args) external {
        uint256 strategiesLength = args.strategies.length;
        
        if (strategiesLength == 0) revert ZERO_LENGTH_ARRAY();
        // Validate input array lengths
        if (    strategiesLength != args.proofsArray.length
                || strategiesLength != args.ppss.length
                || strategiesLength != args.ppsStdevs.length || strategiesLength != args.validatorSets.length
                || strategiesLength != args.timestamps.length || strategiesLength != args.totalValidators.length
        ) revert ARRAY_LENGTH_MISMATCH();


        // Process strategies and collect valid entries
        (
            address[] memory validStrategies,
            uint256[] memory validPpss,
            uint256[] memory validPpsStdevs,
            uint256[] memory validValidatorSets,
            uint256[] memory validTotalValidators,
            uint256[] memory validTimestamps
        ) = _processBatchStrategies(args, strategiesLength);

        // Forward valid entries if any exist
        _forwardValidEntries(
            validStrategies,
            validPpss,
            validPpsStdevs,
            validValidatorSets,
            validTotalValidators,
            validTimestamps
        );
    }

    

    /// @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)
        public
        view
    {
        _validateProofs(params);
    }

    /*//////////////////////////////////////////////////////////////
                            INTERNAL FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    /// @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) internal view {
        // Check if this oracle is the active PPS Oracle
        if (!SUPER_GOVERNOR.isActivePPSOracle(address(this))) revert NOT_ACTIVE_PPS_ORACLE();

        // Create message hash with all parameters- If anyare incorrect, the message hash will be different and the
        // derived signer address will be incorrect- resulting in a revert
        bytes32 structHash = keccak256(
            abi.encodePacked(
                UPDATE_PPS_TYPEHASH,
                params.strategy,
                params.pps,
                params.ppsStdev,
                params.validatorSet,
                params.totalValidators,
                params.timestamp,
                noncePerStrategy[params.strategy]
            )
        );
        bytes32 digest = _hashTypedDataV4(structHash);
        
        uint256 proofsLength = params.proofs.length;
        if (proofsLength == 0) revert ZERO_LENGTH_ARRAY();

        address lastSigner;
        // Process each proof
        for (uint256 i; i < proofsLength; i++) {
            // Recover the signer from the proof
            address signer = ECDSA.recover(digest, params.proofs[i]);

            // Verify the signer is a registered validator
            if (!SUPER_GOVERNOR.isValidator(signer)) revert INVALID_VALIDATOR();

            // Check for duplicates or improper ordering - signers must be in ascending order
            if (signer <= lastSigner) revert INVALID_PROOF();
            lastSigner = signer;
        }

        // Validate that validatorSet matches actual number of valid signatures
        if (params.validatorSet != proofsLength) revert INVALID_VALIDATOR_SET();

        // Validate that totalValidators matches actual total number of validators
        if (params.totalValidators != SUPER_GOVERNOR.getValidators().length) revert INVALID_TOTAL_VALIDATORS();

        // Ensure we have enough valid signatures to meet quorum
        if (proofsLength < SUPER_GOVERNOR.getPPSOracleQuorum()) revert QUORUM_NOT_MET();
    }

    /// @notice Processes batch strategies and returns valid entries
    /// @param args Batch update arguments
    /// @param strategiesLength Length of strategies array
    /// @return validStrategies Array of valid strategy addresses
    /// @return validPpss Array of valid PPS values
    /// @return validPpsStdevs Array of valid PPS standard deviations
    /// @return validValidatorSets Array of valid validator sets
    /// @return validTotalValidators Array of valid total validators
    /// @return validTimestamps Array of valid timestamps
    function _processBatchStrategies(
        UpdatePPSArgs calldata args,
        uint256 strategiesLength
    )
        internal
        returns (
            address[] memory validStrategies,
            uint256[] memory validPpss,
            uint256[] memory validPpsStdevs,
            uint256[] memory validValidatorSets,
            uint256[] memory validTotalValidators,
            uint256[] memory validTimestamps
        )
    {
        // Arrays to collect valid entries
        validStrategies = new address[](strategiesLength);
        validPpss = new uint256[](strategiesLength);
        validPpsStdevs = new uint256[](strategiesLength);
        validValidatorSets = new uint256[](strategiesLength);
        validTotalValidators = new uint256[](strategiesLength);
        validTimestamps = new uint256[](strategiesLength);
        uint256 validCount;

        // Process each strategy update
        for (uint256 i; i < strategiesLength; i++) {
            bool isValid = _processIndividualStrategy(args, i);
            if (isValid) {
                // Add to valid entries
                validStrategies[validCount] = args.strategies[i];
                validPpss[validCount] = args.ppss[i];
                validPpsStdevs[validCount] = args.ppsStdevs[i];
                validValidatorSets[validCount] = args.validatorSets[i];
                validTotalValidators[validCount] = args.totalValidators[i];
                validTimestamps[validCount] = args.timestamps[i];
                validCount++;
            }
        }

        // Resize arrays to actual valid count
        assembly {
            mstore(validStrategies, validCount)
            mstore(validPpss, validCount)
            mstore(validPpsStdevs, validCount)
            mstore(validValidatorSets, validCount)
            mstore(validTotalValidators, validCount)
            mstore(validTimestamps, validCount)
        }
    }

    /// @notice Processes an individual strategy in the batch
    /// @param args Batch update arguments
    /// @param index Index of the strategy to process
    /// @return isValid True if the strategy was processed successfully
    function _processIndividualStrategy(
        UpdatePPSArgs calldata args,
        uint256 index
    ) internal returns (bool isValid) {
        address _strategy = args.strategies[index];

         // Validate proofs and check quorum requirement
        try IECDSAPPSOracle(address(this)).validateProofs(
            IECDSAPPSOracle.ValidationParams({
                strategy: _strategy,
                proofs: args.proofsArray[index],
                pps: args.ppss[index],
                ppsStdev: args.ppsStdevs[index],
                validatorSet: args.validatorSets[index],
                totalValidators: args.totalValidators[index],
                timestamp: args.timestamps[index]
            })
        ) {
            emit PPSValidated(
                _strategy,
                args.ppss[index],
                args.ppsStdevs[index],
                args.validatorSets[index],
                args.totalValidators[index],
                args.timestamps[index],
                msg.sender
            );
        } catch Error(string memory reason) {
            emit ProofValidationFailed(_strategy, reason);
            return false;
        } catch (bytes memory lowLevelData) {
            emit ProofValidationFailedLowLevel(_strategy, lowLevelData);
            return false;
        }
        
        noncePerStrategy[_strategy]++;
        return true;
    }

    /// @notice Forwards valid entries to SuperVaultAggregator
    /// @param validStrategies Array of valid strategy addresses
    /// @param validPpss Array of valid PPS values
    /// @param validPpsStdevs Array of valid PPS standard deviations
    /// @param validValidatorSets Array of valid validator sets
    /// @param validTotalValidators Array of valid total validators
    /// @param validTimestamps Array of valid timestamps
    function _forwardValidEntries(
        address[] memory validStrategies,
        uint256[] memory validPpss,
        uint256[] memory validPpsStdevs,
        uint256[] memory validValidatorSets,
        uint256[] memory validTotalValidators,
        uint256[] memory validTimestamps
    ) internal {
        // Only forward if there are valid entries
        if (validStrategies.length > 0) {
            try ISuperVaultAggregator(SUPER_GOVERNOR.getAddress(SUPER_VAULT_AGGREGATOR)).forwardPPS(
                ISuperVaultAggregator.ForwardPPSArgs({
                    strategies: validStrategies,
                    ppss: validPpss,
                    ppsStdevs: validPpsStdevs,
                    validatorSets: validValidatorSets,
                    totalValidators: validTotalValidators,
                    timestamps: validTimestamps,
                    updateAuthority: msg.sender
                })
            ) {
            } catch Error(string memory reason) {
                emit BatchForwardPPSFailed(reason);
            } catch (bytes memory lowLevelData) {
                emit BatchForwardPPSFailedLowLevel(lowLevelData);
            }
        }
    }

}

0% src/oracles/SuperOracle.sol

Lines covered: 0 / 3 (0%)

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.30;

// Superform
import { SuperOracleBase } from "./SuperOracleBase.sol";

/// @title SuperOracle
/// @author Superform Labs
/// @notice Oracle for Superform
contract SuperOracle is SuperOracleBase {
    constructor(
        address superGovernor_,
        address[] memory bases,
        address[] memory quotes,
        bytes32[] memory providers,
        address[] memory feeds
    )
        SuperOracleBase(superGovernor_, bases, quotes, providers, feeds)
    { }
}

0% src/oracles/SuperOracleBase.sol

Lines covered: 0 / 210 (0%)

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.30;

// external
import { IOracle } from "../vendor/awesome-oracles/IOracle.sol";
import { AggregatorV3Interface } from "../vendor/chainlink/AggregatorV3Interface.sol";
import { IERC20 } from "forge-std/interfaces/IERC20.sol";
import { BoringERC20 } from "../vendor/BoringSolidity/BoringERC20.sol";
import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";

// Superform
import { ISuperOracle } from "../interfaces/oracles/ISuperOracle.sol";

/// @title SuperOracle
/// @author Superform Labs
/// @notice Oracle for Superform
abstract contract SuperOracleBase is ISuperOracle, IOracle {
    using BoringERC20 for IERC20;

    /// @notice Mapping of feed to max staleness period
    mapping(address feed => uint256 maxStaleness) public feedMaxStaleness;

    /// @notice Mapping of token to emergency price when oracle is down
    mapping(address token => uint256 emergencyPrice) public emergencyPrices;

    uint256 public maxDefaultStaleness;

    /// @notice Pending oracle update
    PendingUpdate public pendingUpdate;

    /// @notice Pending provider removal
    PendingRemoval public pendingRemoval;

    /// @notice Mapping of base asset to array of oracle providers to oracle feed address
    mapping(address base => mapping(address quote => mapping(bytes32 provider => address feed))) internal oracles;

    /// @notice Array of active provider ids
    bytes32[] public activeProviders;
    mapping(bytes32 provider => bool isSet) public isProviderSet;

    /// @notice Timelock period for oracle updates
    uint256 internal constant TIMELOCK_PERIOD = 1 weeks;
    uint256 internal constant MAX_SAMPLE_PROVIDERS = 10;
    bytes32 internal constant AVERAGE_PROVIDER = keccak256("AVERAGE_PROVIDER");

    // SuperGovernor address
    address public immutable SUPER_GOVERNOR;

    constructor(
        address superGovernor_,
        address[] memory bases,
        address[] memory quotes,
        bytes32[] memory providers,
        address[] memory feeds
    ) {
        if (superGovernor_ == address(0)) revert ZERO_ADDRESS();
        SUPER_GOVERNOR = superGovernor_;
        maxDefaultStaleness = 1 days;

        // validate oracle inputs
        _validateOracleInputs(bases, quotes, providers, feeds);

        // configure oracles
        _configureOracles(bases, quotes, providers, feeds);

        // set default staleness for feeds
        uint256 length = feeds.length;
        for (uint256 i; i < length; ++i) {
            feedMaxStaleness[feeds[i]] = maxDefaultStaleness;
        }
    }

    /*//////////////////////////////////////////////////////////////
                            EXTERNAL FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperOracle
    function setMaxStaleness(uint256 newMaxStaleness) external {
        if (msg.sender != SUPER_GOVERNOR) revert UNAUTHORIZED_UPDATE_AUTHORITY();
        maxDefaultStaleness = newMaxStaleness;
        emit MaxStalenessUpdated(newMaxStaleness);
    }

    /// @inheritdoc ISuperOracle
    function setFeedMaxStaleness(address feed, uint256 newMaxStaleness) external {
        if (msg.sender != SUPER_GOVERNOR) revert UNAUTHORIZED_UPDATE_AUTHORITY();
        _setFeedMaxStaleness(feed, newMaxStaleness);
    }

    /// @inheritdoc ISuperOracle
    function setEmergencyPrice(address token_, uint256 price_) external {
        if (msg.sender != SUPER_GOVERNOR) revert UNAUTHORIZED_UPDATE_AUTHORITY();
        _setEmergencyPrice(token_, price_);
    }

    /// @inheritdoc ISuperOracle
    function batchSetEmergencyPrice(address[] calldata tokens_, uint256[] calldata prices_) external {
        if (msg.sender != SUPER_GOVERNOR) revert UNAUTHORIZED_UPDATE_AUTHORITY();
        uint256 length = tokens_.length;
        if (length == 0) revert ZERO_ARRAY_LENGTH();
        if (length != prices_.length) revert ARRAY_LENGTH_MISMATCH();

        for (uint256 i; i < length; ++i) {
            _setEmergencyPrice(tokens_[i], prices_[i]);
        }
    }

    /// @inheritdoc ISuperOracle
    function setFeedMaxStalenessBatch(address[] calldata feeds, uint256[] calldata newMaxStalenessList) external {
        if (msg.sender != SUPER_GOVERNOR) revert UNAUTHORIZED_UPDATE_AUTHORITY();
        uint256 length = feeds.length;
        if (length == 0) revert ZERO_ARRAY_LENGTH();
        if (length != newMaxStalenessList.length) {
            revert ARRAY_LENGTH_MISMATCH();
        }

        for (uint256 i; i < length; ++i) {
            _setFeedMaxStaleness(feeds[i], newMaxStalenessList[i]);
        }
    }

    /// @inheritdoc ISuperOracle
    function queueOracleUpdate(
        address[] calldata bases,
        address[] calldata quotes,
        bytes32[] calldata providers,
        address[] calldata feeds
    )
        external
    {
        if (msg.sender != SUPER_GOVERNOR) revert UNAUTHORIZED_UPDATE_AUTHORITY();
        uint256 length = bases.length;
        if (length != quotes.length || length != providers.length || length != feeds.length) {
            revert ARRAY_LENGTH_MISMATCH();
        }

        _validateOracleInputs(bases, quotes, providers, feeds);

        pendingUpdate = PendingUpdate({
            bases: bases,
            quotes: quotes,
            providers: providers,
            feeds: feeds,
            timestamp: block.timestamp
        });

        emit OracleUpdateQueued(bases, quotes, providers, feeds, block.timestamp);
    }

    /// @inheritdoc ISuperOracle
    function executeOracleUpdate() external {
        if (pendingUpdate.timestamp == 0) revert NO_PENDING_UPDATE();
        if (block.timestamp < pendingUpdate.timestamp + TIMELOCK_PERIOD) revert TIMELOCK_NOT_ELAPSED();

        _configureOracles(pendingUpdate.bases, pendingUpdate.quotes, pendingUpdate.providers, pendingUpdate.feeds);

        emit OracleUpdateExecuted(
            pendingUpdate.bases, pendingUpdate.quotes, pendingUpdate.providers, pendingUpdate.feeds
        );

        delete pendingUpdate;
    }

    /// @inheritdoc ISuperOracle
    function getOracleAddress(address base, address quote, bytes32 provider) external view returns (address oracle) {
        oracle = oracles[base][quote][provider];
        if (oracle == address(0)) revert NO_ORACLES_CONFIGURED();
        if (!isProviderSet[provider]) return address(0);
    }

    /// @inheritdoc ISuperOracle
    function queueProviderRemoval(bytes32[] calldata providers) external {
        if (msg.sender != SUPER_GOVERNOR) revert UNAUTHORIZED_UPDATE_AUTHORITY();
        if (pendingRemoval.timestamp != 0) revert PENDING_UPDATE_EXISTS();

        uint256 length = providers.length;
        if (length == 0) revert ZERO_ARRAY_LENGTH();

        pendingRemoval = PendingRemoval({ providers: providers, timestamp: block.timestamp });

        emit ProviderRemovalQueued(providers, block.timestamp);
    }

    /// @inheritdoc ISuperOracle
    function executeProviderRemoval() external {
        if (pendingRemoval.timestamp == 0) revert NO_PENDING_UPDATE();
        if (block.timestamp < pendingRemoval.timestamp + TIMELOCK_PERIOD) revert TIMELOCK_NOT_ELAPSED();

        bytes32[] memory providersToRemove = pendingRemoval.providers;

        // Loop through each provider to remove
        for (uint256 i; i < providersToRemove.length; i++) {
            bytes32 providerToRemove = providersToRemove[i];
            isProviderSet[providerToRemove] = false;

            // Find the provider in activeProviders array
            for (uint256 j; j < activeProviders.length; j++) {
                if (activeProviders[j] == providerToRemove) {
                    // Replace the provider to remove with the last provider in the array
                    if (j < activeProviders.length - 1) {
                        activeProviders[j] = activeProviders[activeProviders.length - 1];
                    }

                    // Remove the last element
                    activeProviders.pop();
                    break;
                }
            }
        }

        emit ProviderRemovalExecuted(providersToRemove);

        delete pendingRemoval;
    }

    /// @inheritdoc ISuperOracle
    function getActiveProviders() external view returns (bytes32[] memory) {
        return activeProviders;
    }

    /*//////////////////////////////////////////////////////////////
                        EXTERNAL VIEW FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperOracle
    function getQuoteFromProvider(
        uint256 baseAmount,
        address base,
        address quote,
        bytes32 oracleProvider
    )
        public
        view
        virtual
        returns (uint256 quoteAmount, uint256 deviation, uint256 totalProviders, uint256 availableProviders)
    {
        // If average, calculate average of all oracles
        if (oracleProvider == AVERAGE_PROVIDER) {
            uint256 length = activeProviders.length;
            uint256[] memory validQuotes = new uint256[](length);
            uint256 count;
            (quoteAmount, validQuotes, totalProviders, count) = _getAverageQuote(base, quote, baseAmount, length);
            availableProviders = count;
            deviation = _calculateStdDev(validQuotes, count);
        } else {
            quoteAmount = _getQuoteFromOracle(oracles[base][quote][oracleProvider], baseAmount, base, quote, true);
            deviation = 0;
            totalProviders = 1;
            availableProviders = 1;
        }
    }

    /// @inheritdoc ISuperOracle
    function getEmergencyPrice(address token) external view returns (uint256) {
        return emergencyPrices[token];
    }

    /// @inheritdoc IOracle
    function getQuote(
        uint256 baseAmount,
        address base,
        address quote
    )
        external
        view
        virtual
        returns (uint256 quoteAmount)
    {
        // using IOracle interface we always assume average provider
        (quoteAmount,,,) = getQuoteFromProvider(baseAmount, base, quote, AVERAGE_PROVIDER);
    }

    /*//////////////////////////////////////////////////////////////
                            INTERNAL FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    function _validateOracleInputs(
        address[] memory bases,
        address[] memory quotes,
        bytes32[] memory providers,
        address[] memory feeds
    )
        internal
        pure
    {
        uint256 length = bases.length;
        for (uint256 i; i < length; ++i) {
            address base = bases[i];
            address quote = quotes[i];
            bytes32 provider = providers[i];
            address feed = feeds[i];

            if (provider == bytes32(0)) revert ZERO_PROVIDER();
            if (provider == AVERAGE_PROVIDER) revert AVERAGE_PROVIDER_NOT_ALLOWED();
            if (base == address(0) || quote == address(0) || feed == address(0)) revert ZERO_ADDRESS();
        }
    }

    function _setFeedMaxStaleness(address feed, uint256 newMaxStaleness) internal {
        if (newMaxStaleness > maxDefaultStaleness) {
            revert MAX_STALENESS_EXCEEDED();
        }
        if (newMaxStaleness == 0) {
            newMaxStaleness = maxDefaultStaleness;
        }
        feedMaxStaleness[feed] = newMaxStaleness;
        emit FeedMaxStalenessUpdated(feed, newMaxStaleness);
    }

    function _getQuoteFromOracle(
        address oracle,
        uint256 baseAmount,
        address base,
        address quote,
        bool revertOnError
    )
        internal
        view
        virtual
        returns (uint256 quoteAmount)
    {
        int256 answer;
        uint256 updatedAt;

        // --- Get round data ---
        try AggregatorV3Interface(oracle).latestRoundData() returns (
            uint80, int256 _answer, uint256, uint256 _updatedAt, uint80
        ) {
            answer = _answer;
            updatedAt = _updatedAt;
        } catch {
            if (revertOnError) revert ORACLE_ROUND_DATA_CALL_FAIL(oracle);
            return 0;
        }

        // --- Validate data ---
        if (answer <= 0 || block.timestamp - updatedAt > feedMaxStaleness[oracle]) {
            if (revertOnError) revert ORACLE_UNTRUSTED_DATA();
            return 0;
        }

        // --- Get decimals and compute scaled amount ---
        try AggregatorV3Interface(oracle).decimals() returns (uint8 feedDecimals) {
            uint8 baseDecimals = IERC20(base).safeDecimals();
            uint8 quoteDecimals = IERC20(quote).safeDecimals();

            // Calculate quote amount with proper decimal scaling
            quoteAmount = Math.mulDiv(baseAmount, uint256(answer), 10 ** feedDecimals);
            quoteAmount = Math.mulDiv(quoteAmount, 10 ** quoteDecimals, 10 ** baseDecimals);
        } catch {
            if (revertOnError) revert ORACLE_DECIMALS_CALL_FAIL(oracle);
            return 0;
        }
    }


    function _getAverageQuote(
        address base,
        address quote,
        uint256 baseAmount,
        uint256 numberOfProviders
    )
        internal
        view
        virtual
        returns (uint256 quoteAmount, uint256[] memory validQuotes, uint256 totalCount, uint256 count)
    {
        uint256 total;
        validQuotes = new uint256[](numberOfProviders);

        // Loop through all active providers
        // Iterates only until MAX_SAMPLE_PROVIDERS valid quotes are collected to bound gas usage
        for (uint256 i; i < numberOfProviders; ++i) {
            bytes32 provider = activeProviders[i];
            address providerOracle = oracles[base][quote][provider];
            // provider is in active list but has no available oracle address
            /*
            base = ETH
            quote = [USD, EUR]
            providers = [CHAINLINK, eORACLE]

            Let's say we have

            ETH -> USD -> CHAINLINK -> address(0x1)
            ETH -> USD - eORACLE -> address(0x2)
            ETH -> EUR -> CHAINLINK -> address(0x3)

            This would just continue for 

            ETH -> EUR -> eOracle, because oracle address is 0
            */
            if (providerOracle == address(0)) continue;

            // We have one more registered oracle for this base asset
            unchecked {
                ++totalCount;
            }

            uint256 quote_ = _getQuoteFromOracle(providerOracle, baseAmount, base, quote, false);

            /// @dev we don't revert on error, we just skip the oracle value
            if (quote_ > 0) {
                total += quote_;
                validQuotes[count] = quote_;
                // This oracle is available
                unchecked {
                    ++count;
                }
                if (count == MAX_SAMPLE_PROVIDERS) {
                    break;
                }
            }
        }
        if (count == 0) revert NO_VALID_REPORTED_PRICES();

        quoteAmount = total / count;
    }

    function _getOracleDecimals(AggregatorV3Interface oracle_) internal view virtual returns (uint8) {
        return oracle_.decimals();
    }

    function _calculateStdDev(uint256[] memory values, uint256 length) internal pure virtual returns (uint256 stddev) {
        uint256 sum = 0;
        uint256 count = 0;
        for (uint256 i; i < length; ++i) {
            sum += values[i];
            count++;
        }
        if (count < 2) return 0;

        uint256 mean = sum / count;
        uint256 sumSquaredDiff = 0;
        for (uint256 i; i < length; ++i) {
            uint256 diff;
            if (values[i] >= mean) {
                diff = values[i] - mean;
            } else {
                diff = mean - values[i];
            }

            uint256 squaredDiff = Math.mulDiv(diff, diff, 1);
            sumSquaredDiff += squaredDiff;
        }

        uint256 variance = sumSquaredDiff / count;
        return _sqrt(variance);
    }

    function _sqrt(uint256 x) internal pure returns (uint256 y) {
        if (x == 0) return 0;

        uint256 z = (x + 1) / 2;
        y = x;

        while (z < y) {
            y = z;
            z = (x / z + z) / 2;
        }
    }

    function _configureOracles(
        address[] memory bases,
        address[] memory quotes,
        bytes32[] memory providers,
        address[] memory feeds
    )
        internal
    {
        uint256 length = bases.length;

        for (uint256 i; i < length; ++i) {
            address base = bases[i];
            address quote = quotes[i];
            bytes32 provider = providers[i];
            address feed = feeds[i];

            oracles[base][quote][provider] = feed;

            // Update activeProviders array - add provider if not already present
            bool providerExists = false;
            uint256 activeProvidersLength = activeProviders.length;
            for (uint256 j; j < activeProvidersLength; ++j) {
                if (activeProviders[j] == provider) {
                    providerExists = true;
                    break;
                }
            }

            if (!providerExists) {
                activeProviders.push(provider);
                isProviderSet[provider] = true;
            }
        }
    }

    /// @notice Internal logic to set an 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_) internal {
        emergencyPrices[token_] = price_;
        emit EmergencyPriceUpdated(token_, price_);
    }
}

0% src/oracles/SuperOracleL2.sol

Lines covered: 0 / 49 (0%)

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.30;

// Superform

import { SuperOracleBase } from "./SuperOracleBase.sol";
import { ISuperOracleL2 } from "../interfaces/oracles/ISuperOracleL2.sol";

// external
import { IERC20 } from "forge-std/interfaces/IERC20.sol";
import { BoringERC20 } from "../vendor/BoringSolidity/BoringERC20.sol";
import { AggregatorV3Interface } from "../vendor/chainlink/AggregatorV3Interface.sol";
import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";

/// @title SuperOracleL2
/// @author Superform Labs
/// @notice Layer 2 Oracle for Superform
contract SuperOracleL2 is SuperOracleBase, ISuperOracleL2 {
    using BoringERC20 for IERC20;

    /*//////////////////////////////////////////////////////////////
                            STORAGE
    //////////////////////////////////////////////////////////////*/
    mapping(address dataOracle => address uptimeOracle) public uptimeFeeds;
    mapping(address uptimeOracle => uint256 gracePeriod) public gracePeriods;

    uint256 private constant DEFAULT_GRACE_PERIOD_TIME = 3600;

    constructor(
        address superGovernor_,
        address[] memory bases,
        address[] memory quotes,
        bytes32[] memory providers,
        address[] memory feeds
    )
        SuperOracleBase(superGovernor_, bases, quotes, providers, feeds)
    { }

    /*//////////////////////////////////////////////////////////////
                            EXTERNAL FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    /// @inheritdoc ISuperOracleL2
    function batchSetUptimeFeed(
        address[] calldata dataOracles,
        address[] calldata uptimeOracles,
        uint256[] calldata gracePeriods_
    )
        external
    {
        if (msg.sender != SUPER_GOVERNOR) revert UNAUTHORIZED_UPDATE_AUTHORITY();

        uint256 length = dataOracles.length;
        if (length == 0) revert ZERO_ADDRESS(); // Reusing error code
        if (length != uptimeOracles.length || length != gracePeriods_.length) {
            revert ARRAY_LENGTH_MISMATCH();
        }

        for (uint256 i; i < length; ++i) {
            address dataOracle = dataOracles[i];
            address uptimeOracle = uptimeOracles[i];
            uint256 gracePeriod = gracePeriods_[i];

            if (dataOracle == address(0) || uptimeOracle == address(0)) revert ZERO_ADDRESS();

            uptimeFeeds[dataOracle] = uptimeOracle;
            gracePeriods[uptimeOracle] = gracePeriod;

            emit UptimeFeedSet(dataOracle, uptimeOracle);
            emit GracePeriodSet(uptimeOracle, gracePeriod);
        }
    }

    /*//////////////////////////////////////////////////////////////
                            INTERNAL FUNCTIONS
    //////////////////////////////////////////////////////////////*/
    function _getQuoteFromOracle(
        address oracle,
        uint256 baseAmount,
        address base,
        address quote,
        bool revertOnError
    )
        internal
        view
        override
        returns (uint256 quoteAmount)
    {
        {
            address uptimeOracle = uptimeFeeds[oracle];
            if (uptimeOracle == address(0)) revert NO_UPTIME_FEED();

            (
                /*uint80 roundID*/
                ,
                int256 uptimeAnswer,
                uint256 startedAt,
                /*uint256 updatedAt*/
                ,
                /*uint80 answeredInRound*/
            ) = AggregatorV3Interface(uptimeOracle).latestRoundData();

            // Answer == 0: Sequencer is up
            // Answer == 1: Sequencer is down
            bool isSequencerUp = uptimeAnswer == 0;
            if (!isSequencerUp) {
                revert SEQUENCER_DOWN();
            }

            // Make sure the grace period has passed after the
            // sequencer is back up.
            uint256 timeSinceUp = block.timestamp - startedAt;
            uint256 gracePeriod = gracePeriods[uptimeOracle];
            if (gracePeriod == 0) {
                gracePeriod = DEFAULT_GRACE_PERIOD_TIME;
            }
            if (timeSinceUp <= gracePeriod) {
                revert GRACE_PERIOD_NOT_OVER();
            }
        }

        (, int256 answer,, uint256 updatedAt,) = AggregatorV3Interface(oracle).latestRoundData();

        // Validate data
        if (answer <= 0 || block.timestamp - updatedAt > feedMaxStaleness[oracle]) {
            if (revertOnError) revert ORACLE_UNTRUSTED_DATA();
            return 0;
        }

        // Get decimals
        uint8 feedDecimals = _getOracleDecimals(AggregatorV3Interface(oracle));
        uint8 baseDecimals = IERC20(base).safeDecimals();
        uint8 quoteDecimals = IERC20(quote).safeDecimals();

        // Calculate quote amount with proper decimal scaling
        quoteAmount = Math.mulDiv(baseAmount, uint256(answer), 10 ** feedDecimals);
        quoteAmount = Math.mulDiv(quoteAmount, 10 ** quoteDecimals, 10 ** baseDecimals);
    }
}

0% src/vendor/BoringSolidity/BoringERC20.sol

Lines covered: 0 / 4 (0%)

// SPDX-License-Identifier: UNLICENSED
// With thanks to @BoringCrypto
pragma solidity >=0.8.19;

import { IERC20 } from "forge-std/interfaces/IERC20.sol";

// solhint-disable avoid-low-level-calls

library BoringERC20 {
    bytes4 private constant SIG_DECIMALS = 0x313ce567; // decimals()

    /// @notice Provides a safe ERC20.decimals version which returns '18' as fallback value.
    /// @param token The address of the ERC-20 token contract.
    /// @return (uint8) Token decimals.
    function safeDecimals(IERC20 token) internal view returns (uint8) {
        (bool success, bytes memory data) = address(token).staticcall(abi.encodeWithSelector(SIG_DECIMALS));
        return success && data.length == 32 ? abi.decode(data, (uint8)) : 18;
    }
}

0% src/vendor/BytesLib.sol

Lines covered: 0 / 4 (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;
    }
}

100% test/recon/BeforeAfter.sol

Lines covered: 86 / 86 (100%)

// 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% test/recon/CryticTester.sol

Lines covered: 2 / 2 (100%)

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

83% test/recon/Properties.sol

Lines covered: 290 / 346 (83%)

// 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% test/recon/Setup.sol

Lines covered: 158 / 159 (99%)

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

73% test/recon/helpers/MerkleTestHelper.sol

Lines covered: 25 / 34 (73%)

// 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% test/recon/helpers/UnsafeSuperVaultAggregator.sol

Lines covered: 8 / 8 (100%)

// 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% test/recon/managers/YieldManager.sol

Lines covered: 26 / 29 (89%)

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

30% test/recon/mocks/MockECDSAPPSOracle.sol

Lines covered: 13 / 42 (30%)

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

91% test/recon/mocks/MockERC4626Tester.sol

Lines covered: 107 / 117 (91%)

// 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% test/recon/mocks/MockERC4626YieldSourceOracle.sol

Lines covered: 6 / 57 (10%)

// 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% test/recon/mocks/MockERC5115Tester.sol

Lines covered: 26 / 104 (25%)

// 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% test/recon/mocks/MockERC5115YieldSourceOracle.sol

Lines covered: 6 / 59 (10%)

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

77% test/recon/mocks/MockERC7540Tester.sol

Lines covered: 137 / 177 (77%)

// 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% test/recon/mocks/MockERC7540YieldSourceOracle.sol

Lines covered: 6 / 60 (10%)

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

92% test/recon/targets/AdminTargets.sol

Lines covered: 187 / 203 (92%)

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

88% test/recon/targets/DoomsdayTargets.sol

Lines covered: 331 / 375 (88%)

// 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% test/recon/targets/ManagersTargets.sol

Lines covered: 14 / 14 (100%)

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

92% test/recon/targets/OracleTargets.sol

Lines covered: 36 / 39 (92%)

// 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% test/recon/targets/SuperGovernorTargets.sol

Lines covered: 37 / 37 (100%)

// 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% test/recon/targets/SuperVaultAggregatorTargets.sol

Lines covered: 56 / 56 (100%)

// 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% test/recon/targets/SuperVaultEscrowTargets.sol

Lines covered: 6 / 6 (100%)

// 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% test/recon/targets/SuperVaultStrategyTargets.sol

Lines covered: 36 / 36 (100%)

// 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% test/recon/targets/SuperVaultTargets.sol

Lines covered: 123 / 123 (100%)

// 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% test/recon/targets/YieldSourceTargets.sol

Lines covered: 166 / 176 (94%)

// 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	16×	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	25×	function erc7540_1(address erc7540Target) public virtual returns (bool) {
82		// Doesn't hold on zero price
83	3×	if (
84	62×	IERC7540Like(erc7540Target).convertToAssets(
85	128×	10 ** IShareLike(IERC7540Like(erc7540Target).share()).decimals()
86	1×	) == 0
87	2×	) return true;
88
89		return
90	63×	IERC7540Like(erc7540Target).convertToAssets(
91	115×	IShareLike(IERC7540Like(erc7540Target).share()).totalSupply()
92	58×	) == IERC7540Like(erc7540Target).totalAssets();
93		}
94
95		/// @dev 7540-2 convertToShares(totalAssets) == totalSupply unless price is 0.0
96	25×	function erc7540_2(address erc7540Target) public virtual returns (bool) {
97	3×	if (
98	62×	IERC7540Like(erc7540Target).convertToAssets(
99	128×	10 ** IShareLike(IERC7540Like(erc7540Target).share()).decimals()
100	1×	) == 0
101	2×	) return true;
102
103		// convertToShares(totalAssets) == totalSupply
104		return
105	7×	_diff(
106	61×	IERC7540Like(erc7540Target).convertToShares(
107	58×	IERC7540Like(erc7540Target).totalAssets()
108		),
109	115×	IShareLike(IERC7540Like(erc7540Target).share()).totalSupply()
110		) <= MAX_ROUNDING_ERROR;
111		}
112
113	2×	function _diff(uint256 a, uint256 b) internal pure returns (uint256) {
114	19×	return a > b ? a - b : b - a;
115		}
116
117		/// @dev 7540-3 max* never reverts
118	26×	function erc7540_3(address erc7540Target) public virtual returns (bool) {
119		// max* never reverts
120	65×	try IERC7540Like(erc7540Target).maxDeposit(actor) {} catch {
121	2×	return false;
122		}
123	66×	try IERC7540Like(erc7540Target).maxMint(actor) {} catch {
124	0	return false;
125		}
126	66×	try IERC7540Like(erc7540Target).maxRedeem(actor) {} catch {
127	2×	return false;
128		}
129	67×	try IERC7540Like(erc7540Target).maxWithdraw(actor) {} catch {
130	0	return false;
131		}
132
133	2×	return true;
134		}
135
136		/// == erc7540_4 == //
137
138		/// @dev 7540-4 claiming more than max always reverts
139	21×	function erc7540_4_deposit(
140		address erc7540Target,
141		uint256 amt
142	2×	) public virtual returns (bool) {
143		// Skip 0
144	12×	if (amt == 0) {
145	6×	return true; // Skip
146		}
147
148	139×	uint256 maxDep = IERC7540Like(erc7540Target).maxDeposit(actor);
149
150		/// @audit No Revert is proven by erc7540_5
151
152	16×	uint256 sum = maxDep + amt;
153	12×	if (sum == 0) {
154	0	return true; // Needs to be greater than 0, skip
155		}
156
157	16×	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	21×	function erc7540_4_mint(
168		address erc7540Target,
169		uint256 amt
170	2×	) public virtual returns (bool) {
171		// Skip 0
172	12×	if (amt == 0) {
173	6×	return true;
174		}
175
176	139×	uint256 maxDep = IERC7540Like(erc7540Target).maxMint(actor);
177
178	16×	uint256 sum = maxDep + amt;
179	12×	if (sum == 0) {
180	0	return true; // Needs to be greater than 0, skip
181		}
182
183	64×	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	21×	function erc7540_4_withdraw(
194		address erc7540Target,
195		uint256 amt
196	2×	) public virtual returns (bool) {
197		// Skip 0
198	12×	if (amt == 0) {
199	6×	return true;
200		}
201
202	139×	uint256 maxDep = IERC7540Like(erc7540Target).maxWithdraw(actor);
203
204	16×	uint256 sum = maxDep + amt;
205	12×	if (sum == 0) {
206	0	return true; // Needs to be greater than 0
207		}
208
209	16×	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	33×	function erc7540_4_redeem(
220		address erc7540Target,
221		uint256 amt
222	2×	) public virtual returns (bool) {
223		// Skip 0
224	12×	if (amt == 0) {
225	6×	return true;
226		}
227
228	139×	uint256 maxDep = IERC7540Like(erc7540Target).maxRedeem(actor);
229
230	16×	uint256 sum = maxDep + amt;
231	12×	if (sum == 0) {
232	0	return true; // Needs to be greater than 0
233		}
234
235	139×	try IERC7540Like(erc7540Target).redeem(maxDep + amt, actor, actor) {
236	5×	return false;
237		} catch {
238		// We want this to be hit
239	14×	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	23×	function erc7540_5(
249		address erc7540Target,
250		address shareToken,
251		uint256 shares
252	2×	) public virtual returns (bool) {
253	12×	if (shares == 0) {
254	6×	return true; // Skip
255		}
256
257	139×	uint256 actualBal = IShareLike(shareToken).balanceOf(actor);
258	16×	uint256 balWeWillUse = actualBal + shares;
259
260	12×	if (balWeWillUse == 0) {
261	0	return true; // Skip
262		}
263
264	5×	try
265	87×	IERC7540Like(erc7540Target).requestRedeem(
266		balWeWillUse,
267	18×	actor,
268		actor,
269		""
270		)
271		{
272	2×	return false;
273		} catch {
274	14×	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	28×	function erc7540_6(address erc7540Target) public virtual returns (bool) {
282		// preview* always reverts
283	58×	try IERC7540Like(erc7540Target).previewDeposit(0) {
284	2×	return false;
285		} catch {}
286	59×	try IERC7540Like(erc7540Target).previewMint(0) {
287	2×	return false;
288		} catch {}
289	36×	try IERC7540Like(erc7540Target).previewRedeem(0) {
290	0	return false;
291		} catch {}
292	36×	try IERC7540Like(erc7540Target).previewWithdraw(0) {
293	0	return false;
294		} catch {}
295
296	2×	return true;
297		}
298
299		/// == erc7540_7 == //
300
301		/// @dev 7540-7 if max[method] > 0, then [method] (max) should not revert
302	20×	function erc7540_7_deposit(
303		address erc7540Target,
304		uint256 amt
305	4×	) public virtual returns (bool) {
306		// Per erc7540_4
307	74×	uint256 maxDeposit = IERC7540Like(erc7540Target).maxDeposit(actor);
308	9×	amt = between(amt, 0, maxDeposit);
309
310	6×	if (amt == 0) {
311	6×	return true; // Skip
312		}
313
314	25×	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	20×	function erc7540_7_mint(
325		address erc7540Target,
326		uint256 amt
327	4×	) public virtual returns (bool) {
328	74×	uint256 maxMint = IERC7540Like(erc7540Target).maxMint(actor);
329	9×	amt = between(amt, 0, maxMint);
330
331	6×	if (amt == 0) {
332	6×	return true; // Skip
333		}
334
335	25×	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	31×	function erc7540_7_withdraw(
346		address erc7540Target,
347		uint256 amt
348	10×	) public virtual returns (bool) {
349	141×	uint256 maxWithdraw = IERC7540Like(erc7540Target).maxWithdraw(actor);
350	18×	amt = between(amt, 0, maxWithdraw);
351
352	11×	if (amt == 0) {
353	12×	return true; // Skip
354		}
355
356	77×	try IERC7540Like(erc7540Target).withdraw(amt, actor, actor) {
357		// Success here
358	6×	return true;
359		} catch {
360	6×	return false;
361		}
362
363		// NOTE: This code path is never hit per the above
364		}
365
366	20×	function erc7540_7_redeem(
367		address erc7540Target,
368		uint256 amt
369	4×	) public virtual returns (bool) {
370		// Per erc7540_4
371	74×	uint256 maxRedeem = IERC7540Like(erc7540Target).maxRedeem(actor);
372	9×	amt = between(amt, 0, maxRedeem);
373
374	6×	if (amt == 0) {
375	6×	return true; // Skip
376		}
377
378	27×	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		}

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	4×	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	10×	modifier initializer() {
105		// solhint-disable-next-line var-name-mixedcase
106	14×	InitializableStorage storage $ = _getInitializableStorage();
107
108		// Cache values to avoid duplicated sloads
109	18×	bool isTopLevelCall = !$._initializing;
110	3×	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	22×	bool initialSetup = initialized == 0 && isTopLevelCall;
118	25×	bool construction = initialized == 1 && address(this).code.length == 0;
119
120	22×	if (!initialSetup && !construction) {
121	0	revert InvalidInitialization();
122		}
123	14×	$._initialized = 1;
124	10×	if (isTopLevelCall) {
125	12×	$._initializing = true;
126		}
127		_;
128	10×	if (isTopLevelCall) {
129	10×	$._initializing = false;
130	22×	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	30×	_checkInitializing();
172		_;
173		}
174
175		/**
176		* @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}.
177		*/
178	2×	function _checkInitializing() internal view virtual {
179	12×	if (!_isInitializing()) {
180	0	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	6×	function _disableInitializers() internal virtual {
193		// solhint-disable-next-line var-name-mixedcase
194		InitializableStorage storage $ = _getInitializableStorage();
195
196	22×	if ($._initializing) {
197	0	revert InvalidInitialization();
198		}
199	18×	if ($._initialized != type(uint64).max) {
200	16×	$._initialized = type(uint64).max;
201	22×	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	6×	function _isInitializing() internal view returns (bool) {
216	22×	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	2×	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	6×	function _getInitializableStorage() private pure returns (InitializableStorage storage $) {
233	2×	bytes32 slot = _initializableStorageSlot();
234		assembly {
235		$.slot := slot
236		}
237		}
238		}

1		// SPDX-License-Identifier: MIT
2		pragma solidity ^0.8.0;
3
4		import {Asserts} from "./Asserts.sol";
5
6	0	contract CryticAsserts is Asserts {
7		event Log(string);
8
9	1×	function gt(uint256 a, uint256 b, string memory reason) internal virtual override {
10	5×	if (!(a > b)) {
11	0	emit Log(reason);
12		assert(false);
13		}
14		}
15
16	2×	function gte(uint256 a, uint256 b, string memory reason) internal virtual override {
17	12×	if (!(a >= b)) {
18	16×	emit Log(reason);
19		assert(false);
20		}
21		}
22
23		function lt(uint256 a, uint256 b, string memory reason) internal virtual override {
24		if (!(a < b)) {
25		emit Log(reason);
26		assert(false);
27		}
28		}
29
30	2×	function lte(uint256 a, uint256 b, string memory reason) internal virtual override {
31	12×	if (!(a <= b)) {
32	8×	emit Log(reason);
33		assert(false);
34		}
35		}
36
37	2×	function eq(uint256 a, uint256 b, string memory reason) internal virtual override {
38	10×	if (!(a == b)) {
39	24×	emit Log(reason);
40	6×	assert(false);
41		}
42		}
43
44	2×	function t(bool b, string memory reason) internal virtual override {
45	6×	if (!b) {
46	16×	emit Log(reason);
47	3×	assert(false);
48		}
49		}
50
51	8×	function between(uint256 value, uint256 low, uint256 high) internal virtual override returns (uint256) {
52	30×	if (value < low \|\| value > high) {
53	52×	uint256 ans = low + (value % (high - low + 1));
54	6×	return ans;
55		}
56	4×	return value;
57		}
58
59		function between(int256 value, int256 low, int256 high) internal virtual override returns (int256) {
60		if (value < low \|\| value > high) {
61		int256 range = high - low + 1;
62		int256 clamped = (value - low) % (range);
63		if (clamped < 0) clamped += range;
64		int256 ans = low + clamped;
65		return ans;
66		}
67		return value;
68		}
69
70		function precondition(bool p) internal virtual override {
71		require(p);
72		}
73		}

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	21×	IHevm constant vm = IHevm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
55
56		// slither-disable-end shadowing-local

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	5×	_actors.add(address(this));
31	8×	_actor = address(this);
32		}
33
34		/// @notice Returns the current active actor
35	351×	function _getActor() internal view returns (address) {
36	552×	return _actor;
37		}
38
39		/// @notice Returns all actors being used
40	10×	function _getActors() internal view returns (address[] memory) {
41	18×	return _actors.values();
42		}
43
44		/// @notice Adds an actor to the list of actors
45	3×	function _addActor(address target) internal {
46	10×	if (_actors.contains(target)) {
47	0	revert ActorExists();
48		}
49
50	7×	if (target == address(this)) {
51	0	revert DefaultActor();
52		}
53
54	7×	_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	6×	function _switchActor(uint256 entropy) internal returns (address target) {
77	14×	target = _actors.at(entropy);
78	20×	_actor = target;
79		}
80		}

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	0	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	3×	function _add(Set storage set, bytes32 value) private returns (bool) {
66	4×	if (!_contains(set, value)) {
67	44×	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	36×	set._indexes[value] = set._values.length;
71	4×	return true;
72		} else {
73	0	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	2×	function _contains(Set storage set, bytes32 value) private view returns (bool) {
121	52×	return set._indexes[value] != 0;
122		}
123
124		/**
125		* @dev Returns the number of values on the set. O(1).
126		*/
127	2×	function _length(Set storage set) private view returns (uint256) {
128	4×	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	21×	function _at(Set storage set, uint256 index) private view returns (bytes32) {
142	66×	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	24×	function _values(Set storage set) private view returns (bytes32[] memory) {
154	276×	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	10×	function add(AddressSet storage set, address value) internal returns (bool) {
244	13×	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	4×	function contains(AddressSet storage set, address value) internal view returns (bool) {
261	6×	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	4×	function length(AddressSet storage set) internal view returns (uint256) {
268	4×	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	6×	function at(AddressSet storage set, uint256 index) internal view returns (address) {
282	15×	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	12×	function values(AddressSet storage set) internal view returns (address[] memory) {
294	24×	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		}

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	88×	string public name;
35
36	0	string public symbol;
37
38	72×	uint8 public immutable decimals;
39
40		/*//////////////////////////////////////////////////////////////
41		ERC20 STORAGE
42		//////////////////////////////////////////////////////////////*/
43
44	50×	uint256 public totalSupply;
45
46	336×	mapping(address => uint256) public balanceOf;
47
48	0	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	0	mapping(address => uint256) public nonces;
59
60		/*//////////////////////////////////////////////////////////////
61		CONSTRUCTOR
62		//////////////////////////////////////////////////////////////*/
63
64		constructor(string memory _name, string memory _symbol, uint8 _decimals) {
65	36×	name = _name;
66	28×	symbol = _symbol;
67	20×	decimals = _decimals;
68
69	12×	INITIAL_CHAIN_ID = block.chainid;
70	24×	INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();
71		}
72
73		/*//////////////////////////////////////////////////////////////
74		ERC20 LOGIC
75		//////////////////////////////////////////////////////////////*/
76
77	248×	function approve(address spender, uint256 amount) public virtual returns (bool) {
78	145×	allowance[msg.sender][spender] = amount;
79
80	65×	emit Approval(msg.sender, spender, amount);
81
82	5×	return true;
83		}
84
85	182×	function transfer(address to, uint256 amount) public virtual returns (bool) {
86	143×	uint256 fromBalance = balanceOf[msg.sender];
87	154×	if (fromBalance < amount) revert InsufficientBalance(msg.sender, fromBalance, amount);
88
89	286×	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	208×	balanceOf[to] += amount;
95		}
96
97	169×	emit Transfer(msg.sender, to, amount);
98
99	26×	return true;
100		}
101
102	174×	function transferFrom(address from, address to, uint256 amount) public virtual returns (bool) {
103	264×	uint256 allowed = allowance[from][msg.sender]; // Saves gas for limited approvals.
104	110×	uint256 fromBalance = balanceOf[from];
105
106	54×	if (allowed != type(uint256).max) {
107	292×	if (allowed < amount) revert InsufficientAllowance(from, msg.sender, allowed, amount);
108	300×	allowance[from][msg.sender] = allowed - amount;
109		}
110
111	150×	if (fromBalance < amount) revert InsufficientBalance(from, fromBalance, amount);
112	280×	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	160×	balanceOf[to] += amount;
118		}
119
120	100×	emit Transfer(from, to, amount);
121
122	20×	return true;
123		}
124
125		/*//////////////////////////////////////////////////////////////
126		EIP-2612 LOGIC
127		//////////////////////////////////////////////////////////////*/
128
129	0	function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s)
130		public
131		virtual
132		{
133	0	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	0	address recoveredAddress = ecrecover(
139	0	keccak256(
140	0	abi.encodePacked(
141		"\x19\x01",
142	0	DOMAIN_SEPARATOR(),
143	0	keccak256(
144	0	abi.encode(
145	0	keccak256(
146		"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
147		),
148		owner,
149		spender,
150		value,
151	0	nonces[owner]++,
152		deadline
153		)
154		)
155		)
156		),
157		v,
158		r,
159		s
160		);
161
162	0	require(recoveredAddress != address(0) && recoveredAddress == owner, "INVALID_SIGNER");
163
164	0	allowance[recoveredAddress][spender] = value;
165		}
166
167	0	emit Approval(owner, spender, value);
168		}
169
170	0	function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
171	0	return block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator();
172		}
173
174	16×	function computeDomainSeparator() internal view virtual returns (bytes32) {
175	32×	return keccak256(
176	60×	abi.encode(
177	4×	keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
178	72×	keccak256(bytes(name)),
179	4×	keccak256("1"),
180	4×	block.chainid,
181	4×	address(this)
182		)
183		);
184		}
185
186		/*//////////////////////////////////////////////////////////////
187		INTERNAL MINT/BURN LOGIC
188		//////////////////////////////////////////////////////////////*/
189
190	44×	function _mint(address to, uint256 amount) internal virtual {
191	96×	uint256 newTotalSupply = totalSupply + amount;
192	64×	if (newTotalSupply < totalSupply) revert MintOverflow(totalSupply, amount);
193	32×	totalSupply = newTotalSupply;
194
195		// Cannot overflow because the sum of all user
196		// balances can't exceed the max uint256 value.
197		unchecked {
198	168×	balanceOf[to] += amount;
199		}
200
201	88×	emit Transfer(address(0), to, amount);
202		}
203
204	8×	function _burn(address from, uint256 amount) internal virtual {
205	104×	uint256 fromBalance = balanceOf[from];
206	118×	if (fromBalance < amount) revert InsufficientBalance(from, fromBalance, amount);
207
208	138×	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	54×	totalSupply -= amount;
214		}
215
216	30×	emit Transfer(from, address(0), amount);
217		}
218		}
219
220	428×	contract MockERC20 is ERC20 {
221	136×	constructor(string memory _name, string memory _symbol, uint8 _decimals) ERC20(_name, _symbol, _decimals) {}
222
223	44×	function mint(address to, uint256 value) public virtual {
224	18×	_mint(to, value);
225		}
226
227	0	function burn(address from, uint256 value) public virtual {
228	0	_burn(from, value);
229		}
230		}

1		// SPDX-License-Identifier: GPL-2.0
2		pragma solidity ^0.8.0;
3
4		import {Panic} from "./Panic.sol";
5
6	0	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	4×	function checkError(bytes memory err, string memory expected) internal pure returns (bool) {
12	11×	(string memory revertMsg, bool customError) = _getRevertMsg(err);
13
14	1×	bytes32 errorBytes;
15	1×	bytes32 expectedBytes;
16
17	7×	if (customError) {
18		// Custom error returns the keccak256 hash of the error, so don't need to hash it again
19	32×	errorBytes = bytes32(abi.encodePacked(revertMsg, bytes28(0)));
20	33×	expectedBytes = bytes4(keccak256(abi.encodePacked(expected)));
21		} else {
22	0	errorBytes = keccak256(abi.encodePacked(revertMsg));
23	0	expectedBytes = keccak256(abi.encodePacked(expected));
24		}
25
26		// Check if error contains expected string
27	2×	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	7×	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	7×	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	7×	if (returnData.length == 4 + 32) {
41		// Check that the data starts with the Panic signature
42	0	bool panic = _checkIfPanic(returnData);
43
44	0	if (panic) {
45	0	return _getPanicCode(returnData);
46		}
47		}
48
49		// Get the error selector from returnData
50	5×	bytes4 errorSelector = _getErrorSelector(returnData);
51
52		// 2. Error(string) - If it's a standard revert string
53	1×	bytes4 errorStringSelector = bytes4(keccak256("Error(string)")); // Get the standard Error(string) selector
54
55	6×	if (errorSelector == errorStringSelector) {
56		assembly {
57		// slice the sighash of the error so we can decode the string
58	0	returnData := add(returnData, 0x04)
59		}
60	0	return (abi.decode(returnData, (string)), false);
61		}
62
63		// 3. Custom error - Return the custom error selector as a string
64	24×	return (string(abi.encodePacked(errorSelector)), true);
65		}
66
67	0	function _checkIfPanic(bytes memory returnData) internal pure returns (bool) {
68	0	bytes4 panicSignature = bytes4(keccak256(bytes("Panic(uint256)")));
69
70	0	for (uint256 i = 0; i < 4; i++) {
71	0	if (returnData[i] != panicSignature[i]) {
72	0	return false;
73		}
74		}
75
76	0	return true;
77		}
78
79	0	function _getPanicCode(bytes memory returnData) internal pure returns (string memory, bool) {
80		uint256 panicCode;
81	0	for (uint256 i = 4; i < 36; i++) {
82	0	panicCode = panicCode << 8;
83	0	panicCode \|= uint8(returnData[i]);
84		}
85
86		// Convert the panic code into its string representation
87	0	if (panicCode == 1) {
88		// call assert with an argument that evaluates to false
89	0	return (Panic.assertionPanic, false);
90	0	} else if (panicCode == 17) {
91		// arithmetic operation results in underflow or overflow
92	0	return (Panic.arithmeticPanic, false);
93	0	} else if (panicCode == 18) {
94		// division or modulo by zero
95	0	return (Panic.divisionPanic, false);
96	0	} else if (panicCode == 33) {
97		// converting a value that's too big or negative into an enum type
98	0	return (Panic.enumPanic, false);
99	0	} else if (panicCode == 34) {
100		// access a storage byte array that is incorrectly encoded
101	0	return (Panic.arrayPanic, false);
102	0	} else if (panicCode == 49) {
103		// call .pop() on an empty array
104	0	return (Panic.emptyArrayPanic, false);
105	0	} else if (panicCode == 50) {
106		// array access out of bounds
107	0	return (Panic.outOfBoundsPanic, false);
108	0	} else if (panicCode == 65) {
109		// allocate too much memory or create an array that is too large
110	0	return (Panic.memoryPanic, false);
111	0	} else if (panicCode == 81) {
112		// call a zero-initialized variable of internal function type
113	0	return (Panic.functionPanic, false);
114		}
115
116	0	return ("Undefined panic code", false);
117		}
118
119	1×	function _getErrorSelector(bytes memory returnData) internal pure returns (bytes4 errorSelector) {
120		assembly {
121	4×	errorSelector := mload(add(returnData, 0x20))
122		}
123		return errorSelector;
124		}
125		}

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	0	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	0	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	0	address public transient asset;
36
37		/// @notice Execution nonce for creating unique contexts
38	214×	uint256 public transient executionNonce;
39
40		/// @notice Last execution context caller
41	0	address public transient lastCaller;
42
43		// Storage offsets for different state variables
44	15×	uint256 private constant OUT_AMOUNT_OFFSET = 1;
45	22×	uint256 private constant PRE_EXECUTE_MUTEX_OFFSET = 2;
46	12×	uint256 private constant POST_EXECUTE_MUTEX_OFFSET = 3;
47
48		/// @notice Base storage key for hook execution state
49	11×	bytes32 private constant HOOK_EXECUTION_STORAGE = keccak256("hook.execution.state");
50
51		/// @notice Storage key for account context mapping
52	23×	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	0	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	102×	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	100×	hookType = hookType_;
103	36×	SUB_TYPE = subType_;
104		}
105
106		modifier onlyLastCaller() {
107	48×	if (msg.sender != lastCaller) revert UNAUTHORIZED_CALLER();
108		_;
109		}
110
111		/*//////////////////////////////////////////////////////////////
112		EXECUTION SECURITY
113		//////////////////////////////////////////////////////////////*/
114		/// @inheritdoc ISuperHook
115	299×	function setExecutionContext(address caller) external {
116	115×	_createExecutionContext(caller);
117	230×	lastCaller = msg.sender;
118		}
119
120		/// @dev Standard build pattern - MUST include preExecute first, postExecute last
121		/// @inheritdoc ISuperHook
122	418×	function build(
123		address prevHook,
124		address account,
125		bytes calldata hookData
126		)
127		external
128		view
129		virtual
130	23×	returns (Execution[] memory executions)
131	11×	{
132		// Get hook-specific executions
133	217×	Execution[] memory hookExecutions = _buildHookExecutions(prevHook, account, hookData);
134
135		// Always include pre + hook + post
136	627×	executions = new Execution[](hookExecutions.length + 2);
137
138		// FIRST: preExecute
139	429×	executions[0] = Execution({
140	11×	target: address(this),
141	11×	value: 0,
142	572×	callData: abi.encodeCall(this.preExecute, (prevHook, account, hookData))
143		});
144
145		// MIDDLE: hook-specific operations
146	165×	for (uint256 i = 0; i < hookExecutions.length; i++) {
147	451×	executions[i + 1] = hookExecutions[i];
148		}
149
150		// LAST: postExecute
151	506×	executions[executions.length - 1] = Execution({
152	11×	target: address(this),
153	11×	value: 0,
154	572×	callData: abi.encodeCall(this.postExecute, (prevHook, account, hookData))
155		});
156		}
157
158		/// @inheritdoc ISuperHook
159	121×	function preExecute(address prevHook, address account, bytes calldata data) external {
160	77×	if (msg.sender != account) revert UNAUTHORIZED_CALLER();
161	88×	uint256 context = _getCurrentExecutionContext(account);
162	99×	if (_getPreExecuteMutex(context)) revert PRE_EXECUTE_ALREADY_CALLED();
163	64×	_setPreExecuteMutex(context, true);
164	63×	_preExecute(prevHook, account, data);
165		}
166
167		/// @inheritdoc ISuperHook
168	178×	function postExecute(address prevHook, address account, bytes calldata data) external {
169	42×	if (msg.sender != account) revert UNAUTHORIZED_CALLER();
170	48×	uint256 context = _getCurrentExecutionContext(account);
171	54×	if (_getPostExecuteMutex(context)) revert POST_EXECUTE_ALREADY_CALLED();
172	37×	_setPostExecuteMutex(context, true);
173	44×	_postExecute(prevHook, account, data);
174		}
175
176		/// @inheritdoc ISuperHookSetter
177	27×	function setOutAmount(uint256 _outAmount, address caller) external {
178	0	uint256 context = _getCurrentExecutionContext(caller);
179	0	if (_getPreExecuteMutex(context) \|\| _getPostExecuteMutex(context)) {
180	0	revert CANNOT_SET_OUT_AMOUNT();
181		}
182
183	27×	bytes32 key = _makeKey(context, OUT_AMOUNT_OFFSET);
184	18×	assembly {
185	27×	tstore(key, _outAmount)
186		}
187		}
188
189	84×	function getOutAmount(address caller) public view returns (uint256) {
190	80×	return _getOutAmount(_getCurrentExecutionContext(caller));
191		}
192
193		/// @inheritdoc ISuperHook
194	84×	function resetExecutionState(address caller) external onlyLastCaller {
195	48×	uint256 context = _getCurrentExecutionContext(caller);
196	126×	if (!_getPreExecuteMutex(context) \|\| !_getPostExecuteMutex(context)) {
197	0	revert INCOMPLETE_HOOK_EXECUTION();
198		}
199
200	30×	_clearExecutionState(context);
201		}
202
203		/*//////////////////////////////////////////////////////////////
204		VIEW METHODS
205		//////////////////////////////////////////////////////////////*/
206		/// @inheritdoc ISuperHook
207	0	function subtype() external view returns (bytes32) {
208	0	return SUB_TYPE;
209		}
210
211		/// @inheritdoc ISuperHookInspector
212	0	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	0	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	114×	function _decodeBool(bytes memory data, uint256 offset) internal pure returns (bool) {
261	283×	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	18×	function _replaceCalldataAmount(
273		bytes memory data,
274		uint256 amount,
275		uint256 offset
276		)
277		internal
278		pure
279	6×	returns (bytes memory)
280		{
281	138×	bytes memory newAmountEncoded = abi.encodePacked(amount);
282	78×	for (uint256 i; i < 32; ++i) {
283	240×	data[offset + i] = newAmountEncoded[i];
284		}
285	12×	return data;
286		}
287
288	138×	function _makeAccountContextKey(address account) private pure returns (bytes32) {
289	690×	return keccak256(abi.encodePacked(ACCOUNT_CONTEXT_STORAGE, account));
290		}
291
292	115×	function _createExecutionContext(address caller) private returns (uint256) {
293		// Always increment nonce for new execution context
294	322×	executionNonce++;
295	184×	bytes32 key = _makeAccountContextKey(caller);
296
297		// Store this context for the current caller
298	69×	uint256 currentNonce = executionNonce; // Load into local variable for assembly
299		assembly {
300	23×	tstore(key, currentNonce)
301		}
302
303	69×	return executionNonce;
304		}
305
306	44×	function _getCurrentExecutionContext(address caller) private view returns (uint256 context) {
307	66×	bytes32 key = _makeAccountContextKey(caller);
308		assembly {
309	22×	context := tload(key)
310		}
311		}
312
313	22×	function _makeKey(uint256 context, uint256 offset) private pure returns (bytes32) {
314	275×	return keccak256(abi.encodePacked(HOOK_EXECUTION_STORAGE, context, offset));
315		}
316
317	12×	function _getOutAmount(uint256 context) private view returns (uint256 value) {
318	30×	bytes32 key = _makeKey(context, OUT_AMOUNT_OFFSET);
319		assembly {
320		value := tload(key)
321		}
322		}
323
324	9×	function _setOutAmount(uint256 value, address caller) internal {
325	72×	uint256 context = _getCurrentExecutionContext(caller);
326	45×	bytes32 key = _makeKey(context, OUT_AMOUNT_OFFSET);
327		assembly {
328		tstore(key, value)
329		}
330		}
331
332	22×	function _getPreExecuteMutex(uint256 context) private view returns (bool value) {
333	33×	bytes32 key = _makeKey(context, PRE_EXECUTE_MUTEX_OFFSET);
334		assembly {
335		value := tload(key)
336		}
337		}
338
339	11×	function _setPreExecuteMutex(uint256 context, bool value) private {
340	55×	bytes32 key = _makeKey(context, PRE_EXECUTE_MUTEX_OFFSET);
341		assembly {
342		tstore(key, value)
343		}
344		}
345
346	12×	function _getPostExecuteMutex(uint256 context) private view returns (bool value) {
347	30×	bytes32 key = _makeKey(context, POST_EXECUTE_MUTEX_OFFSET);
348		assembly {
349		value := tload(key)
350		}
351		}
352
353	39×	function _setPostExecuteMutex(uint256 context, bool value) private {
354	63×	bytes32 key = _makeKey(context, POST_EXECUTE_MUTEX_OFFSET);
355	11×	assembly {
356	33×	tstore(key, value)
357		}
358		}
359
360	36×	function _clearExecutionState(uint256 context) private {
361	36×	_setPreExecuteMutex(context, false);
362	45×	_setPostExecuteMutex(context, false);
363		}
364		}

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	0	library HookDataDecoder {
10	0	function extractYieldSourceOracleId(bytes memory data) internal pure returns (bytes32) {
11	0	return bytes32(BytesLib.slice(data, 0, 32));
12		}
13
14	50×	function extractYieldSource(bytes memory data) internal pure returns (address) {
15	99×	return BytesLib.toAddress(data, 32);
16		}
17		}

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	0	library HookSubTypes {
8	0	bytes32 public constant BRIDGE = keccak256(bytes("Bridge"));
9	0	bytes32 public constant CANCEL_DEPOSIT = keccak256(bytes("CancelDeposit"));
10	19×	bytes32 public constant CANCEL_DEPOSIT_REQUEST = keccak256(bytes("CancelDepositRequest"));
11	18×	bytes32 public constant CANCEL_REDEEM = keccak256(bytes("CancelRedeem"));
12	19×	bytes32 public constant CANCEL_REDEEM_REQUEST = keccak256(bytes("CancelRedeemRequest"));
13	0	bytes32 public constant CLAIM = keccak256(bytes("Claim"));
14	19×	bytes32 public constant CLAIM_CANCEL_DEPOSIT_REQUEST = keccak256(bytes("ClaimCancelDepositRequest"));
15	19×	bytes32 public constant CLAIM_CANCEL_REDEEM_REQUEST = keccak256(bytes("ClaimCancelRedeemRequest"));
16	0	bytes32 public constant COOLDOWN = keccak256(bytes("Cooldown"));
17	0	bytes32 public constant ETHENA = keccak256(bytes("Ethena"));
18	54×	bytes32 public constant ERC4626 = keccak256(bytes("ERC4626"));
19	54×	bytes32 public constant ERC5115 = keccak256(bytes("ERC5115"));
20	126×	bytes32 public constant ERC7540 = keccak256(bytes("ERC7540"));
21	0	bytes32 public constant LOAN = keccak256(bytes("Loan"));
22	0	bytes32 public constant LOAN_REPAY = keccak256(bytes("LoanRepay"));
23	0	bytes32 public constant MISC = keccak256(bytes("Misc"));
24	0	bytes32 public constant STAKE = keccak256(bytes("Stake"));
25	0	bytes32 public constant SWAP = keccak256(bytes("Swap"));
26	0	bytes32 public constant TOKEN = keccak256(bytes("Token"));
27	0	bytes32 public constant UNSTAKE = keccak256(bytes("Unstake"));
28	0	bytes32 public constant PTYT = keccak256(bytes("PTYT"));
29	0	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		}

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	0	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	0	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	0	require(_length + 31 >= _length, "slice_overflow");
217		}
218	0	require(_bytes.length >= _start + _length, "slice_outOfBounds");
219
220	0	bytes memory tempBytes;
221
222		assembly {
223	0	switch iszero(_length)
224	0	case 0 {
225		// Get a location of some free memory and store it in tempBytes as
226		// Solidity does for memory variables.
227	0	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	0	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	0	let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
244	0	let end := add(mc, _length)
245
246	0	for {
247		// The multiplication in the next line has the same exact purpose
248		// as the one above.
249	0	let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)
250	0	} lt(mc, end) {
251	0	mc := add(mc, 0x20)
252	0	cc := add(cc, 0x20)
253	0	} { mstore(mc, mload(cc)) }
254
255	0	mstore(tempBytes, _length)
256
257		//update free-memory pointer
258		//allocating the array padded to 32 bytes like the compiler does now
259	0	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	0	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	0	mstore(tempBytes, 0)
267
268	0	mstore(0x40, add(tempBytes, 0x20))
269		}
270		}
271
272	0	return tempBytes;
273		}
274
275	75×	function toAddress(bytes memory _bytes, uint256 _start) internal pure returns (address) {
276	357×	require(_bytes.length >= _start + 20, "toAddress_outOfBounds");
277		address tempAddress;
278
279		assembly {
280	175×	tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)
281		}
282
283		return tempAddress;
284		}
285
286	0	function toUint8(bytes memory _bytes, uint256 _start) internal pure returns (uint8) {
287	0	require(_bytes.length >= _start + 1, "toUint8_outOfBounds");
288		uint8 tempUint;
289
290		assembly {
291	0	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	0	function toUint32(bytes memory _bytes, uint256 _start) internal pure returns (uint32) {
309	0	require(_bytes.length >= _start + 4, "toUint32_outOfBounds");
310		uint32 tempUint;
311
312		assembly {
313	0	tempUint := mload(add(add(_bytes, 0x4), _start))
314		}
315
316		return tempUint;
317		}
318
319	0	function toUint64(bytes memory _bytes, uint256 _start) internal pure returns (uint64) {
320	0	require(_bytes.length >= _start + 8, "toUint64_outOfBounds");
321		uint64 tempUint;
322
323		assembly {
324	0	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	54×	function toUint256(bytes memory _bytes, uint256 _start) internal pure returns (uint256) {
353	266×	require(_bytes.length >= _start + 32, "toUint256_outOfBounds");
354		uint256 tempUint;
355
356		assembly {
357	90×	tempUint := mload(add(add(_bytes, 0x20), _start))
358		}
359
360		return tempUint;
361		}
362
363	0	function toBytes32(bytes memory _bytes, uint256 _start) internal pure returns (bytes32) {
364	0	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		}

1		// SPDX-License-Identifier: UNLICENSED
2		pragma solidity 0.8.30;
3
4		// external
5		import { MerkleProof } from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
6		import { ReentrancyGuard } from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
7
8		// Superform
9		import { IHookExecutionData } from "./interfaces/IHookExecutionData.sol";
10		import { ISuperHook, Execution } from "@superform-v2-core/src/interfaces/ISuperHook.sol";
11
12		abstract contract Bank is ReentrancyGuard {
13		/*//////////////////////////////////////////////////////////////
14		ERRORS
15		//////////////////////////////////////////////////////////////*/
16		error INVALID_HOOK();
17		error INVALID_MERKLE_PROOF();
18		error HOOK_EXECUTION_FAILED();
19		error ZERO_LENGTH_ARRAY();
20		error INVALID_ARRAY_LENGTH();
21
22		/*//////////////////////////////////////////////////////////////
23		EVENTS
24		//////////////////////////////////////////////////////////////*/
25		/// @notice Emitted when hooks are executed.
26		/// @param hooks The addresses of the hooks that were executed.
27		/// @param data The data passed to each hook.
28		event HooksExecuted(address[] hooks, bytes[] data);
29
30		/*//////////////////////////////////////////////////////////////
31		INTERNAL FUNCTIONS
32		//////////////////////////////////////////////////////////////*/
33		function _getMerkleRootForHook(address hookAddress) internal view virtual returns (bytes32);
34
35	0	function _executeHooks(IHookExecutionData.HookExecutionData calldata executionData) internal virtual nonReentrant {
36	0	uint256 hooksLength = executionData.hooks.length;
37	0	if (hooksLength == 0) revert ZERO_LENGTH_ARRAY();
38
39		// Validate arrays have matching lengths
40	0	if (hooksLength != executionData.data.length \|\| hooksLength != executionData.merkleProofs.length) {
41	0	revert INVALID_ARRAY_LENGTH();
42		}
43
44	0	address prevHook;
45	0	address hookAddress;
46	0	bytes memory hookData;
47	0	bytes32[] memory merkleProof;
48	0	ISuperHook hook;
49	0	bytes32 merkleRoot;
50	0	Execution[] memory executions;
51	0	Execution memory executionStep;
52	0	bytes32 targetLeaf;
53	0	bool success;
54
55	0	for (uint256 i; i < hooksLength; i++) {
56	0	hookAddress = executionData.hooks[i];
57	0	hookData = executionData.data[i];
58	0	merkleProof = executionData.merkleProofs[i];
59
60	0	hook = ISuperHook(hookAddress);
61
62		// 1. Get the Merkle root specific to this hook
63	0	merkleRoot = _getMerkleRootForHook(hookAddress);
64
65	0	ISuperHook(hookAddress).setExecutionContext(address(this));
66
67		// 2. Build Execution Steps
68	0	executions = hook.build(prevHook, address(this), hookData);
69
70		// 3. Execute Target Calls and verify each target
71	0	for (uint256 j; j < executions.length; ++j) {
72	0	executionStep = executions[j];
73
74		// valid hooks encapsulate execution between a `.preExecute` and ` .postExecute`
75		// target for preExecute and postExecute is the hook address
76		// keep the original behavior for validating the tree against the actual execution steps
77	0	if (executionStep.target != hookAddress) {
78		// Verify that this target is allowed for this hook using the Merkle proof
79		// The leaf is the hash of the target address
80	0	targetLeaf = keccak256(bytes.concat(keccak256(abi.encodePacked(executionStep.target))));
81		// Verify this target is allowed using the corresponding Merkle proof
82	0	if (!MerkleProof.verify(merkleProof, merkleRoot, targetLeaf)) {
83	0	revert INVALID_MERKLE_PROOF();
84		}
85		}
86
87		// Execute the call after verification
88	0	(success,) = executionStep.target.call{ value: executionStep.value }(executionStep.callData);
89	0	if (!success) {
90	0	revert HOOK_EXECUTION_FAILED();
91		}
92		}
93
94		// Reset execution state after each hook
95	0	ISuperHook(hookAddress).resetExecutionState(address(this));
96
97	0	prevHook = hookAddress;
98		}
99
100	0	emit HooksExecuted(executionData.hooks, executionData.data);
101		}
102		}

1		// SPDX-License-Identifier: MIT
2		pragma solidity 0.8.30;
3
4		import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";
5		import { IIncentiveCalculationContract } from "../interfaces/SuperAsset/IIncentiveCalculationContract.sol";
6
7		/// @title IncentiveCalculationContract
8		/// @author Superform Labs
9		/// @notice A stateless contract for calculating incentives.
10	0	contract IncentiveCalculationContract is IIncentiveCalculationContract {
11		using Math for uint256;
12
13		// --- Constants ---
14	0	uint256 public constant PRECISION = 1e18;
15	0	uint256 public constant PERC = 100e18;
16
17		// --- View Functions ---
18		/// @inheritdoc IIncentiveCalculationContract
19	0	function energy(
20		uint256[] memory currentAllocation,
21		uint256[] memory allocationTarget,
22		uint256[] memory weights,
23		uint256 totalCurrentAllocation,
24		uint256 totalAllocationTarget
25		)
26		public
27		pure
28	0	returns (uint256 res, bool isSuccess)
29		{
30	0	if (currentAllocation.length != allocationTarget.length \|\| currentAllocation.length != weights.length) {
31		// NOTE: This is a really corner a case that should never happen, this is why we let it revert even though
32		// in general we do not allow view and pure functions to revert.
33	0	revert INVALID_ARRAY_LENGTH();
34		}
35
36		// NOTE: This is to ensure we won't divide by zero in the subsequent calculations
37	0	if (totalCurrentAllocation == 0 \|\| totalAllocationTarget == 0) {
38	0	return (0, false);
39		}
40
41	0	uint256 length = currentAllocation.length;
42	0	for (uint256 i; i < length; i++) {
43	0	uint256 _currentAllocation = Math.mulDiv(currentAllocation[i], PERC, totalCurrentAllocation);
44	0	uint256 _targetAllocation = Math.mulDiv(allocationTarget[i], PERC, totalAllocationTarget);
45	0	int256 diff = int256(_currentAllocation) - int256(_targetAllocation);
46		// Square the difference and maintain precision
47	0	uint256 diff2 = Math.mulDiv(uint256(diff * diff), 1, PRECISION);
48		// Apply weight and maintain precision
49	0	res += Math.mulDiv(diff2, weights[i], PRECISION);
50		}
51	0	return (res, true);
52		}
53
54		/// @inheritdoc IIncentiveCalculationContract
55	0	function calculateIncentive(
56		uint256[] memory allocationPreOperation,
57		uint256[] memory allocationPostOperation,
58		uint256[] memory allocationTarget,
59		uint256[] memory weights,
60		uint256 totalAllocationPreOperation,
61		uint256 totalAllocationPostOperation,
62		uint256 totalAllocationTarget,
63		uint256 energyToUSDExchangeRatio
64		)
65		public
66		pure
67	0	returns (int256 incentiveUSD, bool isSuccess)
68		{
69	0	if (
70	0	allocationPreOperation.length != allocationPostOperation.length
71	0	\|\| allocationPreOperation.length != allocationTarget.length
72		) {
73	0	revert INVALID_ARRAY_LENGTH();
74		}
75
76	0	uint256 energyBefore;
77	0	uint256 energyAfter;
78	0	bool _isSuccess;
79
80	0	(energyBefore, _isSuccess) = energy(
81	0	allocationPreOperation, allocationTarget, weights, totalAllocationPreOperation, totalAllocationTarget
82		);
83
84	0	if (!_isSuccess) {
85	0	return (0, false);
86		}
87
88	0	(energyAfter, _isSuccess) = energy(
89	0	allocationPostOperation, allocationTarget, weights, totalAllocationPostOperation, totalAllocationTarget
90		);
91
92	0	if (!_isSuccess) {
93	0	return (0, false);
94		}
95
96		// Calculate energy difference first
97	0	int256 energyDiff = int256(energyBefore) - int256(energyAfter);
98
99		// Handle positive and negative cases separately for safe multiplication
100	0	if (energyDiff >= 0) {
101	0	incentiveUSD = int256(Math.mulDiv(uint256(energyDiff), energyToUSDExchangeRatio, PRECISION));
102		} else {
103	0	incentiveUSD = -int256(Math.mulDiv(uint256(-energyDiff), energyToUSDExchangeRatio, PRECISION));
104		}
105	0	return (incentiveUSD, true);
106		}
107		}

1		// SPDX-License-Identifier: MIT
2		pragma solidity 0.8.30;
3
4		import { IERC20Metadata } from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
5		import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
6		import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
7		import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";
8		import { IIncentiveFundContract } from "../interfaces/SuperAsset/IIncentiveFundContract.sol";
9		import { ISuperGovernor } from "../interfaces/ISuperGovernor.sol";
10		import { ISuperAsset } from "../interfaces/SuperAsset/ISuperAsset.sol";
11		import { ISuperAssetFactory } from "../interfaces/SuperAsset/ISuperAssetFactory.sol";
12
13		/// @title Incentive Fund Contract
14		/// @author Superform Labs
15		/// @notice Manages incentive tokens in the SuperAsset system
16		/// @dev This contract is responsible for handling the incentive fund, including paying and taking incentives.
17		/// @dev For now it is OK to keep Access Control but it will be managed by SuperGovernor when ready, see
18		/// https://github.com/superform-xyz/v2-contracts/pull/377#discussion_r2058893391
19	0	contract IncentiveFundContract is IIncentiveFundContract {
20		using SafeERC20 for IERC20;
21
22		// --- State Variables ---
23	0	address public tokenInIncentive;
24	0	address public tokenOutIncentive;
25
26	0	ISuperAsset public superAsset;
27	0	ISuperGovernor public superGovernor;
28
29	0	bool public incentivesActive;
30
31		// --- Modifiers ---
32	0	modifier onlyManager() {
33	0	ISuperAssetFactory factory = ISuperAssetFactory(superGovernor.getAddress(superGovernor.SUPER_ASSET_FACTORY()));
34	0	address manager = factory.getIncentiveFundManager(address(superAsset));
35	0	if (msg.sender != manager) revert UNAUTHORIZED();
36	0	_;
37		}
38
39		/// @inheritdoc IIncentiveFundContract
40	0	function initialize(
41		address _superGovernor,
42		address superAsset_,
43		address tokenInIncentive_,
44		address tokenOutIncentive_
45		)
46		external
47		{
48	0	if (_superGovernor == address(0)) revert ZERO_ADDRESS();
49	0	superGovernor = ISuperGovernor(_superGovernor);
50
51		// Ensure this can only be called once
52	0	if (address(superAsset) != address(0)) revert ALREADY_INITIALIZED();
53
54	0	if (superAsset_ == address(0)) revert ZERO_ADDRESS();
55	0	if (tokenInIncentive_ == address(0)) revert ZERO_ADDRESS();
56	0	if (tokenOutIncentive_ == address(0)) revert ZERO_ADDRESS();
57
58	0	superAsset = ISuperAsset(superAsset_);
59	0	tokenInIncentive = tokenInIncentive_;
60	0	tokenOutIncentive = tokenOutIncentive_;
61		}
62
63		/*//////////////////////////////////////////////////////////////
64		EXTERNAL FUNCTIONS
65		//////////////////////////////////////////////////////////////*/
66		/// @inheritdoc IIncentiveFundContract
67	0	function setTokenInIncentive(address token) external onlyManager {
68	0	if (token == address(0)) revert ZERO_ADDRESS();
69
70	0	bool isWhitelisted = superGovernor.isWhitelistedIncentiveToken(token);
71
72	0	if (isWhitelisted) {
73	0	tokenInIncentive = token;
74		} else {
75	0	revert TOKEN_NOT_WHITELISTED();
76		}
77
78	0	emit SettlementTokenInSet(token);
79		}
80
81		/// @inheritdoc IIncentiveFundContract
82	0	function setTokenOutIncentive(address token) external onlyManager {
83	0	if (token == address(0)) revert ZERO_ADDRESS();
84
85	0	bool isWhitelisted = superGovernor.isWhitelistedIncentiveToken(token);
86
87	0	if (isWhitelisted) {
88	0	tokenOutIncentive = token;
89		} else {
90		revert TOKEN_NOT_WHITELISTED();
91		}
92
93		emit SettlementTokenInSet(token);
94		}
95
96		/// @inheritdoc IIncentiveFundContract
97	0	function toggleIncentives(bool enabled) external onlyManager {
98	0	incentivesActive = enabled;
99	0	emit IncentivesToggled(enabled);
100		}
101
102		/// @inheritdoc IIncentiveFundContract
103	0	function payIncentive(address receiver, uint256 amountUSD) external onlyManager returns (uint256 amountToken) {
104	0	if (!incentivesActive) {
105	0	return 0;
106		}
107
108	0	_validateInput(receiver, amountUSD);
109	0	if (tokenOutIncentive == address(0)) revert TOKEN_OUT_NOT_SET();
110
111		// Get token price and check circuit breakers
112	0	(uint256 priceUSD,,,) = superAsset.getPriceAndCircuitBreakers(tokenOutIncentive);
113
114	0	if (priceUSD > 0) {
115		// Convert USD amount to token amount using price
116		// amountToken = amountUSD / priceUSD
117	0	amountToken = Math.mulDiv(amountUSD, IERC20Metadata(tokenInIncentive).decimals(), priceUSD);
118
119	0	IERC20(tokenOutIncentive).safeTransfer(receiver, amountToken);
120	0	emit IncentivePaid(receiver, tokenOutIncentive, amountToken);
121		}
122
123	0	emit IncentivePaid(receiver, tokenOutIncentive, 0);
124		return 0;
125		}
126
127		/// @inheritdoc IIncentiveFundContract
128	0	function takeIncentive(address sender, uint256 amountUSD) external onlyManager returns (uint256 amountToken) {
129	0	if (!incentivesActive) {
130	0	return 0;
131		}
132
133	0	_validateInput(sender, amountUSD);
134	0	if (tokenInIncentive == address(0)) revert TOKEN_IN_NOT_SET();
135
136		// Get token price and check circuit breakers
137	0	(uint256 priceUSD,,,) = superAsset.getPriceAndCircuitBreakers(tokenInIncentive);
138
139	0	if (priceUSD > 0) {
140		// Convert USD amount to token amount using price
141		// amountToken = amountUSD / priceUSD
142	0	amountToken = Math.mulDiv(amountUSD, IERC20Metadata(tokenInIncentive).decimals(), priceUSD);
143
144	0	IERC20(tokenInIncentive).safeTransferFrom(sender, address(this), amountToken);
145	0	emit IncentiveTaken(sender, tokenInIncentive, amountToken);
146		}
147
148	0	emit IncentiveTaken(sender, tokenInIncentive, 0);
149	0	return 0;
150		}
151
152		/// @inheritdoc IIncentiveFundContract
153	0	function withdraw(address receiver, address tokenOut, uint256 amount) external onlyManager {
154	0	_validateInput(receiver, amount);
155	0	if (tokenOut == address(0)) revert ZERO_ADDRESS();
156
157	0	IERC20(tokenOut).safeTransfer(receiver, amount);
158	0	emit RebalanceWithdrawal(receiver, tokenOut, amount);
159		}
160
161		/// @inheritdoc IIncentiveFundContract
162	0	function incentivesEnabled() external view returns (bool) {
163	0	return incentivesActive;
164		}
165
166		/*//////////////////////////////////////////////////////////////
167		INTERNAL FUNCTIONS
168		//////////////////////////////////////////////////////////////*/
169	0	function _validateInput(address user, uint256 amount) internal pure {
170	0	if (user == address(0)) revert ZERO_ADDRESS();
171	0	if (amount == 0) revert ZERO_AMOUNT();
172		}
173		}

1		// SPDX-License-Identifier: MIT
2		pragma solidity 0.8.30;
3
4		import { Clones } from "@openzeppelin/contracts/proxy/Clones.sol";
5		import { ISuperAssetFactory } from "../interfaces/SuperAsset/ISuperAssetFactory.sol";
6		import { SuperAsset } from "./SuperAsset.sol";
7		import { IncentiveFundContract } from "./IncentiveFundContract.sol";
8		import { IncentiveCalculationContract } from "./IncentiveCalculationContract.sol";
9
10		/**
11		* @title SuperAssetFactory
12		* @author Superform Labs
13		* @notice Factory contract that deploys SuperAsset and its dependencies
14		*/
15	0	contract SuperAssetFactory is ISuperAssetFactory {
16		using Clones for address;
17
18		/*//////////////////////////////////////////////////////////////
19		STATE
20		//////////////////////////////////////////////////////////////*/
21	0	address public immutable superAssetImplementation;
22	0	address public immutable incentiveFundImplementation;
23		// Single instances
24	0	address public immutable superGovernor;
25
26	0	mapping(address superAsset => SuperAssetData data) public data;
27	0	mapping(address icc => bool isValid) public incentiveCalculationContractsWhitelist;
28
29		/*//////////////////////////////////////////////////////////////
30		CONSTRUCTOR
31		//////////////////////////////////////////////////////////////*/
32	0	constructor(address _superGovernor) {
33	0	if (_superGovernor == address(0)) revert ZERO_ADDRESS();
34	0	superGovernor = _superGovernor;
35
36	0	superAssetImplementation = address(new SuperAsset());
37	0	incentiveFundImplementation = address(new IncentiveFundContract());
38		}
39
40		/// @inheritdoc ISuperAssetFactory
41	0	function addICCToWhitelist(address icc) external {
42	0	if (msg.sender != superGovernor) revert UNAUTHORIZED();
43	0	incentiveCalculationContractsWhitelist[icc] = true;
44		}
45
46		/// @inheritdoc ISuperAssetFactory
47	0	function removeICCFromWhitelist(address icc) external {
48	0	if (msg.sender != superGovernor) revert UNAUTHORIZED();
49	0	incentiveCalculationContractsWhitelist[icc] = false;
50		}
51
52		/// @inheritdoc ISuperAssetFactory
53	0	function isICCWhitelisted(address icc) external view returns (bool) {
54	0	return incentiveCalculationContractsWhitelist[icc];
55		}
56
57		/// @inheritdoc ISuperAssetFactory
58	0	function setSuperAssetManager(address superAsset, address _superAssetManager) external {
59	0	if (_superAssetManager == address(0)) revert ZERO_ADDRESS();
60	0	if (
61	0	(msg.sender != data[superAsset].superAssetManager) && (msg.sender != superGovernor) // NOTE: This role can
62		// take over
63	0	) revert UNAUTHORIZED();
64	0	data[superAsset].superAssetManager = _superAssetManager;
65		}
66
67		/// @inheritdoc ISuperAssetFactory
68	0	function setSuperAssetStrategist(address superAsset, address _superAssetStrategist) external {
69	0	if (_superAssetStrategist == address(0)) revert ZERO_ADDRESS();
70	0	if (msg.sender != data[superAsset].superAssetManager) revert UNAUTHORIZED();
71	0	data[superAsset].superAssetStrategist = _superAssetStrategist;
72		}
73
74		/// @inheritdoc ISuperAssetFactory
75	0	function setIncentiveFundManager(address superAsset, address _incentiveFundManager) external {
76	0	if (_incentiveFundManager == address(0)) revert ZERO_ADDRESS();
77	0	if (msg.sender != data[superAsset].superAssetManager) revert UNAUTHORIZED();
78	0	data[superAsset].incentiveFundManager = _incentiveFundManager;
79		}
80
81		/// @inheritdoc ISuperAssetFactory
82	0	function setIncentiveCalculationContract(address superAsset, address _incentiveCalculationContract) external {
83	0	if (_incentiveCalculationContract == address(0)) revert ZERO_ADDRESS();
84	0	if (!incentiveCalculationContractsWhitelist[_incentiveCalculationContract]) revert ICC_NOT_WHITELISTED();
85	0	if (msg.sender != data[superAsset].superAssetManager) revert UNAUTHORIZED();
86	0	data[superAsset].incentiveCalculationContract = _incentiveCalculationContract;
87		}
88
89		/// @inheritdoc ISuperAssetFactory
90	0	function getSuperAssetManager(address superAsset) external view returns (address) {
91	0	return data[superAsset].superAssetManager;
92		}
93
94		/// @inheritdoc ISuperAssetFactory
95	0	function getSuperAssetStrategist(address superAsset) external view returns (address) {
96	0	return data[superAsset].superAssetStrategist;
97		}
98
99		/// @inheritdoc ISuperAssetFactory
100	0	function getIncentiveFundManager(address superAsset) external view returns (address) {
101	0	return data[superAsset].incentiveFundManager;
102		}
103
104		/// @inheritdoc ISuperAssetFactory
105	0	function getIncentiveCalculationContract(address superAsset) external view returns (address) {
106	0	return data[superAsset].incentiveCalculationContract;
107		}
108
109		/// @inheritdoc ISuperAssetFactory
110	0	function getIncentiveFundContract(address superAsset) external view returns (address) {
111	0	return data[superAsset].incentiveFundContract;
112		}
113
114		/*//////////////////////////////////////////////////////////////
115		EXTERNAL FUNCTIONS
116		//////////////////////////////////////////////////////////////*/
117		/// @inheritdoc ISuperAssetFactory
118	0	function createSuperAsset(AssetCreationParams calldata params)
119		external
120	0	returns (address superAsset, address incentiveFundContract)
121		{
122		// TODO: Decide whether to make this method permissionless or permissioned
123
124	0	if (params.incentiveCalculationContract == address(0)) revert ZERO_ADDRESS();
125	0	if (!incentiveCalculationContractsWhitelist[params.incentiveCalculationContract]) revert ICC_NOT_WHITELISTED();
126
127		// Deploy IncentiveFund (this one needs to be unique per SuperAsset)
128	0	incentiveFundContract = incentiveFundImplementation.clone();
129
130		// Deploy SuperAsset with its dependencies
131	0	superAsset = superAssetImplementation.clone();
132	0	SuperAsset(superAsset).initialize(
133	0	params.name,
134	0	params.symbol,
135	0	params.asset,
136	0	superGovernor,
137	0	params.swapFeeInPercentage,
138	0	params.swapFeeOutPercentage
139		);
140
141		// Initialize IncentiveFund
142	0	IncentiveFundContract(incentiveFundContract).initialize(
143	0	superGovernor, superAsset, params.tokenInIncentive, params.tokenOutIncentive
144		);
145
146	0	data[superAsset] = SuperAssetData({
147	0	superAssetManager: params.superAssetManager,
148	0	superAssetStrategist: params.superAssetStrategist,
149	0	incentiveFundManager: params.incentiveFundManager,
150	0	incentiveCalculationContract: params.incentiveCalculationContract,
151		incentiveFundContract: incentiveFundContract
152		});
153
154	0	emit SuperAssetCreated(
155	0	superAsset, incentiveFundContract, params.incentiveCalculationContract, params.name, params.symbol
156		);
157		}
158		}

1		// SPDX-License-Identifier: MIT
2		pragma solidity 0.8.30;
3
4		import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
5		import {ERC20Permit} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol";
6		import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
7		import {Ownable2Step} from "@openzeppelin/contracts/access/Ownable2Step.sol";
8
9		/**
10		* @title Up
11		* @author Superform Foundation
12		*/
13	0	contract Up is ERC20, ERC20Permit, Ownable2Step {
14	0	uint256 public constant INITIAL_SUPPLY = 1_000_000_000 * 10 ** 18;
15	0	uint256 public constant MINT_CAP_BPS = 200; // 2%
16	0	uint256 public constant DAYS_PER_YEAR = 365 days;
17	0	uint256 public constant INITIAL_MINT_LOCK = 3 * 365 days; // 3 years
18
19	0	uint256 public lastMintTimestamp;
20	0	uint256 public immutable INITIAL_MINT_TIMESTAMP;
21
22		event TokensMinted(address indexed to, uint256 amount);
23
24		error MintingTooEarly();
25		error MintAmountTooHigh();
26		error InitialLockPeriodNotOver();
27
28	0	constructor(address initialOwner) ERC20("Superform", "UP") ERC20Permit("Superform") Ownable(initialOwner) {
29	0	_mint(initialOwner, INITIAL_SUPPLY);
30	0	lastMintTimestamp = block.timestamp;
31	0	INITIAL_MINT_TIMESTAMP = block.timestamp;
32		}
33
34		/**
35		* @dev Allows owner to mint new tokens once per year after 3 years, up to 2% of total supply
36		* @param to Address to mint tokens to
37		* @param amount Amount of tokens to mint
38		*/
39	0	function mint(address to, uint256 amount) external onlyOwner {
40		// Check if 3 years have passed since initial mint
41	0	if (block.timestamp < INITIAL_MINT_TIMESTAMP + INITIAL_MINT_LOCK) {
42	0	revert InitialLockPeriodNotOver();
43		}
44
45		// Check if enough time has passed since last mint
46	0	if (block.timestamp < lastMintTimestamp + DAYS_PER_YEAR) {
47	0	revert MintingTooEarly();
48		}
49
50		// Calculate maximum mint amount (2% of total supply)
51	0	uint256 maxMintAmount = (totalSupply() * MINT_CAP_BPS) / 10_000;
52	0	if (amount > maxMintAmount) {
53	0	revert MintAmountTooHigh();
54		}
55
56	0	lastMintTimestamp = block.timestamp;
57	0	_mint(to, amount);
58	0	emit TokensMinted(to, amount);
59		}
60		}

1		// SPDX-License-Identifier: MIT
2		pragma solidity 0.8.30;
3
4		import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
5		import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
6		import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
7		import { Ownable2Step } from "@openzeppelin/contracts/access/Ownable2Step.sol";
8		import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
9		import { MerkleProof } from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
10
11		/**
12		* @title UpDistributor
13		* @notice A contract for distributing tokens using a merkle tree for verification
14		* @dev The foundation can reclaim unclaimed tokens
15		*/
16	0	contract UpDistributor is Ownable2Step {
17		using SafeERC20 for IERC20;
18
19	0	IERC20 public immutable token;
20	0	bytes32 public merkleRoot;
21
22		/// @notice Track which addresses have claimed their tokens
23	0	mapping(address => bool) public hasClaimed;
24
25		event MerkleRootSet(bytes32 merkleRoot);
26		event TokensClaimed(address indexed user, uint256 amount);
27		event TokensReclaimed(uint256 amount);
28
29		error ALREADY_CLAIMED();
30		error NO_TOKENS_TO_RECLAIM();
31		error INVALID_MERKLE_PROOF();
32		error INVALID_TOKEN_ADDRESS();
33
34	0	constructor(address _token, address initialOwner) Ownable(initialOwner) {
35	0	if (_token == address(0)) revert INVALID_TOKEN_ADDRESS();
36	0	token = IERC20(_token);
37		}
38
39		/**
40		* @notice Set a new merkle root for the distribution
41		* @param _merkleRoot The new merkle root
42		*/
43	0	function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
44	0	merkleRoot = _merkleRoot;
45	0	emit MerkleRootSet(_merkleRoot);
46		}
47
48		/**
49		* @notice Claim tokens if you are part of the merkle tree
50		* @param amount The amount of tokens to claim
51		* @param merkleProof A proof of inclusion in the merkle tree
52		*/
53	0	function claim(uint256 amount, bytes32[] calldata merkleProof) external {
54		// Verify user hasn't already claimed
55	0	if (hasClaimed[msg.sender]) revert ALREADY_CLAIMED();
56
57		// Verify the merkle proof
58	0	bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(msg.sender, amount))));
59	0	if (!MerkleProof.verify(merkleProof, merkleRoot, leaf)) revert INVALID_MERKLE_PROOF();
60
61		// Mark as claimed and transfer tokens
62	0	hasClaimed[msg.sender] = true;
63	0	emit TokensClaimed(msg.sender, amount);
64	0	token.safeTransfer(msg.sender, amount);
65		}
66
67		/**
68		* @notice Claim tokens for a recipient
69		* @dev This function can be called by users with smart accounts
70		* @param recipient The address to claim tokens for
71		* @param amount The amount of tokens to claim
72		* @param merkleProof A proof of inclusion in the merkle tree
73		*/
74	0	function claimOnBehalf(
75		address recipient,
76		uint256 amount,
77		bytes32[] calldata merkleProof
78		)
79		external
80	0	{
81		// Verify user hasn't already claimed
82	0	if (hasClaimed[recipient]) revert ALREADY_CLAIMED();
83
84		// Verify the merkle proof
85	0	bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(recipient, amount))));
86	0	if (!MerkleProof.verify(merkleProof, merkleRoot, leaf)) revert INVALID_MERKLE_PROOF();
87
88		// Mark as claimed and transfer tokens
89	0	hasClaimed[recipient] = true;
90	0	emit TokensClaimed(recipient, amount);
91	0	token.safeTransfer(recipient, amount);
92		}
93
94		/**
95		* @notice Allow the foundation to reclaim unclaimed tokens
96		* @param amount The amount of tokens to reclaim
97		*/
98	0	function reclaimTokens(uint256 amount) external onlyOwner {
99	0	uint256 balance = token.balanceOf(address(this));
100	0	if (amount > balance) revert NO_TOKENS_TO_RECLAIM();
101
102	0	emit TokensReclaimed(amount);
103	0	token.safeTransfer(owner(), amount);
104		}
105		}

1		// SPDX-License-Identifier: MIT
2		pragma solidity 0.8.30;
3
4		import { ISuperOracle } from "../interfaces/oracles/ISuperOracle.sol";
5		import { ISuperAsset } from "../interfaces/SuperAsset/ISuperAsset.sol";
6		import { IYieldSourceOracle } from "@superform-v2-core/src/interfaces/accounting/IYieldSourceOracle.sol";
7
8		import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";
9		import { IERC4626 } from "@openzeppelin/contracts/interfaces/IERC4626.sol";
10		import { IERC20Metadata } from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
11
12	0	library SuperAssetPriceLib {
13		using Math for uint256;
14
15		/// @dev Gets the price of a token with circuit breakers
16		/// @param args The arguments for the price calculation
17		/// @return priceUSD The price of the token in USD
18		/// @return isDepeg Whether the token is depegged
19		/// @return isDispersion Whether the token has price dispersion
20		/// @return isOracleOff Whether the oracle is off
21	0	function getPriceWithCircuitBreakers(ISuperAsset.PriceArgs memory args)
22		external
23		view
24	0	returns (uint256 priceUSD, bool isDepeg, bool isDispersion, bool isOracleOff)
25		{
26		// Get token decimals
27	0	uint256 stddev;
28	0	uint256 M;
29
30		// @dev Passing oneUnit to get the price of a single unit of asset to check if it has depegged
31	0	ISuperOracle superOracle = ISuperOracle(args.superOracle);
32	0	ISuperAsset superAsset = ISuperAsset(args.superAsset);
33
34	0	uint256 precision = superAsset.getPrecision();
35
36	0	(priceUSD, stddev, M) = _getPriceInfo(superOracle, superAsset, args.usd, args.token);
37
38		// Circuit Breaker for Oracle Off
39	0	if (M == 0) {
40	0	isOracleOff = true;
41		} else {
42	0	address primaryAsset = superAsset.getPrimaryAsset();
43	0	if (primaryAsset == args.usd) {
44	0	return (precision, false, false, false);
45		}
46
47		// Circuit Breaker for Depeg - price deviates more than ±2% from expected
48	0	(isDepeg, isDispersion) = _getDepegAndDispersion(args, precision, priceUSD, stddev);
49		}
50	0	return (priceUSD, isDepeg, isDispersion, isOracleOff);
51		}
52
53		/// @dev Derives the price of the token from the underlying vault
54		/// @param token The address of the token to derive the price of
55		/// @return priceUSD The price of the token in USD
56		/// @return stddev The standard deviation of the token
57		/// @return M The number of quote providers
58	0	function _derivePriceFromUnderlyingVault(
59		ISuperOracle superOracle,
60		ISuperAsset superAsset,
61		address USD,
62		address token,
63		address oracle
64		)
65		internal
66		view
67	0	returns (uint256 priceUSD, uint256 stddev, uint256 M)
68	0	{
69	0	address vaultAsset = IERC4626(token).asset();
70	0	uint256 unitVaultAsset = 10 ** IERC20Metadata(vaultAsset).decimals();
71
72	0	bytes32 AVERAGE_PROVIDER = keccak256("AVERAGE_PROVIDER");
73
74	0	try superOracle.getQuoteFromProvider(unitVaultAsset, vaultAsset, USD, AVERAGE_PROVIDER) returns (
75		uint256 _priceUSD, uint256 _stddev, uint256, uint256 _m
76		) {
77	0	priceUSD = _priceUSD;
78	0	stddev = _stddev;
79	0	M = _m;
80		} catch {
81	0	priceUSD = superOracle.getEmergencyPrice(vaultAsset);
82	0	stddev = 0;
83	0	M = 0;
84		}
85
86	0	uint256 pricePerShare = IYieldSourceOracle(oracle).getPricePerShare(token);
87	0	if (priceUSD > 0) {
88	0	priceUSD = pricePerShare.mulDiv(priceUSD, superAsset.getPrecision(), Math.Rounding.Floor);
89		}
90		}
91
92		/// @dev Checks if the standard deviation is greater than the dispersion threshold
93		/// @param stddev The standard deviation
94		/// @param priceUSD The price in USD
95		/// @return isDispersion True if the standard deviation is greater than the dispersion threshold
96	0	function _isSTDDevDegged(
97		address superAsset,
98		uint256 stddev,
99		uint256 priceUSD,
100		uint256 dispersionThreshold
101		)
102		internal
103		pure
104	0	returns (bool)
105		{
106		// Calculate relative standard deviation
107	0	uint256 relativeStdDev = Math.mulDiv(stddev, ISuperAsset(superAsset).getPrecision(), priceUSD);
108
109		// Circuit Breaker for Dispersion
110	0	if (relativeStdDev > dispersionThreshold) {
111	0	return true;
112		}
113	0	return false;
114		}
115
116		/// @dev Checks if the token is depegged
117		/// @param priceUSD The price of the token in USD
118		/// @param assetPriceUSD The price of the asset in USD
119		/// @return isDepeg True if the token is depegged
120	0	function _isTokenDepeg(
121		uint256 priceUSD,
122		uint256 precision,
123		uint256 assetPriceUSD,
124		uint256 depegLowerThreshold,
125		uint256 depegUpperThreshold
126		)
127		internal
128		pure
129	0	returns (bool isDepeg)
130	0	{
131		// NOTE: There should be no need to adjust for decimals since
132		// the token specific decimals and
133		// the Oracle Price decimals
134		// can be different
135		// Example, if we send 2 USDC to someone then the transferred amount is 2e6 since USDC has 6d
136		// but the USDC price quoted in USD can have its own decimals, for example
137		// if USDC depegs high and is worth 3 USD then its price quoted in a 18d oracle will be 3e18
138	0	uint256 ratio = Math.mulDiv(priceUSD, precision, assetPriceUSD);
139
140	0	if (ratio < depegLowerThreshold \|\| ratio > depegUpperThreshold) {
141	0	isDepeg = true;
142		}
143		}
144
145		/// @dev Gets the price information for a token
146		/// @param superOracle The super oracle
147		/// @param superAsset The super asset
148		/// @param USD The USD address
149		/// @param token The token address
150		/// @return priceUSD The price of the token in USD
151		/// @return stddev The standard deviation of the token
152	0	function _getPriceInfo(
153		ISuperOracle superOracle,
154		ISuperAsset superAsset,
155		address USD,
156		address token
157		)
158		internal
159		view
160	0	returns (uint256 priceUSD, uint256 stddev, uint256 M)
161	0	{
162	0	bytes32 AVERAGE_PROVIDER = keccak256("AVERAGE_PROVIDER");
163	0	uint256 one = 10 ** IERC20Metadata(token).decimals();
164
165	0	ISuperAsset.TokenData memory tokenData = superAsset.getTokenData(token);
166
167	0	if (tokenData.isSupportedERC20) {
168	0	try superOracle.getQuoteFromProvider(one, token, USD, AVERAGE_PROVIDER) returns (
169		uint256 _priceUSD, uint256 _stddev, uint256, uint256 _m
170		) {
171	0	priceUSD = _priceUSD;
172	0	stddev = _stddev;
173	0	M = _m;
174		} catch {
175	0	priceUSD = superOracle.getEmergencyPrice(token);
176	0	M = 0;
177		}
178	0	} else if (tokenData.isSupportedUnderlyingVault) {
179	0	(priceUSD, stddev, M) =
180	0	_derivePriceFromUnderlyingVault(superOracle, superAsset, USD, token, tokenData.oracle);
181		}
182		}
183
184		/// @dev Gets the depeg and dispersion status of a token
185		/// @param args The arguments for the price calculation
186		/// @param precision The precision of the token
187		/// @param priceUSD The price of the token in USD
188		/// @param stddev The standard deviation of the token
189		/// @return isDepeg True if the token is depegged
190		/// @return isDispersion True if the token has price dispersion
191	0	function _getDepegAndDispersion(
192		ISuperAsset.PriceArgs memory args,
193		uint256 precision,
194		uint256 priceUSD,
195		uint256 stddev
196		)
197		internal
198		view
199	0	returns (bool isDepeg, bool isDispersion)
200	0	{
201	0	uint256 assetPriceUSD = _getAssetPriceUSD(args.superOracle, args.superAsset, args.usd);
202
203	0	isDepeg = _isTokenDepeg(priceUSD, precision, assetPriceUSD, args.depegLowerThreshold, args.depegUpperThreshold);
204
205	0	isDispersion = _isSTDDevDegged(args.superAsset, stddev, priceUSD, args.dispersionThreshold);
206		}
207
208		/// @dev Gets the price of the asset in USD
209		/// @param superOracleAddress The address of the super oracle
210		/// @param superAssetAddress The address of the super asset
211		/// @param USD The address of the USD token
212		/// @return assetPriceUSD The price of the asset in USD
213	0	function _getAssetPriceUSD(
214		address superOracleAddress,
215		address superAssetAddress,
216		address USD
217		)
218		internal
219		view
220	0	returns (uint256 assetPriceUSD)
221	0	{
222	0	bytes32 AVERAGE_PROVIDER = keccak256("AVERAGE_PROVIDER");
223	0	address primaryAsset = ISuperAsset(superAssetAddress).getPrimaryAsset();
224	0	uint256 oneUnitAsset = 10 ** IERC20Metadata(primaryAsset).decimals();
225
226	0	ISuperOracle superOracle = ISuperOracle(superOracleAddress);
227
228	0	try superOracle.getQuoteFromProvider(oneUnitAsset, primaryAsset, USD, AVERAGE_PROVIDER) returns (
229		uint256 _priceUSD, uint256, uint256, uint256
230		) {
231	0	assetPriceUSD = _priceUSD;
232		} catch {
233	0	assetPriceUSD = superOracle.getEmergencyPrice(primaryAsset);
234		}
235		}
236		}

1		// SPDX-License-Identifier: UNLICENSED
2		// With thanks to @BoringCrypto
3		pragma solidity >=0.8.19;
4
5		import { IERC20 } from "forge-std/interfaces/IERC20.sol";
6
7		// solhint-disable avoid-low-level-calls
8
9	0	library BoringERC20 {
10		bytes4 private constant SIG_DECIMALS = 0x313ce567; // decimals()
11
12		/// @notice Provides a safe ERC20.decimals version which returns '18' as fallback value.
13		/// @param token The address of the ERC-20 token contract.
14		/// @return (uint8) Token decimals.
15	0	function safeDecimals(IERC20 token) internal view returns (uint8) {
16	0	(bool success, bytes memory data) = address(token).staticcall(abi.encodeWithSelector(SIG_DECIMALS));
17	0	return success && data.length == 32 ? abi.decode(data, (uint8)) : 18;
18		}
19		}

1		// SPDX-License-Identifier: GPL-2.0
2		pragma solidity ^0.8.0;
3
4		import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
5		import {IERC4626} from "@openzeppelin/contracts/interfaces/IERC4626.sol";
6		import {MockERC20} from "@recon/MockERC20.sol";
7
8		import {ISuperVaultStrategy} from "src/interfaces/SuperVault/ISuperVaultStrategy.sol";
9
10		import {Setup} from "./Setup.sol";
11
12		enum OpType {
13		DEFAULT,
14		ADD,
15		REMOVE,
16		FULFILL,
17		REQUEST,
18		TRANSFER,
19		CANCEL
20		}
21
22		// ghost variables for tracking state variable values before and after function calls
23		abstract contract BeforeAfter is Setup {
24		struct Vars {
25		mapping(address user => uint256 pendingAsAssets) pendingUserAssets;
26		mapping(address user => uint256 claimableAsAssets) claimableUserAssets;
27		mapping(address user => ISuperVaultStrategy.SuperVaultState) state;
28		mapping(address user => uint256 shares) superVaultShares;
29		uint256 oraclePPS;
30		uint256 naivePPS;
31		uint256 summedTotalShares;
32		uint256 summedAccumulatorShares;
33		uint256 summedAccumulatorCostBasis;
34		uint256 summedTotalAssets;
35		uint256 strategyAssetBalance;
36		uint256 summedPendingRedeem;
37		}
38
39		Vars internal _before;
40		Vars internal _after;
41		OpType internal _currentOp;
42
43		modifier updateGhosts() {
44	18×	_currentOp = OpType.DEFAULT;
45	12×	__before();
46		_;
47	6×	__after();
48		}
49
50		modifier updateGhostsWithOpType(OpType op) {
51	90×	_currentOp = op;
52	36×	__before();
53		_;
54	17×	__after();
55		}
56
57	2×	function __before() internal {
58	2×	(
59	1×	_before.summedAccumulatorShares,
60	1×	_before.summedAccumulatorCostBasis
61	4×	) = _sumSuperVaultValues();
62	6×	_before.naivePPS = _calculateNaivePPS();
63	6×	_before.summedTotalShares = _sumTotalShares();
64	6×	_before.summedTotalAssets = _sumStrategyAssets();
65	6×	_before.summedPendingRedeem = _sumRequestedRedemptions();
66
67	22×	_before.pendingUserAssets[_getActor()] = _getPendingAsAssets();
68	27×	_before.claimableUserAssets[_getActor()] = _getClaimableAsAssets();
69	128×	_before.state[_getActor()] = superVaultStrategy.getSuperVaultState(
70	2×	_getActor()
71		);
72	81×	_before.superVaultShares[_getActor()] = superVault.balanceOf(
73	2×	_getActor()
74		);
75
76	125×	_before.strategyAssetBalance = MockERC20(superVault.asset()).balanceOf(
77	5×	address(superVaultStrategy)
78		);
79	60×	_before.oraclePPS = superVaultAggregator.getPPS(
80	5×	address(superVaultStrategy)
81		);
82		}
83
84	4×	function __after() internal {
85	4×	(
86	2×	_after.summedAccumulatorShares,
87	2×	_after.summedAccumulatorCostBasis
88	8×	) = _sumSuperVaultValues();
89	12×	_after.naivePPS = _calculateNaivePPS();
90	12×	_after.summedTotalShares = _sumTotalShares();
91	12×	_after.summedTotalAssets = _sumStrategyAssets();
92	12×	_after.summedPendingRedeem = _sumRequestedRedemptions();
93
94	44×	_after.pendingUserAssets[_getActor()] = _getPendingAsAssets();
95	54×	_after.claimableUserAssets[_getActor()] = _getClaimableAsAssets();
96	256×	_after.state[_getActor()] = superVaultStrategy.getSuperVaultState(
97	4×	_getActor()
98		);
99	162×	_after.superVaultShares[_getActor()] = superVault.balanceOf(
100	4×	_getActor()
101		);
102
103	252×	_after.strategyAssetBalance = MockERC20(superVault.asset()).balanceOf(
104	10×	address(superVaultStrategy)
105		);
106	118×	_after.oraclePPS = superVaultAggregator.getPPS(
107	10×	address(superVaultStrategy)
108		);
109		}
110
111		// Helpers
112
113		/// @dev total shares in the system is the sum of shares in the escrow and held by all users
114	4×	function _sumTotalShares() internal returns (uint256) {
115	14×	address[] memory actors = _getActors();
116	4×	uint256 totalShares;
117
118	142×	totalShares += superVault.balanceOf(address(superVaultEscrow));
119	26×	for (uint256 i; i < actors.length; i++) {
120	182×	totalShares += superVault.balanceOf(actors[i]);
121		}
122
123		return totalShares;
124		}
125
126		/// @notice Calculates the naive price per share by summing all assets across strategy and yield sources
127		/// @dev inspired by the share price calculation from BaseSuperVaultTest::_updateSuperVaultPPS
128		/// @return naivePPS The calculated price per share (scaled by 1e18)
129	8×	function _calculateNaivePPS() internal returns (uint256 naivePPS) {
130		// Get total supply of SuperVault shares
131	140×	uint256 totalSupply = superVault.totalSupply();
132
133		// If no shares exist, PPS is 0
134	12×	if (totalSupply == 0) {
135	8×	return 0;
136		}
137
138		// Calculate total assets across all locations
139	14×	uint256 totalAssets = _sumStrategyAssets();
140
141		// Calculate naive PPS: (totalAssets * PRECISION) / totalSupply
142		// Using 1e18 as precision to match the system's PPS_DECIMALS
143	158×	naivePPS = (totalAssets * superVault.PRECISION()) / totalSupply;
144
145		return naivePPS;
146		}
147
148	22×	function _sumStrategyAssets() public view returns (uint256) {
149		// Get the underlying asset
150	140×	address asset = superVault.asset();
151
152	4×	uint256 totalAssets;
153		// 1. Assets held directly in SuperVaultStrategy
154	140×	totalAssets += IERC20(asset).balanceOf(address(superVaultStrategy));
155
156		// 2. Loop through all yield sources and sum underlying asset balances
157	12×	address[] memory yieldSources = _getYieldSources();
158	28×	for (uint256 i = 0; i < yieldSources.length; i++) {
159	44×	if (yieldSources[i] != address(0)) {
160		// Get the underlying asset balance held in each yield source
161	170×	totalAssets += IERC20(asset).balanceOf(yieldSources[i]);
162		}
163		}
164
165	4×	return totalAssets;
166		}
167
168	8×	function _sumSuperVaultValues()
169		internal
170		view
171	4×	returns (uint256 sumAccumulatorShares, uint256 sumAccumulatorCostBasis)
172	2×	{
173	14×	address[] memory actors = _getActors();
174
175	30×	for (uint256 i; i < actors.length; i++) {
176	156×	sumAccumulatorShares += superVaultStrategy
177	34×	.getSuperVaultState(actors[i])
178		.accumulatorShares;
179	150×	sumAccumulatorCostBasis += superVaultStrategy
180	34×	.getSuperVaultState(actors[i])
181		.accumulatorCostBasis;
182		}
183		}
184
185	4×	function _sumRequestedRedemptions() internal returns (uint256) {
186	14×	address[] memory actors = _getActors();
187	2×	uint256 totalRequested;
188	26×	for (uint256 i; i < actors.length; i++) {
189	192×	totalRequested += superVault.pendingRedeemRequest(0, actors[i]);
190		}
191
192		return totalRequested;
193		}
194
195	12×	function _getPendingAsAssets() internal returns (uint256) {
196	136×	uint256 pendingRedemptions = superVault.pendingRedeemRequest(
197		0,
198	4×	_getActor()
199		);
200	120×	uint256 pendingRedemptionsAsAssets = superVault.convertToAssets(
201		pendingRedemptions
202		);
203
204		return pendingRedemptionsAsAssets;
205		}
206
207	12×	function _getClaimableAsAssets() internal returns (uint256) {
208	8×	uint256 claimableRedemptions = superVault.claimableRedeemRequest(
209		0,
210	2×	_getActor()
211		);
212		uint256 claimableRedemptionsAsAssets = superVault.convertToAssets(
213		claimableRedemptions
214		);
215
216		return claimableRedemptionsAsAssets;
217		}
218		}

1		// SPDX-License-Identifier: GPL-2.0
2		pragma solidity ^0.8.0;
3
4		import {CryticAsserts} from "@chimera/CryticAsserts.sol";
5
6		import {TargetFunctions} from "./TargetFunctions.sol";
7
8		// echidna test/recon/CryticTester.sol --contract CryticTester --config echidna.yaml --format text --test-limit 1000000 --disable-slither
9		// medusa fuzz
10	2116×	contract CryticTester is TargetFunctions, CryticAsserts {
11		constructor() payable {
12	4×	setup();
13		}
14		}

1		// SPDX-License-Identifier: GPL-2.0
2		pragma solidity ^0.8.0;
3
4		// External dependencies
5		import {BaseSetup} from "@chimera/BaseSetup.sol";
6		import {vm} from "@chimera/Hevm.sol";
7		import {ActorManager} from "@recon/ActorManager.sol";
8		import {AssetManager} from "@recon/AssetManager.sol";
9		import {Utils} from "@recon/Utils.sol";
10		// ERC4626 Hooks
11		import {Deposit4626VaultHook} from "lib/v2-core/src/hooks/vaults/4626/Deposit4626VaultHook.sol";
12		import {ApproveAndDeposit4626VaultHook} from "lib/v2-core/src/hooks/vaults/4626/ApproveAndDeposit4626VaultHook.sol";
13		import {Redeem4626VaultHook} from "lib/v2-core/src/hooks/vaults/4626/Redeem4626VaultHook.sol";
14
15		// ERC5115 Hooks
16		import {Deposit5115VaultHook} from "lib/v2-core/src/hooks/vaults/5115/Deposit5115VaultHook.sol";
17		import {ApproveAndDeposit5115VaultHook} from "lib/v2-core/src/hooks/vaults/5115/ApproveAndDeposit5115VaultHook.sol";
18		import {Redeem5115VaultHook} from "lib/v2-core/src/hooks/vaults/5115/Redeem5115VaultHook.sol";
19
20		// ERC7540 Hooks
21		import {Deposit7540VaultHook} from "lib/v2-core/src/hooks/vaults/7540/Deposit7540VaultHook.sol";
22		import {Redeem7540VaultHook} from "lib/v2-core/src/hooks/vaults/7540/Redeem7540VaultHook.sol";
23		import {RequestDeposit7540VaultHook} from "lib/v2-core/src/hooks/vaults/7540/RequestDeposit7540VaultHook.sol";
24		import {RequestRedeem7540VaultHook} from "lib/v2-core/src/hooks/vaults/7540/RequestRedeem7540VaultHook.sol";
25		import {ApproveAndRequestDeposit7540VaultHook} from "lib/v2-core/src/hooks/vaults/7540/ApproveAndRequestDeposit7540VaultHook.sol";
26		import {CancelDepositRequest7540Hook} from "lib/v2-core/src/hooks/vaults/7540/CancelDepositRequest7540Hook.sol";
27		import {CancelRedeemRequest7540Hook} from "lib/v2-core/src/hooks/vaults/7540/CancelRedeemRequest7540Hook.sol";
28		import {ClaimCancelDepositRequest7540Hook} from "lib/v2-core/src/hooks/vaults/7540/ClaimCancelDepositRequest7540Hook.sol";
29		import {ClaimCancelRedeemRequest7540Hook} from "lib/v2-core/src/hooks/vaults/7540/ClaimCancelRedeemRequest7540Hook.sol";
30		import {Withdraw7540VaultHook} from "lib/v2-core/src/hooks/vaults/7540/Withdraw7540VaultHook.sol";
31
32		// Super Vault Hooks
33		import {CancelRedeemHook} from "lib/v2-core/src/hooks/vaults/super-vault/CancelRedeemHook.sol";
34		import {Withdraw7540VaultHook as SuperVaultWithdraw7540VaultHook} from "lib/v2-core/src/hooks/vaults/super-vault/Withdraw7540VaultHook.sol";
35
36		// Source dependencies
37		import "src/SuperVault/SuperVault.sol";
38		import "src/SuperVault/SuperVaultAggregator.sol";
39		import "src/SuperVault/SuperVaultEscrow.sol";
40		import "src/SuperVault/SuperVaultStrategy.sol";
41		import "src/SuperGovernor.sol";
42		import {ISuperVaultAggregator} from "src/interfaces/SuperVault/ISuperVaultAggregator.sol";
43		import {ISuperVaultStrategy} from "src/interfaces/SuperVault/ISuperVaultStrategy.sol";
44		import {MockYieldSourceOracle} from "test/mocks/MockYieldSourceOracle.sol";
45
46		// Test suite dependencies
47		import {YieldManager, YieldSourceType} from "test/recon/managers/YieldManager.sol";
48		import {MerkleTestHelper} from "test/recon/helpers/MerkleTestHelper.sol";
49		import {UnsafeSuperVaultAggregator} from "test/recon/helpers/UnsafeSuperVaultAggregator.sol";
50		import {MockERC4626YieldSourceOracle} from "test/recon/mocks/MockERC4626YieldSourceOracle.sol";
51		import {MockERC5115YieldSourceOracle} from "test/recon/mocks/MockERC5115YieldSourceOracle.sol";
52		import {MockERC7540YieldSourceOracle} from "test/recon/mocks/MockERC7540YieldSourceOracle.sol";
53		import {MockECDSAPPSOracle} from "test/recon/mocks/MockECDSAPPSOracle.sol";
54
55		abstract contract Setup is
56		BaseSetup,
57		ActorManager,
58		AssetManager,
59		YieldManager,
60		Utils
61		{
62		// Configuration constants
63	2×	uint8 internal constant DECIMALS = 18;
64		address asset;
65	9×	address feeRecipient = address(0xbeef);
66
67		// Core contracts
68		SuperGovernor superGovernor;
69		SuperVault superVault;
70		UnsafeSuperVaultAggregator superVaultAggregator;
71		SuperVaultEscrow superVaultEscrow;
72		SuperVaultStrategy superVaultStrategy;
73
74		// Implementation contracts for aggregator
75		SuperVault vaultImpl;
76		SuperVaultStrategy strategyImpl;
77		SuperVaultEscrow escrowImpl;
78
79		// Helpers
80		MerkleTestHelper merkleHelper;
81
82		// ERC4626 Hooks
83		ApproveAndDeposit4626VaultHook approveAndDeposit4626Hook;
84		Deposit4626VaultHook deposit4626Hook;
85		Redeem4626VaultHook redeem4626Hook;
86
87		// ERC5115 Hooks
88		ApproveAndDeposit5115VaultHook approveAndDeposit5115Hook;
89		Deposit5115VaultHook deposit5115Hook;
90		Redeem5115VaultHook redeem5115Hook;
91
92		// ERC7540 Hooks
93		Deposit7540VaultHook deposit7540Hook;
94		Redeem7540VaultHook redeem7540Hook;
95		RequestDeposit7540VaultHook requestDeposit7540Hook;
96		RequestRedeem7540VaultHook requestRedeem7540Hook;
97		ApproveAndRequestDeposit7540VaultHook approveAndRequestDeposit7540Hook;
98		CancelDepositRequest7540Hook cancelDepositRequest7540Hook;
99		CancelRedeemRequest7540Hook cancelRedeemRequest7540Hook;
100		ClaimCancelDepositRequest7540Hook claimCancelDepositRequest7540Hook;
101		ClaimCancelRedeemRequest7540Hook claimCancelRedeemRequest7540Hook;
102		Withdraw7540VaultHook withdraw7540Hook;
103
104		// Super Vault Hooks
105		CancelRedeemHook cancelRedeemHook;
106		SuperVaultWithdraw7540VaultHook superVaultWithdraw7540Hook;
107
108		// Mocks
109		MockERC4626YieldSourceOracle erc4626YieldSourceOracle;
110		MockERC5115YieldSourceOracle erc5115YieldSourceOracle;
111		MockERC7540YieldSourceOracle erc7540YieldSourceOracle;
112		MockECDSAPPSOracle ECDSAPPSOracle;
113
114		// Yield sources for different standards
115		address erc4626YieldSource;
116		address erc5115YieldSource;
117		address erc7540YieldSource;
118
119		// Ghosts
120		bool hasUpdatedPPS;
121		int256 burnedMoreThanRequested;
122		int256 burnedLessThanRequested;
123		int256 previewMintSharesGreater; // setPreviewSharesGreater
124		int256 previewDepositSharesGreater; // setPreviewSharesGreater
125		int256 previewMintAssetsGreater; // setpreviewAssetsGreater
126		int256 previewDepositAssetsGreater; // setpreviewAssetsGreater
127
128		// Canaries
129		bool executeHooksClampedSuccess;
130		bool executeHooksSuccess;
131		bool fulfillRedeemRequestsSuccess;
132		bool hasDeployedNewVault;
133
134		/// === MODIFIERS === ///
135		/// Prank admin and actor
136
137		modifier asAdmin() {
138	632×	vm.prank(address(this));
139		_;
140		}
141
142		modifier asActor() {
143	2519×	vm.prank(address(_getActor()));
144		_;
145		}
146
147		/// Makes a handler have no side effects
148		/// The fuzzer will call this anyway, and because it reverts it will be removed from shrinking
149		/// Replace the "withGhosts" with "stateless" to make the code clean
150		///
151		/// Under Foundry with `assertions_revert = false` a failing t()/vm.assert* only records a
152		/// journaled write to the global fail slot, which the trailing revert would erase — making
153		/// every stateless assertion property invisible to the Foundry leg. Re-raise a failure
154		/// recorded during this call as Panic(0x01), which Foundry classifies as an assertion
155		/// failure; under echidna/medusa/recon a failing t() already reverted with Panic before
156		/// reaching this point, so the extra check never fires there.
157		modifier stateless() {
158	117×	bool preFailed = _foundryFailSlotSet();
159		_;
160	55×	if (!preFailed && _foundryFailSlotSet()) assert(false);
161	15×	revert("stateless");
162		}
163
164		// bytes32("failed") — Foundry's GLOBAL_FAIL_SLOT on the cheatcode address, written
165		// (journaled sstore of 1) by non-reverting vm.assert* failures.
166		bytes32 internal constant _FOUNDRY_FAIL_SLOT =
167		0x6661696c65640000000000000000000000000000000000000000000000000000;
168
169		/// Probes the Foundry fail slot with a raw staticcall so fuzzers without the `load`
170		/// cheatcode simply report "not set" instead of reverting.
171	8×	function _foundryFailSlotSet() internal view returns (bool) {
172	79×	(bool ok, bytes memory ret) = address(vm).staticcall(
173	70×	abi.encodeWithSignature("load(address,bytes32)", address(vm), _FOUNDRY_FAIL_SLOT)
174		);
175	47×	return ok && ret.length >= 32 && abi.decode(ret, (bytes32)) != bytes32(0);
176		}
177
178		/// === Setup === ///
179		/// This contains all calls to be performed in the tester constructor, both for Echidna and Foundry
180	8×	function setup() internal virtual override {
181		// 1. Add additional actors
182	5×	_addActor(address(0x100)); // Actor 1
183	5×	_addActor(address(0x200)); // Actor 2
184
185		// 2. Create assets using AssetManager
186	4×	_newAsset(DECIMALS); // Deploy token with 18 decimals
187	4×	_newAsset(DECIMALS); // UP token
188
189	5×	_switchAsset(0);
190
191		// 3. Deploy all three types of yield sources using YieldManager
192		// Deploy ERC4626 yield source (default)
193	18×	erc4626YieldSource = _newYieldSource(
194	4×	_getAsset(),
195	1×	YieldSourceType.ERC4626
196		);
197
198		// Deploy ERC5115 yield source
199	18×	erc5115YieldSource = _newYieldSource(
200	4×	_getAsset(),
201	1×	YieldSourceType.ERC5115
202		);
203
204		// Deploy ERC7540 yield source
205	18×	erc7540YieldSource = _newYieldSource(
206	4×	_getAsset(),
207	1×	YieldSourceType.ERC7540
208		);
209
210		// Set ERC4626 as the default active yield source
211	4×	_switchYieldSource(0); // Switch to first yield source in the array (ERC4626)
212
213		// 4. Deploy SuperGovernor first (required by other contracts)
214	35×	superGovernor = new SuperGovernor(
215	1×	address(this), // superGovernor role
216	1×	address(this), // governor role
217	1×	address(this), // bankManager role
218	1×	address(this), // gasManager role
219	10×	feeRecipient, // treasury
220	1×	address(this) // prover
221		);
222
223		// 5. Deploy implementation contracts for the aggregator
224	32×	vaultImpl = new SuperVault(address(superGovernor));
225	41×	strategyImpl = new SuperVaultStrategy(address(superGovernor));
226	35×	escrowImpl = new SuperVaultEscrow();
227
228		// 6. Deploy SuperVaultAggregator with implementation contracts
229	32×	superVaultAggregator = new UnsafeSuperVaultAggregator(
230	6×	address(superGovernor),
231	6×	address(vaultImpl),
232	5×	address(strategyImpl),
233		address(escrowImpl)
234		);
235
236		// 7. Register the SuperVaultAggregator and UpToken address with SuperGovernor
237	54×	superGovernor.setAddress(
238	59×	superGovernor.SUPER_VAULT_AGGREGATOR(),
239	3×	address(superVaultAggregator)
240		);
241
242	11×	address[] memory assets = _getAssets();
243	128×	superGovernor.setAddress(superGovernor.UP(), assets[1]); // the second deployed token in the AssetManager is the UPToken
244	114×	superGovernor.setAddress(superGovernor.SUPER_BANK(), address(this));
245
246		// 8. Deploy Mocks and Oracles
247
248		// Deploy specific oracles for each yield source type
249	36×	erc4626YieldSourceOracle = new MockERC4626YieldSourceOracle();
250	36×	erc5115YieldSourceOracle = new MockERC5115YieldSourceOracle();
251	36×	erc7540YieldSourceOracle = new MockERC7540YieldSourceOracle();
252	35×	ECDSAPPSOracle = new MockECDSAPPSOracle();
253
254		// ECDSAPPSOracle setup
255	41×	superGovernor.setActivePPSOracle(address(ECDSAPPSOracle));
256	49×	ECDSAPPSOracle.setSUPER_GOVERNORReturn(address(superVaultAggregator));
257
258		// Set valid assets for all oracles
259	21×	asset = _getAsset();
260	41×	erc4626YieldSourceOracle.setValidAsset(asset, true);
261	46×	erc5115YieldSourceOracle.setValidAsset(asset, true);
262	50×	erc7540YieldSourceOracle.setValidAsset(asset, true);
263
264		// 9. Create a vault trio using the aggregator
265	5×	ISuperVaultAggregator.VaultCreationParams
266	85×	memory params = ISuperVaultAggregator.VaultCreationParams({
267	8×	asset: _getAsset(), // Use the token created by AssetManager
268		name: "SuperVault",
269		symbol: "SV",
270	1×	mainManager: address(this), // CONFIGURABLE: This parameter can be modified via target functions
271	27×	secondaryManagers: new address[](0), // CONFIGURABLE: This parameter can be modified via target functions
272	1×	minUpdateInterval: 5, // CONFIGURABLE: This parameter can be modified via target functions
273	1×	maxStaleness: 300, // CONFIGURABLE: This parameter can be modified via target functions
274	20×	feeConfig: ISuperVaultStrategy.FeeConfig({
275	1×	performanceFeeBps: 1000, // 10% performance fee
276	1×	managementFeeBps: 100, // 1% management fee
277	5×	recipient: feeRecipient
278		})
279		});
280
281	5×	(
282		address vaultAddr,
283		address strategyAddr,
284		address escrowAddr
285	62×	) = superVaultAggregator.createVault(params);
286
287		// 10. Store the deployed contracts
288	13×	superVault = SuperVault(vaultAddr);
289	12×	superVaultStrategy = SuperVaultStrategy(payable(strategyAddr));
290	16×	superVaultEscrow = SuperVaultEscrow(escrowAddr);
291
292		/// 11. Deploy all hook contracts and helper
293	36×	merkleHelper = new MerkleTestHelper();
294
295		// Deploy ERC4626 Hooks
296	36×	approveAndDeposit4626Hook = new ApproveAndDeposit4626VaultHook();
297	36×	deposit4626Hook = new Deposit4626VaultHook();
298	36×	redeem4626Hook = new Redeem4626VaultHook();
299
300		// Deploy ERC5115 Hooks
301	36×	approveAndDeposit5115Hook = new ApproveAndDeposit5115VaultHook();
302	36×	deposit5115Hook = new Deposit5115VaultHook();
303	36×	redeem5115Hook = new Redeem5115VaultHook();
304
305		// Deploy ERC7540 Hooks
306	36×	deposit7540Hook = new Deposit7540VaultHook();
307	36×	redeem7540Hook = new Redeem7540VaultHook();
308	36×	requestDeposit7540Hook = new RequestDeposit7540VaultHook();
309	36×	requestRedeem7540Hook = new RequestRedeem7540VaultHook();
310	36×	approveAndRequestDeposit7540Hook = new ApproveAndRequestDeposit7540VaultHook();
311	36×	cancelDepositRequest7540Hook = new CancelDepositRequest7540Hook();
312	36×	cancelRedeemRequest7540Hook = new CancelRedeemRequest7540Hook();
313	36×	claimCancelDepositRequest7540Hook = new ClaimCancelDepositRequest7540Hook();
314	36×	claimCancelRedeemRequest7540Hook = new ClaimCancelRedeemRequest7540Hook();
315	36×	withdraw7540Hook = new Withdraw7540VaultHook();
316
317		// Deploy Super Vault Hooks
318	36×	cancelRedeemHook = new CancelRedeemHook();
319	32×	superVaultWithdraw7540Hook = new SuperVaultWithdraw7540VaultHook();
320
321		// Register all hooks with SuperGovernor
322		// ERC4626 Hooks (deposit hooks are regular hooks, redeem hooks are fulfill request hooks)
323	45×	superGovernor.registerHook(address(approveAndDeposit4626Hook), false);
324	46×	superGovernor.registerHook(address(deposit4626Hook), false);
325	46×	superGovernor.registerHook(address(redeem4626Hook), true); // fulfill request hook
326
327		// ERC5115 Hooks
328	46×	superGovernor.registerHook(address(approveAndDeposit5115Hook), false);
329	46×	superGovernor.registerHook(address(deposit5115Hook), false);
330	46×	superGovernor.registerHook(address(redeem5115Hook), true); // fulfill request hook
331
332		// ERC7540 Hooks (deposit/request hooks are regular hooks, redeem/withdraw hooks are fulfill request hooks)
333	46×	superGovernor.registerHook(address(deposit7540Hook), false);
334	46×	superGovernor.registerHook(address(redeem7540Hook), true); // fulfill request hook
335	46×	superGovernor.registerHook(address(requestDeposit7540Hook), false);
336	46×	superGovernor.registerHook(address(requestRedeem7540Hook), false);
337	41×	superGovernor.registerHook(
338	5×	address(approveAndRequestDeposit7540Hook),
339		false
340		);
341	41×	superGovernor.registerHook(
342	5×	address(cancelDepositRequest7540Hook),
343		false
344		);
345	46×	superGovernor.registerHook(address(cancelRedeemRequest7540Hook), false);
346	41×	superGovernor.registerHook(
347	5×	address(claimCancelDepositRequest7540Hook),
348		false
349		);
350	41×	superGovernor.registerHook(
351	5×	address(claimCancelRedeemRequest7540Hook),
352		false
353		);
354	46×	superGovernor.registerHook(address(withdraw7540Hook), true); // fulfill request hook
355
356		// Super Vault Hooks
357	48×	superGovernor.registerHook(address(cancelRedeemHook), false);
358	46×	superGovernor.registerHook(address(superVaultWithdraw7540Hook), true); // fulfill request hook
359
360		// 12. Set up approval array for contracts that need token access
361	44×	address[] memory approvalArray = new address[](6);
362	24×	approvalArray[0] = address(superVault);
363	29×	approvalArray[1] = address(superVaultStrategy);
364	29×	approvalArray[2] = address(superVaultAggregator);
365	29×	approvalArray[3] = erc4626YieldSource;
366	29×	approvalArray[4] = erc5115YieldSource;
367	31×	approvalArray[5] = erc7540YieldSource;
368
369		// 13. Finalize asset deployment (mints to actors and sets approvals)
370	9×	_finalizeAssetDeployment(_getActors(), approvalArray, type(uint88).max);
371		}
372
373		/// Get hook addresses for different yield source types
374
375	4×	function _getApproveAndDepositHookForType(
376		YieldSourceType sourceType
377	2×	) internal view returns (address) {
378	12×	if (sourceType == YieldSourceType.ERC4626) {
379	4×	return address(approveAndDeposit4626Hook);
380	13×	} else if (sourceType == YieldSourceType.ERC5115) {
381	4×	return address(approveAndDeposit5115Hook);
382	12×	} else if (sourceType == YieldSourceType.ERC7540) {
383	4×	return address(approveAndRequestDeposit7540Hook);
384		}
385		return address(0);
386		}
387
388	8×	function _getRedeemHookForType(
389		YieldSourceType sourceType
390	4×	) internal view returns (address) {
391	24×	if (sourceType == YieldSourceType.ERC4626) {
392	8×	return address(redeem4626Hook);
393	26×	} else if (sourceType == YieldSourceType.ERC5115) {
394	8×	return address(redeem5115Hook);
395	24×	} else if (sourceType == YieldSourceType.ERC7540) {
396	8×	return address(redeem7540Hook);
397		}
398	0	return address(0);
399		}
400
401		/// Get oracle addresses for different yield source types
402
403	8×	function _getYieldSourceOracleForType(
404		YieldSourceType sourceType
405	2×	) internal view returns (address) {
406	12×	if (sourceType == YieldSourceType.ERC4626) {
407	4×	return address(erc4626YieldSourceOracle);
408	13×	} else if (sourceType == YieldSourceType.ERC5115) {
409	4×	return address(erc5115YieldSourceOracle);
410	13×	} else if (sourceType == YieldSourceType.ERC7540) {
411	4×	return address(erc7540YieldSourceOracle);
412		}
413		}
414
415		/// @dev Helper function to determine yield source type from address
416	18×	function _getYieldSourceTypeFromAddress(
417		address yieldSource
418	2×	) internal view returns (YieldSourceType) {
419		// Get all available yield sources from YieldManager
420	12×	address[] memory yieldSources = _getYieldSources();
421
422		// Check which index matches the current yield source
423	28×	for (uint256 i = 0; i < yieldSources.length; i++) {
424	42×	if (yieldSources[i] == yieldSource) {
425		// Return the corresponding type based on creation order:
426		// Index 0: ERC4626, Index 1: ERC5115, Index 2: ERC7540
427	16×	if (i == 0) return YieldSourceType.ERC4626;
428	16×	if (i == 1) return YieldSourceType.ERC5115;
429	16×	if (i == 2) return YieldSourceType.ERC7540;
430		}
431		}
432
433		// Default to ERC4626 if not found
434	4×	return YieldSourceType.ERC4626;
435		}
436
437		function _getERC4626YieldSourceOracle() internal view returns (address) {
438		return address(erc4626YieldSourceOracle);
439		}
440
441		function _getERC5115YieldSourceOracle() internal view returns (address) {
442		return address(erc5115YieldSourceOracle);
443		}
444
445		function _getERC7540YieldSourceOracle() internal view returns (address) {
446		return address(erc7540YieldSourceOracle);
447		}
448
449		// Helpers
450	35×	function _getRandomActor(uint256 entropy) public view returns (address) {
451	14×	address[] memory actors = _getActors();
452
453	52×	return actors[entropy % actors.length];
454		}
455		}

1		// SPDX-License-Identifier: GPL-2.0
2		pragma solidity ^0.8.0;
3
4		import {MerkleProof} from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
5
6		/// @title MerkleTestHelper
7		/// @notice Helper contract for generating test Merkle roots and proofs for hook validation
8	123×	contract MerkleTestHelper {
9		/// @notice Generate a test Merkle root for ERC4626 deposit and redeem hooks
10		/// @param depositHook Address of the Deposit4626VaultHook or ApproveAndDeposit4626VaultHook contract
11		/// @param redeemHook Address of the Redeem4626VaultHook contract
12		/// @param mockVault Address of the mock ERC4626 vault
13		/// @param mockToken Address of the mock token (unused but kept for compatibility)
14		/// @return root The Merkle root for the tree
15		/// @return proofs Array of proofs for each leaf [depositProof, redeemProof]
16	28×	function generateTestHooksRoot(
17		address depositHook,
18		address redeemHook,
19		address mockVault,
20		address mockToken
21	6×	) public pure returns (bytes32 root, bytes32[][] memory proofs) {
22		// Create leaves for the two hooks following the exact format from SuperVaultAggregator._createLeaf()
23	25×	bytes32[] memory leaves = new bytes32[](2);
24
25		// Leaf 1: Deposit hook with yield source only (what inspect() returns)
26		// The inspect() function only returns abi.encodePacked(yieldSource)
27	21×	bytes memory depositArgs = abi.encodePacked(mockVault); // Only yield source address
28	68×	leaves[0] = keccak256(bytes.concat(keccak256(abi.encode(depositHook, depositArgs))));
29
30		// Leaf 2: Redeem hook with yield source only (what inspect() returns)
31		// The inspect() function only returns abi.encodePacked(yieldSource)
32	24×	bytes memory redeemArgs = abi.encodePacked(mockVault); // Only yield source address
33	72×	leaves[1] = keccak256(bytes.concat(keccak256(abi.encode(redeemHook, redeemArgs))));
34
35		// Sort leaves to match standard Merkle tree ordering
36	35×	if (leaves[0] > leaves[1]) {
37	67×	(leaves[0], leaves[1]) = (leaves[1], leaves[0]);
38		}
39
40		// For a 2-leaf tree, root is hash of the sorted leaves
41	59×	root = keccak256(abi.encodePacked(leaves[0], leaves[1]));
42
43		// Store original leaf hashes for proof assignment
44	56×	bytes32 depositLeaf = keccak256(bytes.concat(keccak256(abi.encode(depositHook, depositArgs))));
45	56×	bytes32 redeemLeaf = keccak256(bytes.concat(keccak256(abi.encode(redeemHook, redeemArgs))));
46
47		// Generate proofs for each leaf
48	29×	proofs = new bytes32[][](2);
49	44×	proofs[0] = new bytes32[](1); // Proof for deposit hook
50	45×	proofs[1] = new bytes32[](1); // Proof for redeem hook
51
52		// In a 2-leaf tree, each leaf's proof is just its sibling
53		// Find which position each leaf ended up in after sorting
54	23×	if (leaves[0] == depositLeaf) {
55		// depositHook is first leaf after sorting
56	48×	proofs[0][0] = leaves[1]; // Sibling of deposit leaf
57	48×	proofs[1][0] = leaves[0]; // Sibling of redeem leaf
58		} else {
59		// redeemHook is first leaf after sorting
60	48×	proofs[0][0] = leaves[1]; // Sibling of deposit leaf
61	48×	proofs[1][0] = leaves[0]; // Sibling of redeem leaf
62		}
63
64	5×	return (root, proofs);
65		}
66
67		/// @notice Generate encoded hook arguments for Deposit4626VaultHook
68		/// @param yieldSource Address of the yield source vault
69		/// @param amount Amount to deposit
70		/// @param usePrevHookAmount Whether to use previous hook amount
71		/// @return Encoded hook arguments
72	0	function encodeDepositHookArgs(
73		address yieldSource,
74		uint256 amount,
75		bool usePrevHookAmount
76	0	) public pure returns (bytes memory) {
77	0	return abi.encodePacked(
78	0	bytes32(0), // yieldSourceOracleId placeholder
79		yieldSource,
80		amount,
81		usePrevHookAmount
82		);
83		}
84
85		/// @notice Generate encoded hook arguments for Redeem4626VaultHook
86		/// @param yieldSource Address of the yield source vault
87		/// @param owner Address of the owner
88		/// @param shares Number of shares to redeem
89		/// @param usePrevHookAmount Whether to use previous hook amount
90		/// @return Encoded hook arguments
91	8×	function encodeRedeemHookArgs(
92		address yieldSource,
93		address owner,
94		uint256 shares,
95		bool usePrevHookAmount
96	0	) public pure returns (bytes memory) {
97	0	return abi.encodePacked(
98	0	bytes32(0), // yieldSourceOracleId placeholder
99		yieldSource,
100		owner,
101		shares,
102		usePrevHookAmount
103		);
104		}
105
106		/// @notice Generate encoded hook arguments for ApproveAndDeposit4626VaultHook
107		/// @param yieldSource Address of the yield source vault
108		/// @param token Address of the token to approve and deposit
109		/// @param amount Amount to deposit
110		/// @param usePrevHookAmount Whether to use previous hook amount
111		/// @return Encoded hook arguments
112		function encodeApproveAndDepositHookArgs(
113		address yieldSource,
114		address token,
115		uint256 amount,
116		bool usePrevHookAmount
117		) public pure returns (bytes memory) {
118		return abi.encodePacked(
119		bytes32(0), // yieldSourceOracleId placeholder
120		yieldSource,
121		token,
122		amount,
123		usePrevHookAmount
124		);
125		}
126
127		/// @notice Create a leaf hash for a specific hook and arguments
128		/// @param hookAddress Address of the hook contract
129		/// @param hookArgs Encoded hook arguments
130		/// @return leaf The leaf hash
131	0	function createLeaf(address hookAddress, bytes memory hookArgs) public pure returns (bytes32 leaf) {
132	0	return keccak256(bytes.concat(keccak256(abi.encode(hookAddress, hookArgs))));
133		}
134
135		/// @notice Verify a Merkle proof against a root
136		/// @param proof Array of proof elements
137		/// @param root Merkle root
138		/// @param leaf Leaf to verify
139		/// @return True if proof is valid
140	2×	function verifyProof(bytes32[] memory proof, bytes32 root, bytes32 leaf) public pure returns (bool) {
141	2×	return MerkleProof.verify(proof, root, leaf);
142		}
143		}

1		// SPDX-License-Identifier: UNLICENSED
2		pragma solidity 0.8.30;
3
4		import {SuperVaultAggregator} from "src/SuperVault/SuperVaultAggregator.sol";
5
6		/// @dev inherits from aggregator to override hook validation
7	1173×	contract UnsafeSuperVaultAggregator is SuperVaultAggregator {
8	27×	constructor(
9		address superGovernor_,
10		address vaultImpl_,
11		address strategyImpl_,
12		address escrowImpl_
13		)
14		SuperVaultAggregator(
15	1×	superGovernor_,
16	1×	vaultImpl_,
17	1×	strategyImpl_,
18	1×	escrowImpl_
19		)
20		{}
21
22	26×	function validateHook(
23		address strategy,
24		ValidateHookArgs calldata args
25		) external view override returns (bool isValid) {
26	2×	return true;
27		}
28		}

1		// SPDX-License-Identifier: MIT
2		// Heavily inspired by https://github.com/liquity/V2-gov/blob/9632de9a988522775336d9b60cdf2542efc600db/test/mocks/MaliciousInitiative.sol
3		pragma solidity ^0.8.0;
4
5		import {MockERC20} from "@recon/MockERC20.sol";
6
7		abstract contract ERC4626 is MockERC20 {
8	18×	MockERC20 public immutable asset;
9
10		event Deposit(
11		address indexed caller,
12		address indexed owner,
13		uint256 assets,
14		uint256 shares
15		);
16		event Withdraw(
17		address indexed caller,
18		address indexed receiver,
19		address indexed owner,
20		uint256 assets,
21		uint256 shares
22		);
23
24	1×	constructor(MockERC20 _asset) MockERC20("MockERC4626Tester", "MCT", 18) {
25	5×	asset = _asset;
26		}
27
28	3×	function deposit(
29		uint256 assets,
30		address receiver
31	3×	) public virtual returns (uint256) {
32	24×	uint256 shares = previewDeposit(assets);
33	21×	_deposit(msg.sender, receiver, assets, shares);
34		return shares;
35		}
36
37	2×	function mint(
38		uint256 shares,
39		address receiver
40	2×	) public virtual returns (uint256) {
41	16×	uint256 assets = previewMint(shares);
42	14×	_deposit(msg.sender, receiver, assets, shares);
43		return assets;
44		}
45
46		function withdraw(
47		uint256 assets,
48		address receiver,
49		address owner
50		) public virtual returns (uint256) {
51		uint256 shares = previewWithdraw(assets);
52		_withdraw(msg.sender, receiver, owner, assets, shares);
53		return shares;
54		}
55
56		function redeem(
57		uint256 shares,
58		address receiver,
59		address owner
60		) public virtual returns (uint256) {
61		uint256 assets = previewRedeem(shares);
62		_withdraw(msg.sender, receiver, owner, assets, shares);
63		return assets;
64		}
65
66	80×	function totalAssets() public view virtual returns (uint256) {
67	295×	return asset.balanceOf(address(this));
68		}
69
70	25×	function convertToShares(
71		uint256 assets
72	10×	) public view virtual returns (uint256) {
73	10×	uint256 supply = totalSupply;
74	65×	return supply == 0 ? assets : (assets * supply) / totalAssets();
75		}
76
77	14×	function convertToAssets(
78		uint256 shares
79	8×	) public view virtual returns (uint256) {
80	8×	uint256 supply = totalSupply;
81	121×	return supply == 0 ? shares : (shares * totalAssets()) / supply;
82		}
83
84	5×	function previewDeposit(
85		uint256 assets
86	5×	) public view virtual returns (uint256) {
87	20×	return convertToShares(assets);
88		}
89
90		function previewMint(uint256 shares) public view virtual returns (uint256) {
91		uint256 supply = totalSupply;
92		return supply == 0 ? shares : (shares * totalAssets()) / supply;
93		}
94
95		function previewWithdraw(
96		uint256 assets
97		) public view virtual returns (uint256) {
98		uint256 supply = totalSupply;
99		return supply == 0 ? assets : (assets * supply) / totalAssets();
100		}
101
102	4×	function previewRedeem(
103		uint256 shares
104	4×	) public view virtual returns (uint256) {
105	16×	return convertToAssets(shares);
106		}
107
108	9×	function maxDeposit(address) public view virtual returns (uint256) {
109	1×	return type(uint256).max;
110		}
111
112		function maxMint(address) public view virtual returns (uint256) {
113		return type(uint256).max;
114		}
115
116	12×	function maxWithdraw(address owner) public view virtual returns (uint256) {
117	16×	return convertToAssets(balanceOf[owner]);
118		}
119
120	10×	function maxRedeem(address owner) public view virtual returns (uint256) {
121	12×	return balanceOf[owner];
122		}
123
124	18×	function _deposit(
125		address caller,
126		address receiver,
127		uint256 assets,
128		uint256 shares
129		) internal virtual {
130	191×	asset.transferFrom(caller, address(this), assets);
131	18×	_mint(receiver, shares);
132	63×	emit Deposit(caller, receiver, assets, shares);
133		}
134
135	22×	function _withdraw(
136		address caller,
137		address receiver,
138		address owner,
139		uint256 assets,
140		uint256 shares
141		) internal virtual {
142	32×	if (caller != owner) {
143	80×	allowance[owner][caller] -= shares;
144		}
145	23×	_burn(owner, shares);
146	188×	asset.transfer(receiver, assets);
147	69×	emit Withdraw(caller, receiver, owner, assets, shares);
148		}
149		}
150
151		enum FunctionType {
152		NONE,
153		DEPOSIT,
154		MINT,
155		WITHDRAW,
156		REDEEM
157		}
158
159		enum RevertType {
160		NONE,
161		THROW,
162		OOG,
163		RETURN_BOMB,
164		REVERT_BOMB
165		}
166
167		/// @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
168		/// @dev Note that blindspots not testable with this current implementation are covered in the ERC4626-integrations.md file
169	1098×	contract MockERC4626Tester is ERC4626 {
170	0	mapping(FunctionType => RevertType) public revertBehaviours;
171
172	0	uint8 public decimalsOffset;
173		/// @dev Track total losses
174	0	uint256 public totalLosses;
175	0	uint256 public totalGains;
176	0	uint256 public lossOnWithdraw;
177	3×	uint256 public MAX_BPS = 10_000;
178
179	28×	constructor(address _asset) ERC4626(MockERC20(_asset)) {}
180
181		/// Standard ERC4626 functions ///
182
183		/// @dev Deposit assets, reverts as specified
184	33×	function deposit(
185		uint256 assets,
186		address receiver
187	6×	) public override returns (uint256) {
188	18×	_performRevertBehaviour(revertBehaviours[FunctionType.DEPOSIT]);
189	15×	return super.deposit(assets, receiver);
190		}
191
192		/// @dev Mint shares, reverts as specified
193	22×	function mint(
194		uint256 shares,
195		address receiver
196	4×	) public override returns (uint256) {
197	12×	_performRevertBehaviour(revertBehaviours[FunctionType.MINT]);
198	10×	return super.mint(shares, receiver);
199		}
200
201		/// @dev Withdraw assets, reverts as specified
202	26×	function withdraw(
203		uint256 assets,
204		address receiver,
205		address owner
206	4×	) public override returns (uint256) {
207	12×	_performRevertBehaviour(revertBehaviours[FunctionType.WITHDRAW]);
208
209	16×	uint256 shares = previewWithdraw(assets);
210	52×	uint256 lossyAssets = assets - ((assets * lossOnWithdraw) / MAX_BPS);
211	18×	_withdraw(msg.sender, receiver, owner, lossyAssets, shares);
212
213	2×	return shares;
214		}
215
216		/// @dev Redeem shares, reverts as specified
217	50×	function redeem(
218		uint256 shares,
219		address receiver,
220		address owner
221	8×	) public override returns (uint256) {
222	24×	_performRevertBehaviour(revertBehaviours[FunctionType.REDEEM]);
223
224	32×	uint256 assets = previewRedeem(shares);
225	104×	uint256 lossyAssets = assets - ((assets * lossOnWithdraw) / MAX_BPS);
226	35×	_withdraw(msg.sender, receiver, owner, lossyAssets, shares);
227
228	3×	return lossyAssets;
229		}
230
231		/// @dev Preview deposit, reverts as specified
232	35×	function previewDeposit(
233		uint256 assets
234	10×	) public view override returns (uint256) {
235	30×	_performRevertBehaviour(revertBehaviours[FunctionType.DEPOSIT]);
236	20×	return super.previewDeposit(assets);
237		}
238
239		/// @dev Preview mint, reverts as specified
240	12×	function previewMint(
241		uint256 shares
242	4×	) public view override returns (uint256) {
243	12×	_performRevertBehaviour(revertBehaviours[FunctionType.MINT]);
244	8×	return super.previewMint(shares);
245		}
246
247		/// @dev Preview withdraw, reverts as specified
248	2×	function previewWithdraw(
249		uint256 assets
250	4×	) public view override returns (uint256) {
251	133×	_performRevertBehaviour(revertBehaviours[FunctionType.WITHDRAW]);
252	8×	return super.previewWithdraw(assets);
253		}
254
255		/// @dev Preview redeem, reverts as specified
256	4×	function previewRedeem(
257		uint256 shares
258	8×	) public view override returns (uint256) {
259	24×	_performRevertBehaviour(revertBehaviours[FunctionType.REDEEM]);
260	16×	return super.previewRedeem(shares);
261		}
262
263		/// @dev Revert in different ways to test the revert behaviour
264	15×	function _performRevertBehaviour(RevertType action) internal pure {
265	65×	if (action == RevertType.THROW) {
266	16×	revert("A normal Revert");
267		}
268
269		// 3 gas per iteration, consider changing to storage changes if traces are cluttered
270	65×	if (action == RevertType.OOG) {
271	0	uint256 i;
272	0	while (true) {
273	0	++i;
274		}
275		}
276
277	65×	if (action == RevertType.RETURN_BOMB) {
278	0	uint256 _bytes = 2_000_000;
279		assembly {
280	0	return(0, _bytes)
281		}
282		}
283
284	65×	if (action == RevertType.REVERT_BOMB) {
285	6×	uint256 _bytes = 2_000_000;
286		assembly {
287	2×	revert(0, _bytes)
288		}
289		}
290
291		return; // NONE
292		}
293
294		/// Custom functions for testing vault behavior ///
295
296		/// @dev Specify the revert behavior on each function
297	14×	function setRevertBehavior(FunctionType ft, RevertType rt) public {
298	47×	revertBehaviours[ft] = rt;
299		}
300
301		/// @dev Simulate a loss on the vault's assets
302	11×	function simulateLoss(uint256 lossAmount) external {
303	66×	MockERC20(asset).transfer(address(0xbeef), lossAmount);
304	11×	totalLosses += lossAmount;
305		}
306
307		/// @dev Simulate a gain on the vault's assets (similar to Yearn's profit taking)
308	12×	function simulateGain(uint256 gainAmount) external {
309	67×	MockERC20(asset).transferFrom(msg.sender, address(this), gainAmount);
310	15×	totalGains += gainAmount;
311		}
312
313		/// @dev Set the loss on withdraw as percentage of the assets being withdrawn
314	16×	function setLossOnWithdraw(uint256 _lossOnWithdraw) public {
315	14×	_lossOnWithdraw %= MAX_BPS + 1; // clamp to ensure we set a max of 100%
316	2×	lossOnWithdraw = _lossOnWithdraw;
317		}
318
319		/// @dev Set the decimal offset. Only possible with no supply.
320	12×	function setDecimalsOffset(uint8 targetDecimalsOffset) external {
321	6×	if (totalSupply != 0) {
322	8×	revert("Supply is not zero");
323		}
324	15×	decimalsOffset = targetDecimalsOffset;
325		}
326		}

1		// SPDX-License-Identifier: MIT
2		pragma solidity ^0.8.30;
3
4		import {IERC4626} from "@openzeppelin/contracts/interfaces/IERC4626.sol";
5		import {IYieldSourceOracle} from "@superform-v2-core/src/interfaces/accounting/IYieldSourceOracle.sol";
6
7		/// @title MockERC4626YieldSourceOracle
8		/// @notice Mock oracle for ERC4626 vaults in testing
9	278×	contract MockERC4626YieldSourceOracle is IYieldSourceOracle {
10	0	mapping(address => bool) public validAssetMap;
11
12	11×	function setValidAsset(address asset, bool isValid) external {
13	27×	validAssetMap[asset] = isValid;
14		}
15
16	0	function decimals(address yieldSourceAddress) external view returns (uint8) {
17	0	return IERC4626(yieldSourceAddress).decimals();
18		}
19
20	48×	function getShareOutput(
21		address yieldSourceAddress,
22		address,
23		uint256 assetsIn
24	4×	) external view returns (uint256) {
25	130×	return IERC4626(yieldSourceAddress).previewDeposit(assetsIn);
26		}
27
28	0	function getAssetOutput(
29		address yieldSourceAddress,
30		address,
31		uint256 sharesIn
32	0	) public view returns (uint256) {
33	0	return IERC4626(yieldSourceAddress).previewRedeem(sharesIn);
34		}
35
36	0	function getPricePerShare(address yieldSourceAddress) external view returns (uint256) {
37	0	IERC4626 yieldSource = IERC4626(yieldSourceAddress);
38	0	uint256 _decimals = yieldSource.decimals();
39	0	return yieldSource.convertToAssets(10 ** _decimals);
40		}
41
42	0	function getBalanceOfOwner(
43		address yieldSourceAddress,
44		address ownerOfShares
45	0	) external view returns (uint256) {
46	0	return IERC4626(yieldSourceAddress).balanceOf(ownerOfShares);
47		}
48
49	0	function getTVLByOwnerOfShares(
50		address yieldSourceAddress,
51		address ownerOfShares
52	0	) external view returns (uint256) {
53	0	uint256 shares = IERC4626(yieldSourceAddress).balanceOf(ownerOfShares);
54	0	return IERC4626(yieldSourceAddress).convertToAssets(shares);
55		}
56
57	0	function getTVL(address yieldSourceAddress) external view returns (uint256) {
58	0	return IERC4626(yieldSourceAddress).totalAssets();
59		}
60
61	0	function getPricePerShareMultiple(
62		address[] memory yieldSourceAddresses
63	0	) external view returns (uint256[] memory) {
64	0	uint256[] memory prices = new uint256[](yieldSourceAddresses.length);
65	0	for (uint256 i = 0; i < yieldSourceAddresses.length; i++) {
66	0	IERC4626 yieldSource = IERC4626(yieldSourceAddresses[i]);
67	0	uint256 _decimals = yieldSource.decimals();
68	0	prices[i] = yieldSource.convertToAssets(10 ** _decimals);
69		}
70	0	return prices;
71		}
72
73	0	function getTVLByOwnerOfSharesMultiple(
74		address[] memory yieldSourceAddresses,
75		address[][] memory ownersOfShares
76	0	) external view returns (uint256[][] memory) {
77	0	uint256[][] memory result = new uint256[][](yieldSourceAddresses.length);
78	0	for (uint256 i = 0; i < yieldSourceAddresses.length; i++) {
79	0	result[i] = new uint256[](ownersOfShares[i].length);
80	0	for (uint256 j = 0; j < ownersOfShares[i].length; j++) {
81	0	uint256 shares = IERC4626(yieldSourceAddresses[i]).balanceOf(ownersOfShares[i][j]);
82	0	result[i][j] = IERC4626(yieldSourceAddresses[i]).convertToAssets(shares);
83		}
84		}
85	0	return result;
86		}
87
88	0	function getTVLMultiple(
89		address[] memory yieldSourceAddresses
90	0	) external view returns (uint256[] memory) {
91	0	uint256[] memory tvls = new uint256[](yieldSourceAddresses.length);
92	0	for (uint256 i = 0; i < yieldSourceAddresses.length; i++) {
93	0	tvls[i] = IERC4626(yieldSourceAddresses[i]).totalAssets();
94		}
95		return tvls;
96		}
97
98	0	function isValidUnderlyingAsset(address, address asset) external view returns (bool) {
99	0	return validAssetMap[asset];
100		}
101
102	0	function isValidUnderlyingAssets(
103		address[] memory,
104		address[] memory assets
105	0	) external view returns (bool[] memory) {
106	0	bool[] memory validities = new bool[](assets.length);
107	0	for (uint256 i = 0; i < assets.length; i++) {
108	0	validities[i] = validAssetMap[assets[i]];
109		}
110		return validities;
111		}
112
113	0	function getAssetOutputWithFees(
114		bytes32,
115		address yieldSourceAddress,
116		address,
117		address,
118		uint256 sharesIn
119	0	) external view returns (uint256) {
120	0	return IERC4626(yieldSourceAddress).previewRedeem(sharesIn);
121		}
122		}

1		// SPDX-License-Identifier: MIT
2		pragma solidity ^0.8.30;
3
4		import {IERC20Metadata} from "@openzeppelin/contracts/interfaces/IERC20Metadata.sol";
5		import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
6		import {IYieldSourceOracle} from "@superform-v2-core/src/interfaces/accounting/IYieldSourceOracle.sol";
7		import {MockERC7540Tester} from "./MockERC7540Tester.sol";
8
9		/// @title MockERC7540YieldSourceOracle
10		/// @notice Mock oracle for ERC7540 (Asynchronous Tokenized Vaults) in testing
11	278×	contract MockERC7540YieldSourceOracle is IYieldSourceOracle {
12	0	mapping(address => bool) public validAssetMap;
13
14	11×	function setValidAsset(address asset, bool isValid) external {
15	27×	validAssetMap[asset] = isValid;
16		}
17
18	0	function decimals(address yieldSourceAddress) external view returns (uint8) {
19	0	address share = MockERC7540Tester(yieldSourceAddress).share();
20	0	return IERC20Metadata(share).decimals();
21		}
22
23	48×	function getShareOutput(
24		address yieldSourceAddress,
25		address,
26		uint256 assetsIn
27	4×	) external view returns (uint256) {
28	130×	return MockERC7540Tester(yieldSourceAddress).convertToShares(assetsIn);
29		}
30
31	0	function getAssetOutput(
32		address yieldSourceAddress,
33		address,
34		uint256 sharesIn
35	0	) public view returns (uint256) {
36	0	return MockERC7540Tester(yieldSourceAddress).convertToAssets(sharesIn);
37		}
38
39	0	function getPricePerShare(address yieldSourceAddress) external view returns (uint256) {
40	0	address share = MockERC7540Tester(yieldSourceAddress).share();
41	0	uint256 _decimals = IERC20Metadata(share).decimals();
42	0	return MockERC7540Tester(yieldSourceAddress).convertToAssets(10 ** _decimals);
43		}
44
45	0	function getBalanceOfOwner(
46		address yieldSourceAddress,
47		address ownerOfShares
48	0	) external view returns (uint256) {
49	0	return IERC20(MockERC7540Tester(yieldSourceAddress).share()).balanceOf(ownerOfShares);
50		}
51
52	0	function getTVLByOwnerOfShares(
53		address yieldSourceAddress,
54		address ownerOfShares
55	0	) external view returns (uint256) {
56	0	address share = MockERC7540Tester(yieldSourceAddress).share();
57	0	uint256 shares = IERC20(share).balanceOf(ownerOfShares);
58	0	return MockERC7540Tester(yieldSourceAddress).convertToAssets(shares);
59		}
60
61	0	function getTVL(address yieldSourceAddress) external view returns (uint256) {
62	0	return MockERC7540Tester(yieldSourceAddress).totalAssets();
63		}
64
65	0	function getPricePerShareMultiple(
66		address[] memory yieldSourceAddresses
67	0	) external view returns (uint256[] memory) {
68	0	uint256[] memory prices = new uint256[](yieldSourceAddresses.length);
69	0	for (uint256 i = 0; i < yieldSourceAddresses.length; i++) {
70	0	address share = MockERC7540Tester(yieldSourceAddresses[i]).share();
71	0	uint256 _decimals = IERC20Metadata(share).decimals();
72	0	prices[i] = MockERC7540Tester(yieldSourceAddresses[i]).convertToAssets(10 ** _decimals);
73		}
74	0	return prices;
75		}
76
77	0	function getTVLByOwnerOfSharesMultiple(
78		address[] memory yieldSourceAddresses,
79		address[][] memory ownersOfShares
80	0	) external view returns (uint256[][] memory) {
81	0	uint256[][] memory result = new uint256[][](yieldSourceAddresses.length);
82	0	for (uint256 i = 0; i < yieldSourceAddresses.length; i++) {
83	0	result[i] = new uint256[](ownersOfShares[i].length);
84	0	address share = MockERC7540Tester(yieldSourceAddresses[i]).share();
85	0	for (uint256 j = 0; j < ownersOfShares[i].length; j++) {
86	0	uint256 shares = IERC20(share).balanceOf(ownersOfShares[i][j]);
87	0	result[i][j] = MockERC7540Tester(yieldSourceAddresses[i]).convertToAssets(shares);
88		}
89		}
90	0	return result;
91		}
92
93	0	function getTVLMultiple(
94		address[] memory yieldSourceAddresses
95	0	) external view returns (uint256[] memory) {
96	0	uint256[] memory tvls = new uint256[](yieldSourceAddresses.length);
97	0	for (uint256 i = 0; i < yieldSourceAddresses.length; i++) {
98	0	tvls[i] = MockERC7540Tester(yieldSourceAddresses[i]).totalAssets();
99		}
100		return tvls;
101		}
102
103	0	function isValidUnderlyingAsset(address, address asset) external view returns (bool) {
104	0	return validAssetMap[asset];
105		}
106
107	0	function isValidUnderlyingAssets(
108		address[] memory,
109		address[] memory assets
110	0	) external view returns (bool[] memory) {
111	0	bool[] memory validities = new bool[](assets.length);
112	0	for (uint256 i = 0; i < assets.length; i++) {
113	0	validities[i] = validAssetMap[assets[i]];
114		}
115		return validities;
116		}
117
118	0	function getAssetOutputWithFees(
119		bytes32,
120		address yieldSourceAddress,
121		address,
122		address,
123		uint256 sharesIn
124	0	) external view returns (uint256) {
125	0	return MockERC7540Tester(yieldSourceAddress).convertToAssets(sharesIn);
126		}
127		}

1		// SPDX-License-Identifier: GPL-2.0
2		pragma solidity ^0.8.0;
3
4		import {BaseTargetFunctions} from "@chimera/BaseTargetFunctions.sol";
5		import {BeforeAfter} from "../BeforeAfter.sol";
6		import {Properties} from "../Properties.sol";
7		import {vm} from "@chimera/Hevm.sol";
8
9		import {MockERC20} from "@recon/MockERC20.sol";
10
11		// Target functions that are effectively inherited from the Actor and AssetManagers
12		// Once properly standardized, managers will expose these by default
13		// Keeping them out makes your project more custom
14		abstract contract ManagersTargets is BaseTargetFunctions, Properties {
15		// == ACTOR HANDLERS == //
16
17		/// @dev Start acting as another actor
18		/// @dev Update ghosts here to make global property checks not fail falsely
19	20×	function switchActor(uint256 entropy) public updateGhosts {
20	6×	_switchActor(entropy);
21		}
22
23		/// @dev Starts using a new asset
24	20×	function switch_asset(uint256 entropy) public {
25	4×	_switchAsset(entropy);
26		}
27
28		/// @dev Deploy a new token and add it to the list of assets, then set it as the current asset
29	25×	function add_new_asset(uint8 decimals) public returns (address) {
30	9×	address newAsset = _newAsset(decimals);
31		return newAsset;
32		}
33
34		/// @dev Switches the current vault based on the entropy
35		/// @param entropy The entropy to choose a random vault in the array for switching
36	20×	function switch_vault(uint256 entropy) public {
37	4×	_switchVault(entropy);
38		}
39
40		/// @dev Deploy a new vault using the current asset and add it to the list of vaults,
41		/// then set it as the current vault
42	15×	function add_new_vault() public {
43	68×	_newVault(superVault.asset());
44		}
45
46		/// === GHOST UPDATING HANDLERS ===///
47		/// We `updateGhosts` cause you never know (e.g. donations)
48		/// If you don't want to track donations, remove the `updateGhosts`
49
50		/// @dev Approve to arbitrary address, uses Actor by default
51		/// NOTE: You're almost always better off setting approvals in `Setup`
52	20×	function asset_approve(
53		address to,
54		uint128 amt
55		) public updateGhosts asActor {
56	132×	MockERC20(superVault.asset()).approve(to, amt);
57		}
58
59		/// @dev Mint to arbitrary address, uses owner by default, even though MockERC20 doesn't check
60	20×	function asset_mint(address to, uint128 amt) public updateGhosts asAdmin {
61	118×	MockERC20(superVault.asset()).mint(to, amt);
62		}
63		}

1		// SPDX-License-Identifier: GPL-2.0
2		pragma solidity ^0.8.0;
3
4		// Recon deps
5		import {BaseTargetFunctions} from "@chimera/BaseTargetFunctions.sol";
6		import {vm} from "@chimera/Hevm.sol";
7		import {Panic} from "@recon/Panic.sol";
8		import {MockERC20} from "@recon/MockERC20.sol";
9
10		import "src/SuperVault/SuperVault.sol";
11
12		import {BeforeAfter, OpType} from "test/recon/BeforeAfter.sol";
13		import {Properties} from "../Properties.sol";
14
15		/// @dev All receivers are inherently clamped to actors to make checking properties easier
16		abstract contract SuperVaultTargets is BaseTargetFunctions, Properties {
17		/// CUSTOM TARGET FUNCTIONS - Add your own target functions here ///
18	20×	function superVault_requestRedeem_clamped(uint256 shares) public {
19	76×	shares %= superVault.balanceOf(_getActor()) + 1;
20
21	4×	superVault_requestRedeem(shares);
22		}
23
24	20×	function superVault_redeem_clamped(uint256 shares) public {
25	66×	uint256 claimableAssets = superVault.maxWithdraw(_getActor());
26	63×	uint256 claimableShares = superVault.convertToShares(claimableAssets);
27
28	13×	shares %= claimableShares + 1;
29
30	4×	superVault_redeem(shares);
31		}
32
33	20×	function superVault_withdraw_clamped(uint256 assets) public {
34	66×	uint256 claimableAssets = superVault.maxWithdraw(_getActor());
35	13×	assets %= claimableAssets + 1;
36
37	2×	superVault_withdraw(assets);
38		}
39
40		/// AUTO GENERATED TARGET FUNCTIONS - WARNING: DO NOT DELETE OR MODIFY THIS LINE ///
41
42	20×	function superVault_approve(address spender, uint256 value) public asActor {
43	74×	superVault.approve(spender, value);
44		}
45
46	20×	function superVault_burnShares(uint256 amount) public asActor {
47	16×	superVault.burnShares(amount);
48		}
49
50		/// @dev Property: pendingRedeemRequest should be 0 after a user calls cancelRedeem
51		/// @dev Property: averageRequestPPS should be 0 after a user calls cancelRedeem
52		/// @dev Property: user shouldn't receive more than convertToAssets(pendingRedeemRequest) after cancelRedeem
53	15×	function superVault_cancelRedeem_ASSERTION_CANCEL_REDEEM_NO_OVERPAY()
54		public
55	1×	updateGhostsWithOpType(OpType.CANCEL)
56	6×	{
57	71×	uint256 pendingRedeemRequestsBefore = superVault.pendingRedeemRequest(
58		0,
59	2×	_getActor()
60		);
61	63×	uint256 pendingRedeemRequestsAsAssets = superVault.convertToAssets(
62		pendingRedeemRequestsBefore
63		);
64	127×	uint256 balanceBefore = MockERC20(superVault.asset()).balanceOf(
65	2×	_getActor()
66		);
67
68	41×	vm.prank(_getActor());
69	53×	superVault.cancelRedeem(_getActor());
70
71	72×	uint256 pendingRedeemRequestsAfter = superVault.pendingRedeemRequest(
72		0,
73	2×	_getActor()
74		);
75	67×	uint256 averageRequestPPS = superVaultStrategy
76	2×	.getSuperVaultState(_getActor())
77		.averageRequestPPS;
78	128×	uint256 balanceAfter = MockERC20(superVault.asset()).balanceOf(
79	2×	_getActor()
80		);
81
82		// Checks
83	4×	eq(
84	1×	pendingRedeemRequestsAfter,
85	1×	0,
86	17×	ASSERTION_CANCEL_REDEEM_NO_OVERPAY
87		);
88	4×	eq(
89	1×	averageRequestPPS,
90	1×	0,
91	17×	ASSERTION_CANCEL_REDEEM_NO_OVERPAY
92		);
93	4×	lte(
94	6×	balanceAfter - balanceBefore,
95	1×	pendingRedeemRequestsAsAssets,
96	17×	ASSERTION_CANCEL_REDEEM_NO_OVERPAY
97		);
98		}
99
100		/// @dev Property: previewDeposit returns the correct amounts compared to executing a deposit
101	20×	function superVault_deposit_ASSERTION_PREVIEW_DEPOSIT_MATCHES_EXECUTION(
102		uint256 assets
103	3×	) public updateGhostsWithOpType(OpType.ADD) {
104	67×	uint256 previewShares = superVault.previewDeposit(assets);
105
106	41×	vm.prank(_getActor());
107	82×	uint256 shares = superVault.deposit(assets, _getActor());
108
109	4×	eq(
110	1×	previewShares,
111	1×	shares,
112	17×	ASSERTION_PREVIEW_DEPOSIT_MATCHES_EXECUTION
113		);
114		}
115
116		/// @dev Property: previewMint returns the correct amounts compared to executing a mint
117	20×	function superVault_mint_ASSERTION_PREVIEW_MINT_MATCHES_EXECUTION(
118		uint256 shares
119	1×	) public updateGhostsWithOpType(OpType.ADD) {
120	67×	uint256 previewMint = superVault.previewMint(shares);
121
122	41×	vm.prank(_getActor());
123	82×	uint256 assets = superVault.mint(shares, _getActor());
124
125	3×	eq(
126	1×	assets,
127	1×	previewMint,
128	17×	ASSERTION_PREVIEW_MINT_MATCHES_EXECUTION
129		);
130		}
131
132	20×	function superVault_invalidateNonce(bytes32 nonce) public asActor {
133	16×	superVault.invalidateNonce(nonce);
134		}
135
136	20×	function superVault_redeem(
137		uint256 shares
138	1×	) public updateGhostsWithOpType(OpType.REMOVE) asActor {
139	8×	superVault.redeem(shares, _getActor(), _getActor());
140		}
141
142	20×	function superVault_withdraw(
143		uint256 assets
144	1×	) public updateGhostsWithOpType(OpType.REMOVE) asActor {
145	8×	superVault.withdraw(assets, _getActor(), _getActor());
146		}
147
148	26×	function superVault_requestRedeem(
149		uint256 shares
150	1×	) public updateGhostsWithOpType(OpType.REQUEST) asActor {
151	81×	superVault.requestRedeem(shares, _getActor(), _getActor());
152		}
153
154	20×	function superVault_setOperator(
155		uint256 entropy,
156		bool approved
157		) public asActor {
158	8×	address operator = _getRandomActor(entropy);
159	65×	superVault.setOperator(operator, approved);
160		}
161
162		/// @dev Propery: _update should never revert
163		/// @dev Property: Transfers of shares should transfer the exact amount of accumulatorShares to the recipient
164		/// @dev Property: Transfers of shares should transfer the exact amount of accumulatorCostBasis to the recipient
165		// NOTE: _update only gets called on transfer of Vault shares
166	20×	function superVault_transfer_ASSERTION_TRANSFER_SHARES_CONSERVED(
167		uint256 entropy,
168		uint256 value
169	4×	) public updateGhostsWithOpType(OpType.TRANSFER) {
170	8×	address to = _getRandomActor(entropy);
171	4×	ISuperVaultStrategy.SuperVaultState
172	60×	memory stateSenderBefore = superVaultStrategy.getSuperVaultState(
173	2×	_getActor()
174		);
175	3×	ISuperVaultStrategy.SuperVaultState
176	59×	memory stateRecipientBefore = superVaultStrategy.getSuperVaultState(
177		to
178		);
179
180	41×	vm.prank(_getActor());
181	107×	try superVault.transfer(to, value) {
182	4×	ISuperVaultStrategy.SuperVaultState
183	60×	memory stateSenderAfter = superVaultStrategy.getSuperVaultState(
184	2×	_getActor()
185		);
186	4×	ISuperVaultStrategy.SuperVaultState
187	59×	memory stateRecipientAfter = superVaultStrategy
188		.getSuperVaultState(to);
189
190	4×	eq(
191	10×	stateSenderBefore.accumulatorShares -
192	4×	stateSenderAfter.accumulatorShares,
193	10×	stateRecipientAfter.accumulatorShares -
194	4×	stateRecipientBefore.accumulatorShares,
195	17×	ASSERTION_TRANSFER_SHARES_CONSERVED
196		);
197	2×	eq(
198	10×	stateSenderBefore.accumulatorCostBasis -
199	4×	stateSenderAfter.accumulatorCostBasis,
200	9×	stateRecipientAfter.accumulatorCostBasis -
201	4×	stateRecipientBefore.accumulatorCostBasis,
202		ASSERTION_TRANSFER_SHARES_CONSERVED
203		);
204	2×	} catch (bytes memory err) {
205	1×	bool expectedError;
206	23×	expectedError = checkError(
207	1×	err,
208		"ERC20InsufficientBalance(address,uint256,uint256)"
209		);
210	22×	t(expectedError, ASSERTION_TRANSFER_SHARES_CONSERVED);
211		}
212		}
213
214		/// @dev Propery: _update should never revert
215		// NOTE: _update only gets called on transfer of Vault shares
216	20×	function superVault_transferFrom_ASSERTION_UPDATE_SHOULD_NOT_REVERT_TRANSFER_FROM(
217		uint256 entropyFrom,
218		uint256 entropyTo,
219		uint256 value
220	3×	) public updateGhostsWithOpType(OpType.TRANSFER) {
221	8×	address from = _getRandomActor(entropyFrom);
222	7×	address to = _getRandomActor(entropyTo);
223
224	41×	vm.prank(_getActor());
225	109×	try superVault.transferFrom(from, to, value) {} catch (
226		bytes memory err
227	1×	) {
228	1×	bool expectedError;
229	2×	expectedError =
230	25×	checkError(
231	1×	err,
232		"ERC20InsufficientBalance(address,uint256,uint256)"
233		) \|\|
234	21×	checkError(
235	1×	err,
236		"ERC20InsufficientAllowance(address,uint256,uint256)"
237		);
238	4×	t(
239	1×	expectedError,
240	17×	ASSERTION_UPDATE_SHOULD_NOT_REVERT_TRANSFER_FROM
241		);
242		}
243		}
244
245		/// @dev removed because signature components not fuzzable
246		// function superVault_authorizeOperator(
247		// address controller,
248		// address operator,
249		// bool approved,
250		// bytes32 nonce,
251		// uint256 deadline,
252		// bytes memory signature
253		// ) public asActor {
254		// superVault.authorizeOperator(
255		// controller,
256		// operator,
257		// approved,
258		// nonce,
259		// deadline,
260		// signature
261		// );
262		// }
263		}