@pendle/core-v2 6.7.0 → 6.8.0

package/contracts/pt-looping/money-market/implementations/aave/dependencies/IPoolAddressesProvider.sol

@@ -0,0 +1,227 @@
+// SPDX-License-Identifier: AGPL-3.0
+pragma solidity ^0.8.4;
+
+import {IPool} from "./IPool.sol";
+import {IAaveOracle} from "./IAaveOracle.sol";
+import {IPoolDataProviderV3} from "./IPoolDataProviderV3.sol";
+
+/**
+ * @title IPoolAddressesProvider
+ * @author Aave
+ * @notice Defines the basic interface for a Pool Addresses Provider.
+ */
+interface IPoolAddressesProvider {
+    /**
+     * @dev Emitted when the market identifier is updated.
+     * @param oldMarketId The old id of the market
+     * @param newMarketId The new id of the market
+     */
+    event MarketIdSet(string indexed oldMarketId, string indexed newMarketId);
+
+    /**
+     * @dev Emitted when the pool is updated.
+     * @param oldAddress The old address of the Pool
+     * @param newAddress The new address of the Pool
+     */
+    event PoolUpdated(address indexed oldAddress, address indexed newAddress);
+
+    /**
+     * @dev Emitted when the pool configurator is updated.
+     * @param oldAddress The old address of the PoolConfigurator
+     * @param newAddress The new address of the PoolConfigurator
+     */
+    event PoolConfiguratorUpdated(address indexed oldAddress, address indexed newAddress);
+
+    /**
+     * @dev Emitted when the price oracle is updated.
+     * @param oldAddress The old address of the PriceOracle
+     * @param newAddress The new address of the PriceOracle
+     */
+    event PriceOracleUpdated(address indexed oldAddress, address indexed newAddress);
+
+    /**
+     * @dev Emitted when the ACL manager is updated.
+     * @param oldAddress The old address of the ACLManager
+     * @param newAddress The new address of the ACLManager
+     */
+    event ACLManagerUpdated(address indexed oldAddress, address indexed newAddress);
+
+    /**
+     * @dev Emitted when the ACL admin is updated.
+     * @param oldAddress The old address of the ACLAdmin
+     * @param newAddress The new address of the ACLAdmin
+     */
+    event ACLAdminUpdated(address indexed oldAddress, address indexed newAddress);
+
+    /**
+     * @dev Emitted when the price oracle sentinel is updated.
+     * @param oldAddress The old address of the PriceOracleSentinel
+     * @param newAddress The new address of the PriceOracleSentinel
+     */
+    event PriceOracleSentinelUpdated(address indexed oldAddress, address indexed newAddress);
+
+    /**
+     * @dev Emitted when the pool data provider is updated.
+     * @param oldAddress The old address of the PoolDataProvider
+     * @param newAddress The new address of the PoolDataProvider
+     */
+    event PoolDataProviderUpdated(address indexed oldAddress, address indexed newAddress);
+
+    /**
+     * @dev Emitted when a new proxy is created.
+     * @param id The identifier of the proxy
+     * @param proxyAddress The address of the created proxy contract
+     * @param implementationAddress The address of the implementation contract
+     */
+    event ProxyCreated(bytes32 indexed id, address indexed proxyAddress, address indexed implementationAddress);
+
+    /**
+     * @dev Emitted when a new non-proxied contract address is registered.
+     * @param id The identifier of the contract
+     * @param oldAddress The address of the old contract
+     * @param newAddress The address of the new contract
+     */
+    event AddressSet(bytes32 indexed id, address indexed oldAddress, address indexed newAddress);
+
+    /**
+     * @dev Emitted when the implementation of the proxy registered with id is updated
+     * @param id The identifier of the contract
+     * @param proxyAddress The address of the proxy contract
+     * @param oldImplementationAddress The address of the old implementation contract
+     * @param newImplementationAddress The address of the new implementation contract
+     */
+    event AddressSetAsProxy(
+        bytes32 indexed id,
+        address indexed proxyAddress,
+        address oldImplementationAddress,
+        address indexed newImplementationAddress
+    );
+
+    /**
+     * @notice Returns the id of the Aave market to which this contract points to.
+     * @return The market id
+     */
+    function getMarketId() external view returns (string memory);
+
+    /**
+     * @notice Associates an id with a specific PoolAddressesProvider.
+     * @dev This can be used to create an onchain registry of PoolAddressesProviders to
+     * identify and validate multiple Aave markets.
+     * @param newMarketId The market id
+     */
+    function setMarketId(string calldata newMarketId) external;
+
+    /**
+     * @notice Returns an address by its identifier.
+     * @dev The returned address might be an EOA or a contract, potentially proxied
+     * @dev It returns ZERO if there is no registered address with the given id
+     * @param id The id
+     * @return The address of the registered for the specified id
+     */
+    function getAddress(bytes32 id) external view returns (address);
+
+    /**
+     * @notice General function to update the implementation of a proxy registered with
+     * certain `id`. If there is no proxy registered, it will instantiate one and
+     * set as implementation the `newImplementationAddress`.
+     * @dev IMPORTANT Use this function carefully, only for ids that don't have an explicit
+     * setter function, in order to avoid unexpected consequences
+     * @param id The id
+     * @param newImplementationAddress The address of the new implementation
+     */
+    function setAddressAsProxy(bytes32 id, address newImplementationAddress) external;
+
+    /**
+     * @notice Sets an address for an id replacing the address saved in the addresses map.
+     * @dev IMPORTANT Use this function carefully, as it will do a hard replacement
+     * @param id The id
+     * @param newAddress The address to set
+     */
+    function setAddress(bytes32 id, address newAddress) external;
+
+    /**
+     * @notice Returns the address of the Pool proxy.
+     * @return The Pool proxy address
+     */
+    function getPool() external view returns (IPool);
+
+    /**
+     * @notice Updates the implementation of the Pool, or creates a proxy
+     * setting the new `pool` implementation when the function is called for the first time.
+     * @param newPoolImpl The new Pool implementation
+     */
+    function setPoolImpl(address newPoolImpl) external;
+
+    /**
+     * @notice Returns the address of the PoolConfigurator proxy.
+     * @return The PoolConfigurator proxy address
+     */
+    function getPoolConfigurator() external view returns (address);
+
+    /**
+     * @notice Updates the implementation of the PoolConfigurator, or creates a proxy
+     * setting the new `PoolConfigurator` implementation when the function is called for the first time.
+     * @param newPoolConfiguratorImpl The new PoolConfigurator implementation
+     */
+    function setPoolConfiguratorImpl(address newPoolConfiguratorImpl) external;
+
+    /**
+     * @notice Returns the address of the price oracle.
+     * @return The address of the PriceOracle
+     */
+    function getPriceOracle() external view returns (IAaveOracle);
+
+    /**
+     * @notice Updates the address of the price oracle.
+     * @param newPriceOracle The address of the new PriceOracle
+     */
+    function setPriceOracle(address newPriceOracle) external;
+
+    /**
+     * @notice Returns the address of the ACL manager.
+     * @return The address of the ACLManager
+     */
+    function getACLManager() external view returns (address);
+
+    /**
+     * @notice Updates the address of the ACL manager.
+     * @param newAclManager The address of the new ACLManager
+     */
+    function setACLManager(address newAclManager) external;
+
+    /**
+     * @notice Returns the address of the ACL admin.
+     * @return The address of the ACL admin
+     */
+    function getACLAdmin() external view returns (address);
+
+    /**
+     * @notice Updates the address of the ACL admin.
+     * @param newAclAdmin The address of the new ACL admin
+     */
+    function setACLAdmin(address newAclAdmin) external;
+
+    /**
+     * @notice Returns the address of the price oracle sentinel.
+     * @return The address of the PriceOracleSentinel
+     */
+    function getPriceOracleSentinel() external view returns (address);
+
+    /**
+     * @notice Updates the address of the price oracle sentinel.
+     * @param newPriceOracleSentinel The address of the new PriceOracleSentinel
+     */
+    function setPriceOracleSentinel(address newPriceOracleSentinel) external;
+
+    /**
+     * @notice Returns the address of the data provider.
+     * @return The address of the DataProvider
+     */
+    function getPoolDataProvider() external view returns (IPoolDataProviderV3);
+
+    /**
+     * @notice Updates the address of the data provider.
+     * @param newDataProvider The address of the new DataProvider
+     */
+    function setPoolDataProvider(address newDataProvider) external;
+}

package/contracts/pt-looping/money-market/implementations/aave/dependencies/IPoolDataProviderV3.sol

@@ -0,0 +1,228 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// https://github.com/aave/aave-v3-horizon/blob/311a59fb1cec23ee254e84b28759fd1faf9c3711/src/contracts/interfaces/IPoolDataProvider.sol
+/// Modifications:
+/// - Rename IPoolDataProvider -> IPoolDataProviderV3
+/// - Make `getReserveData` return a `ReserveData` struct instead of individual fields.
+
+import {IPoolAddressesProvider} from "./IPoolAddressesProvider.sol";
+
+/**
+ * @title IPoolDataProviderV3
+ * @author Aave
+ * @notice Defines the basic interface of a PoolDataProvider
+ */
+interface IPoolDataProviderV3 {
+    struct TokenData {
+        string symbol;
+        address tokenAddress;
+    }
+
+    /**
+     * @notice Returns the address for the PoolAddressesProvider contract.
+     * @return The address for the PoolAddressesProvider contract
+     */
+    function ADDRESSES_PROVIDER() external view returns (IPoolAddressesProvider);
+
+    /**
+     * @notice Returns the list of the existing reserves in the pool.
+     * @dev Handling MKR and ETH in a different way since they do not have standard `symbol` functions.
+     * @return The list of reserves, pairs of symbols and addresses
+     */
+    function getAllReservesTokens() external view returns (TokenData[] memory);
+
+    /**
+     * @notice Returns the list of the existing ATokens in the pool.
+     * @return The list of ATokens, pairs of symbols and addresses
+     */
+    function getAllATokens() external view returns (TokenData[] memory);
+
+    /**
+     * @notice Returns the configuration data of the reserve
+     * @dev Not returning borrow and supply caps for compatibility, nor pause flag
+     * @param asset The address of the underlying asset of the reserve
+     * @return decimals The number of decimals of the reserve
+     * @return ltv The ltv of the reserve
+     * @return liquidationThreshold The liquidationThreshold of the reserve
+     * @return liquidationBonus The liquidationBonus of the reserve
+     * @return reserveFactor The reserveFactor of the reserve
+     * @return usageAsCollateralEnabled True if the usage as collateral is enabled, false otherwise
+     * @return borrowingEnabled True if borrowing is enabled, false otherwise
+     * @return stableBorrowRateEnabled True if stable rate borrowing is enabled, false otherwise
+     * @return isActive True if it is active, false otherwise
+     * @return isFrozen True if it is frozen, false otherwise
+     */
+    function getReserveConfigurationData(address asset)
+        external
+        view
+        returns (
+            uint256 decimals,
+            uint256 ltv,
+            uint256 liquidationThreshold,
+            uint256 liquidationBonus,
+            uint256 reserveFactor,
+            bool usageAsCollateralEnabled,
+            bool borrowingEnabled,
+            bool stableBorrowRateEnabled,
+            bool isActive,
+            bool isFrozen
+        );
+
+    /**
+     * @notice Returns the caps parameters of the reserve
+     * @param asset The address of the underlying asset of the reserve
+     * @return borrowCap The borrow cap of the reserve
+     * @return supplyCap The supply cap of the reserve
+     */
+    function getReserveCaps(address asset) external view returns (uint256 borrowCap, uint256 supplyCap);
+
+    /**
+     * @notice Returns if the pool is paused
+     * @param asset The address of the underlying asset of the reserve
+     * @return isPaused True if the pool is paused, false otherwise
+     */
+    function getPaused(address asset) external view returns (bool isPaused);
+
+    /**
+     * @notice Returns the siloed borrowing flag
+     * @param asset The address of the underlying asset of the reserve
+     * @return True if the asset is siloed for borrowing
+     */
+    function getSiloedBorrowing(address asset) external view returns (bool);
+
+    /**
+     * @notice Returns the protocol fee on the liquidation bonus
+     * @param asset The address of the underlying asset of the reserve
+     * @return The protocol fee on liquidation
+     */
+    function getLiquidationProtocolFee(address asset) external view returns (uint256);
+
+    /**
+     * @notice Returns the unbacked mint cap of the reserve
+     * @param asset The address of the underlying asset of the reserve
+     * @return The unbacked mint cap of the reserve
+     */
+    function getUnbackedMintCap(address asset) external view returns (uint256);
+
+    /**
+     * @notice Returns the debt ceiling of the reserve
+     * @param asset The address of the underlying asset of the reserve
+     * @return The debt ceiling of the reserve
+     */
+    function getDebtCeiling(address asset) external view returns (uint256);
+
+    /**
+     * @notice Returns the debt ceiling decimals
+     * @return The debt ceiling decimals
+     */
+    function getDebtCeilingDecimals() external pure returns (uint256);
+
+    struct ReserveData {
+        uint256 unbacked;
+        uint256 accruedToTreasuryScaled;
+        uint256 totalAToken;
+        uint256 totalStableDebt;
+        uint256 totalVariableDebt;
+        uint256 liquidityRate;
+        uint256 variableBorrowRate;
+        uint256 stableBorrowRate;
+        uint256 averageStableBorrowRate;
+        uint256 liquidityIndex;
+        uint256 variableBorrowIndex;
+        uint40 lastUpdateTimestamp;
+    }
+
+    function getReserveData(address asset) external view returns (ReserveData memory);
+
+    /**
+     * @notice Returns the total supply of aTokens for a given asset
+     * @param asset The address of the underlying asset of the reserve
+     * @return The total supply of the aToken
+     */
+    function getATokenTotalSupply(address asset) external view returns (uint256);
+
+    /**
+     * @notice Returns the total debt for a given asset
+     * @param asset The address of the underlying asset of the reserve
+     * @return The total debt for asset
+     */
+    function getTotalDebt(address asset) external view returns (uint256);
+
+    /**
+     * @notice Returns the user data in a reserve
+     * @param asset The address of the underlying asset of the reserve
+     * @param user The address of the user
+     * @return currentATokenBalance The current AToken balance of the user
+     * @return currentStableDebt The current stable debt of the user
+     * @return currentVariableDebt The current variable debt of the user
+     * @return principalStableDebt The principal stable debt of the user
+     * @return scaledVariableDebt The scaled variable debt of the user
+     * @return stableBorrowRate The stable borrow rate of the user
+     * @return liquidityRate The liquidity rate of the reserve
+     * @return stableRateLastUpdated The timestamp of the last update of the user stable rate
+     * @return usageAsCollateralEnabled True if the user is using the asset as collateral, false
+     *         otherwise
+     */
+    function getUserReserveData(address asset, address user)
+        external
+        view
+        returns (
+            uint256 currentATokenBalance,
+            uint256 currentStableDebt,
+            uint256 currentVariableDebt,
+            uint256 principalStableDebt,
+            uint256 scaledVariableDebt,
+            uint256 stableBorrowRate,
+            uint256 liquidityRate,
+            uint40 stableRateLastUpdated,
+            bool usageAsCollateralEnabled
+        );
+
+    /**
+     * @notice Returns the token addresses of the reserve
+     * @param asset The address of the underlying asset of the reserve
+     * @return aTokenAddress The AToken address of the reserve
+     * @return stableDebtTokenAddress DEPRECATED in v3.2.0
+     * @return variableDebtTokenAddress The VariableDebtToken address of the reserve
+     */
+    function getReserveTokensAddresses(address asset)
+        external
+        view
+        returns (address aTokenAddress, address stableDebtTokenAddress, address variableDebtTokenAddress);
+
+    /**
+     * @notice Returns the address of the Interest Rate strategy
+     * @param asset The address of the underlying asset of the reserve
+     * @return irStrategyAddress The address of the Interest Rate strategy
+     */
+    function getInterestRateStrategyAddress(address asset) external view returns (address irStrategyAddress);
+
+    /**
+     * @notice Returns whether the reserve has FlashLoans enabled or disabled
+     * @param asset The address of the underlying asset of the reserve
+     * @return True if FlashLoans are enabled, false otherwise
+     */
+    function getFlashLoanEnabled(address asset) external view returns (bool);
+
+    /**
+     * @notice Returns whether virtual accounting is enabled/not for a reserve
+     * @param asset The address of the underlying asset of the reserve
+     * @return True if active, false otherwise
+     */
+    function getIsVirtualAccActive(address asset) external view returns (bool);
+
+    /**
+     * @notice Returns the virtual underlying balance of the reserve
+     * @param asset The address of the underlying asset of the reserve
+     * @return The reserve virtual underlying balance
+     */
+    function getVirtualUnderlyingBalance(address asset) external view returns (uint256);
+
+    /**
+     * @notice Returns the deficit of the reserve
+     * @param asset The address of the underlying asset of the reserve
+     * @return The reserve deficit
+     */
+    function getReserveDeficit(address asset) external view returns (uint256);
+}

package/contracts/pt-looping/money-market/implementations/aave/dependencies/IPriceOracleGetter.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: AGPL-3.0
+pragma solidity ^0.8.4;
+
+import {IERC20Metadata as IERC20} from "@openzeppelin/contracts/interfaces/IERC20Metadata.sol";
+
+/**
+ * @title IPriceOracleGetter
+ * @author Aave
+ * @notice Interface for the Aave price oracle.
+ */
+interface IPriceOracleGetter {
+    /**
+     * @notice Returns the base currency address
+     * @dev Address 0x0 is reserved for USD as base currency.
+     * @return Returns the base currency address.
+     */
+    function BASE_CURRENCY() external view returns (IERC20);
+
+    /**
+     * @notice Returns the base currency unit
+     * @dev 1 ether for ETH, 1e8 for USD.
+     * @return Returns the base currency unit.
+     */
+    function BASE_CURRENCY_UNIT() external view returns (uint256);
+
+    /**
+     * @notice Returns the asset price in the base currency
+     * @param asset The address of the asset
+     * @return The price of the asset
+     */
+    function getAssetPrice(IERC20 asset) external view returns (uint256);
+}

package/contracts/pt-looping/money-market/implementations/morpho/MorphoBlueMoneyMarket.sol

@@ -0,0 +1,123 @@
+//SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.20;
+
+import {PMath} from "../../../../core/libraries/math/PMath.sol";
+import {MarketCtx} from "../../../../interfaces/IMoneyMarket.sol";
+import {BaseMoneyMarket} from "../../BaseMoneyMarket.sol";
+import {
+    IMorpho,
+    Market as MorphoMarketState,
+    MarketParams as MorphoMarketParams,
+    MorphoMarketId,
+    Position as MorphoPosition
+} from "./dependencies/IMorpho.sol";
+import {SharesMathLib} from "./dependencies/SharesMathLib.sol";
+
+contract MorphoBlueMoneyMarket is BaseMoneyMarket {
+    using SharesMathLib for *;
+
+    /// @dev Morpho oracle returns price scaled by 1e36. PMath WAD is 1e18, so the divisor
+    /// `1e36 / WAD = 1e18` normalises the rate. Kept as a named constant for clarity.
+    uint256 internal constant ORACLE_PRICE_SCALE_TO_WAD_NUMERATOR = 1e36 / PMath.ONE;
+
+    IMorpho public immutable MORPHO;
+
+    constructor(address ptLooper, address _morpho) BaseMoneyMarket(ptLooper) {
+        MORPHO = IMorpho(_morpho);
+    }
+
+    // ========== IMoneyMarket ==========
+
+    function _initialize(MarketCtx memory ctx) internal virtual override {
+        _safeApproveInf(ctx.collateral, address(MORPHO));
+        _safeApproveInf(ctx.debtAsset, address(MORPHO));
+    }
+
+    function collateralBalance(MarketCtx memory ctx) public view override returns (uint256 balance) {
+        balance = _selfPosition(ctx.mmPayload).collateral;
+    }
+
+    /// @dev Mutating, not `view`: calls `MORPHO.accrueInterest` before reading. Sibling math is
+    /// duplicated in `MorphoBlueMoneyMarketView._moneyMarketBalances` — keep in sync on Morpho
+    /// protocol updates.
+    function debtBalance(MarketCtx memory ctx) public override returns (uint256 balance) {
+        MORPHO.accrueInterest(_marketParams(ctx.mmPayload)); // Accrue interest before loading the market state
+        MorphoMarketState memory market = _marketState(ctx.mmPayload);
+        MorphoPosition memory position = _selfPosition(ctx.mmPayload);
+        balance = position.borrowShares.toAssetsUp(market.totalBorrowAssets, market.totalBorrowShares);
+    }
+
+    function _lend(MarketCtx memory ctx, uint256 amount) internal virtual override returns (uint256 actualAmount) {
+        _transferIn(ctx.collateral, address(ctx.box), amount);
+        MORPHO.supplyCollateral({
+            marketParams: _marketParams(ctx.mmPayload), assets: amount, onBehalf: address(this), data: ""
+        });
+        return amount;
+    }
+
+    function _borrow(MarketCtx memory ctx, uint256 amount) internal virtual override returns (uint256 actualAmount) {
+        (actualAmount,) = MORPHO.borrow({
+            marketParams: _marketParams(ctx.mmPayload),
+            assets: amount,
+            shares: 0,
+            onBehalf: address(this),
+            receiver: address(ctx.box)
+        });
+    }
+
+    /// @dev Pull `actualShares.toAssetsUp(...)` — exactly the assets Morpho consumes when burning
+    /// `actualShares` — for both full and partial repays. `toAssetsUp(toSharesDown(amount)) <= amount`,
+    /// so this never over-pulls and leaves no debt-token dust stranded in this contract.
+    function _repay(MarketCtx memory ctx, uint256 amount, uint256)
+        internal
+        virtual
+        override
+        returns (uint256 actualAmount)
+    {
+        // Parent `BaseMoneyMarket.repay` called `debtBalance` which already accrued interest.
+        MorphoMarketParams memory marketParams = _marketParams(ctx.mmPayload);
+        MorphoMarketState memory market = _marketState(ctx.mmPayload);
+        uint256 borrowShares = _selfPosition(ctx.mmPayload).borrowShares;
+        uint256 actualShares =
+            PMath.min(amount.toSharesDown(market.totalBorrowAssets, market.totalBorrowShares), borrowShares);
+
+        if (actualShares > 0) {
+            uint256 pullAmount = actualShares.toAssetsUp(market.totalBorrowAssets, market.totalBorrowShares);
+            _transferIn(ctx.debtAsset, address(ctx.box), pullAmount);
+
+            (actualAmount,) = MORPHO.repay({
+                marketParams: marketParams, assets: 0, shares: actualShares, onBehalf: address(this), data: ""
+            });
+        }
+    }
+
+    function _withdraw(MarketCtx memory ctx, uint256 amount) internal virtual override returns (uint256 actualAmount) {
+        MORPHO.withdrawCollateral({
+            marketParams: _marketParams(ctx.mmPayload),
+            assets: amount,
+            onBehalf: address(this),
+            receiver: address(ctx.box)
+        });
+        return amount;
+    }
+
+    /// @dev Morpho's oracle is keyed by the market (resolved from `mmPayload`), not by individual
+    /// asset addresses — so `ctx.collateral` and `ctx.debtAsset` are unused here.
+    function oraclePtDebtRate(MarketCtx memory ctx) public view override returns (uint256) {
+        return _marketParams(ctx.mmPayload).oracle.price() / ORACLE_PRICE_SCALE_TO_WAD_NUMERATOR;
+    }
+
+    // ========== Internal helpers ==========
+
+    function _marketState(bytes32 mmPayload) internal view returns (MorphoMarketState memory) {
+        return MORPHO.market(MorphoMarketId.wrap(mmPayload));
+    }
+
+    function _marketParams(bytes32 mmPayload) internal view returns (MorphoMarketParams memory) {
+        return MORPHO.idToMarketParams(MorphoMarketId.wrap(mmPayload));
+    }
+
+    function _selfPosition(bytes32 mmPayload) internal view returns (MorphoPosition memory) {
+        return MORPHO.position(MorphoMarketId.wrap(mmPayload), address(this));
+    }
+}

package/contracts/pt-looping/money-market/implementations/morpho/MorphoBlueMoneyMarketView.sol

@@ -0,0 +1,66 @@
+//SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.20;
+
+import {IMorpho, MorphoMarketId, MarketParams, Market as MorphoMarketState} from "./dependencies/IMorpho.sol";
+import {BaseMoneyMarketView} from "../../BaseMoneyMarketView.sol";
+import {IPLoopPositionBox, BoxData} from "../../../../interfaces/IPLoopPositionBox.sol";
+import {IERC20Metadata as IERC20} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+contract MorphoBlueMoneyMarketView is BaseMoneyMarketView {
+    IMorpho public immutable MORPHO;
+
+    constructor(string memory _moneyMarketName, address _ptLooper, address _morpho)
+        BaseMoneyMarketView(_moneyMarketName, _ptLooper)
+    {
+        MORPHO = IMorpho(_morpho);
+    }
+
+    // ========== IMoneyMarketView ==========
+
+    // `_moneyMarketBalances` is inherited from `BaseMoneyMarketView`, which reads the
+    // canonical `collateralBalance` / `debtBalance` off the spoke MM clone (the latter accrues
+    // interest before reading) — no need to re-implement Morpho's shares math here.
+
+    function _thresholds(IPLoopPositionBox, BoxData memory bd)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 ltv, uint256 liquidationThreshold)
+    {
+        // Morpho has a single LLTV, so ltv == liquidationThreshold
+        ltv = liquidationThreshold = MORPHO.idToMarketParams(_morphoMarketId(bd)).lltv;
+    }
+
+    function _liquidity(IPLoopPositionBox, BoxData memory bd)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 borrowing, uint256 lending)
+    {
+        MorphoMarketState memory market = MORPHO.market(_morphoMarketId(bd));
+        borrowing = market.totalSupplyAssets - market.totalBorrowAssets;
+        lending = IERC20(bd.spokePt).totalSupply();
+    }
+
+    function _rates(IPLoopPositionBox, BoxData memory bd)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 borrowing, uint256 lending)
+    {
+        MorphoMarketId marketId = _morphoMarketId(bd);
+        MarketParams memory params = MORPHO.idToMarketParams(marketId);
+
+        borrowing = _apy({rate: params.irm.borrowRateView(params, MORPHO.market(marketId)), perSeconds: 1});
+        lending = 0;
+    }
+
+    // ========== Other internal helpers ==========
+
+    function _morphoMarketId(BoxData memory bd) internal pure returns (MorphoMarketId) {
+        return MorphoMarketId.wrap(bd.mmPayload);
+    }
+}