@pendle/core-v2 6.9.0 → 6.10.0

package/contracts/pt-looping/money-market/implementations/aave-v4/AaveV4MoneyMarketView.sol

@@ -0,0 +1,180 @@
+//SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.20;
+
+import {IERC20Metadata as IERC20} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+import {ISpoke} from "./dependencies/ISpoke.sol";
+import {IHubBase} from "./dependencies/IHubBase.sol";
+import {AaveV4MMPayloadLib} from "./AaveV4MMPayloadLib.sol";
+
+import {BaseMoneyMarketView} from "../../BaseMoneyMarketView.sol";
+import {IPLoopPositionBox, BoxData} from "../../../../interfaces/IPLoopPositionBox.sol";
+import {PMath} from "../../../../core/libraries/math/PMath.sol";
+
+contract AaveV4MoneyMarketView is BaseMoneyMarketView {
+    using PMath for uint256;
+
+    constructor(string memory _moneyMarketName, address _ptLooper) BaseMoneyMarketView(_moneyMarketName, _ptLooper) {}
+
+    /// @notice Aave V4 has no separate borrow-LTV / liquidation-threshold pair — `DynamicReserveConfig`
+    /// carries a single `collateralFactor` that serves both roles, so both return values are equal.
+    /// Callers MUST NOT treat `ltv` as a safe borrowing target the way they can on the V3 adapter:
+    /// borrowing to `ltv` here means borrowing to exactly `HF == 1`, i.e. to the liquidation line.
+    /// The entire safety margin must be supplied by the caller's own `postBorrowMaxLTV` haircut.
+    function _thresholds(IPLoopPositionBox box, BoxData memory bd)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 ltv, uint256 liquidationThreshold)
+    {
+        (ISpoke spoke, uint256 collateralReserveId,) = AaveV4MMPayloadLib.unwrap(bd.mmPayload);
+        uint32 dynamicConfigKey = spoke.getUserPosition(collateralReserveId, box.SPOKE_MONEY_MARKET()).dynamicConfigKey;
+        ISpoke.DynamicReserveConfig memory dc = spoke.getDynamicReserveConfig(collateralReserveId, dynamicConfigKey);
+
+        ltv = liquidationThreshold = _bpsToWad(dc.collateralFactor);
+    }
+
+    /// @notice Known limitations:
+    /// The returned `borrowing` accounts for Hub cash and the per-spoke `drawCap`, but not for
+    /// `Hub._applyPremiumDelta`'s aggregate constraint
+    /// `spoke.premiumShares <= spoke.drawnShares.percentMulUp(riskPremiumThreshold)`.
+    /// That threshold is a spoke-wide quantity driven by all borrowers on the spoke, so it cannot
+    /// be meaningfully attributed to a single box and any computed value would be immediately
+    /// stale. A borrow within the returned figure may still revert if the spoke is at its
+    /// premium threshold and this box's collateral carries a high `collateralRisk`.
+    function _liquidity(IPLoopPositionBox, BoxData memory bd)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 borrowing, uint256 lending)
+    {
+        (ISpoke spoke, uint256 collateralReserveId, uint256 debtReserveId) = AaveV4MMPayloadLib.unwrap(bd.mmPayload);
+
+        // lending
+        {
+            ISpoke.Reserve memory collReserve = spoke.getReserve(collateralReserveId);
+            IHubBase.SpokeData memory sd = collReserve.hub.getSpoke(collReserve.assetId, address(spoke));
+            if (sd.addCap == type(uint40).max) {
+                lending = IERC20(collReserve.underlying).totalSupply(); // Infinite supply cap
+            } else {
+                uint256 capAssets = uint256(sd.addCap) * 10 ** collReserve.decimals;
+                uint256 currentAssets = collReserve.hub.previewRemoveByShares(collReserve.assetId, sd.addedShares);
+                lending = capAssets.subMax0(currentAssets);
+            }
+        }
+
+        // borrowing
+        {
+            ISpoke.Reserve memory reserve = spoke.getReserve(debtReserveId);
+            IHubBase hub = reserve.hub;
+            IHubBase.SpokeData memory sd = hub.getSpoke(reserve.assetId, address(spoke));
+            uint256 hubLiquidity = hub.getAsset(reserve.assetId).liquidity;
+            if (sd.drawCap == type(uint40).max) {
+                borrowing = hubLiquidity;
+            } else {
+                uint256 capAssets = uint256(sd.drawCap) * 10 ** reserve.decimals;
+
+                // * `_calculateAggregatedOwedRay`: https://github.com/aave/aave-v4/blob/2524fe4018a42750300e114f2a8c4355df62a878/src/hub/libraries/AssetLogic.sol#L229
+                //      owedAssets = (drawnShares * drawnIndex) + premiumRay + deficitRay
+                // Besides `deficitRay`, the rest is `hub.getSpokeTotalOwed`
+                uint256 owedAssets = hub.getSpokeTotalOwed(reserve.assetId, address(spoke)) + _trimRay(sd.deficitRay);
+                uint256 capHeadroom = capAssets.subMax0(owedAssets);
+                borrowing = PMath.min(hubLiquidity, capHeadroom);
+            }
+        }
+    }
+
+    /// @dev `borrowing` (`_borrowApy`) is position-specific -- includes this box's own risk
+    /// premium (`getUserLastRiskPremium`), a per-position surcharge, not a market-wide figure:
+    /// https://github.com/aave/aave-v4/blob/2524fe4018a42750300e114f2a8c4355df62a878/src/spoke/interfaces/ISpoke.sol#L750
+    /// `lending` (`_lendingApy`) is market-wide -- no single position's premium applies, so it
+    /// folds in premium's *aggregate* contribution via the market's drawn+premium shares instead.
+    /// See `_lendingApy`.
+    function _rates(IPLoopPositionBox box, BoxData memory bd)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 borrowing, uint256 lending)
+    {
+        (ISpoke spoke, uint256 collateralReserveId, uint256 debtReserveId) = AaveV4MMPayloadLib.unwrap(bd.mmPayload);
+
+        uint256 boxRiskPremiumBps = spoke.getUserLastRiskPremium(box.SPOKE_MONEY_MARKET());
+        borrowing = _borrowApyWithPremium(spoke.getReserve(debtReserveId), boxRiskPremiumBps);
+        lending = _lendingApy(spoke.getReserve(collateralReserveId));
+    }
+
+    function _borrowApyWithPremium(ISpoke.Reserve memory reserve, uint256 riskPremiumBps)
+        internal
+        view
+        returns (uint256)
+    {
+        return _aaveV4Apy(_drawnRateWad(reserve).tweakUp(_bpsToWad(riskPremiumBps)));
+    }
+
+    /// @return lendingApy = _apy(drawnRate * usageRatio * (1 - liquidityFee), perSeconds: 365 days)
+    /// - usageRatio (or utilization): `interestBearing / totalValue`
+    function _lendingApy(ISpoke.Reserve memory reserve) internal view returns (uint256) {
+        // * `totalValue` - the real supplier claim base
+        //      totalAddedAssets = liquidity + swept + (drawn+premium+deficit) - realizedFees - unrealizedFees
+        // which is exactly `Hub.getAddedAssets(assetId)` (returns `_assets[assetId].totalAddedAssets()`
+        // directly -- not a shares<->assets conversion, so unlike `previewRemoveByShares` there's no
+        // `SharesMath` virtual-offset rounding)
+        // - https://github.com/aave/aave-v4/blob/2524fe4018a42750300e114f2a8c4355df62a878/src/hub/libraries/AssetLogic.sol#L79-L96
+
+        IHubBase.Asset memory collAsset = reserve.hub.getAsset(reserve.assetId);
+        uint256 totalValue = reserve.hub.getAddedAssets(reserve.assetId);
+
+        if (totalValue == 0) return 0;
+
+        // `interestBearing` must be the principal that `drawnRate` compounds
+        // against going forward, with no offset subtracted
+        //      interestBearing = (drawnShares + premiumShares) * drawnIndex,
+        uint256 interestBearingShares = uint256(collAsset.drawnShares) + collAsset.premiumShares;
+        uint256 interestBearing = reserve.hub.previewRestoreByShares(reserve.assetId, interestBearingShares);
+
+        uint256 drawnRate = _drawnRateWad(reserve);
+        uint256 usageRatio = interestBearing.divDown(totalValue);
+        uint256 supplyApr = drawnRate.mulDown(usageRatio).tweakDown(_bpsToWad(collAsset.liquidityFee));
+        return _aaveV4Apy(supplyApr);
+    }
+
+    function _drawnRateWad(ISpoke.Reserve memory reserve) internal view returns (uint256) {
+        return _rayToWad(reserve.hub.getAssetDrawnRate(reserve.assetId));
+    }
+
+    /// === Internal helpers ===
+
+    /// @dev BaseMoneyMarketView._apy is still used here, by convention, to compound
+    /// daily, uniformly across all money markets so their APYs stay mutually
+    /// comparable.
+    ///
+    /// For Aave V4 in particular, `AssetLogic.accrue` applies linear
+    /// interest per interval and multiplies the index on every Hub interaction,
+    /// so the true compounding frequency equals the asset's interaction
+    /// frequency: this figure understates for busy assets and overstates for
+    /// quiet ones, and is not expected to match Aave's own frontend exactly.
+    ///
+    /// The divergence is ~0.01pp at ordinary rates and only becomes material at
+    /// very high ones.
+    function _aaveV4Apy(uint256 rate) internal pure returns (uint256) {
+        return _apy({rate: rate, perSeconds: 365 days});
+    }
+
+    // BPS (1e4) -> WAD (1e18)
+    function _bpsToWad(uint256 bps) internal pure returns (uint256) {
+        return bps * 1e14;
+    }
+
+    // RAY (1e27) -> WAD (1e18)
+    function _rayToWad(uint256 ray) internal pure returns (uint256) {
+        return ray / 1e9;
+    }
+
+    // RAY (1e27) -> no decimals (1e0)
+    function _trimRay(uint256 ray) internal pure returns (uint256) {
+        return ray / 1e27;
+    }
+}

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

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.20;
+
+/// https://github.com/aave/aave-v4/blob/main/src/spoke/interfaces/IAaveOracle.sol
+/// (and IPriceOracle.sol, which IAaveOracle extends)
+/// Modifications: remove all functions except `getReservePrice`.
+
+interface IAaveOracle {
+    /// @notice Price of one whole unit of the reserve's underlying asset, scaled by `decimals()`.
+    /// @dev Reverts if price <= 0.
+    function getReservePrice(uint256 reserveId) external view returns (uint256);
+}

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

@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.20;
+
+/// https://github.com/aave/aave-v4/blob/main/src/hub/interfaces/IHub.sol
+/// (and IHubBase.sol, which IHub extends)
+/// Modifications:
+/// - Trimmed to the read-only surface needed for rate/liquidity display and share<->asset
+///   conversion. No mutating Hub functions (add/remove/draw/restore/sweep/reclaim/etc) are called
+///   directly by this money market -- all fund movement goes through ISpoke.
+interface IHubBase {
+    struct SpokeData {
+        uint120 drawnShares;
+        uint120 premiumShares;
+        int200 premiumOffsetRay;
+        uint120 addedShares;
+        uint40 addCap;
+        uint40 drawCap;
+        uint24 riskPremiumThreshold;
+        bool active;
+        bool halted;
+        uint200 deficitRay;
+    }
+
+    struct Asset {
+        uint120 liquidity;
+        uint120 realizedFees;
+        uint8 decimals;
+        uint120 addedShares;
+        uint120 swept;
+        int200 premiumOffsetRay;
+        uint120 drawnShares;
+        uint120 premiumShares;
+        uint16 liquidityFee;
+        uint120 drawnIndex;
+        uint96 drawnRate;
+        uint40 lastUpdateTimestamp;
+        address underlying;
+        address irStrategy;
+        address reinvestmentController;
+        address feeReceiver;
+        uint200 deficitRay;
+    }
+
+    /// @notice Current annualized borrow rate for `assetId`, RAY-scaled (1e27) -- same convention
+    /// as Aave V3's `currentVariableBorrowRate`. There is no supply-rate equivalent; V4 exposes
+    /// only this one rate primitive.
+    function getAssetDrawnRate(uint256 assetId) external view returns (uint256);
+
+    function getAsset(uint256 assetId) external view returns (Asset memory);
+
+    /// @notice Per-(asset, spoke) caps and current usage. `addCap`/`drawCap` are expressed in
+    /// whole assets (not scaled by decimals); `type(uint40).max` means uncapped.
+    function getSpoke(uint256 assetId, address spoke) external view returns (SpokeData memory);
+
+    function previewRemoveByShares(uint256 assetId, uint256 shares) external view returns (uint256);
+    function previewRestoreByShares(uint256 assetId, uint256 shares) external view returns (uint256);
+
+    /// @notice The asset-level total value backing all `addedShares` (liquidity + swept + owed -
+    /// fees), already aggregated Hub-side.
+    /// https://github.com/aave/aave-v4/blob/2524fe4018a42750300e114f2a8c4355df62a878/src/hub/Hub.sol#L513-L515
+    /// https://github.com/aave/aave-v4/blob/2524fe4018a42750300e114f2a8c4355df62a878/src/hub/libraries/AssetLogic.sol#L79-L96
+    function getAddedAssets(uint256 assetId) external view returns (uint256);
+
+    /// @notice Total amount of `assetId` owed to the Hub by `spoke` (drawn + premium debt,
+    /// computed internally -- handles the signed premium-offset subtraction itself, so callers
+    /// never need to touch `SpokeData.premiumOffsetRay`'s sign).
+    function getSpokeTotalOwed(uint256 assetId, address spoke) external view returns (uint256);
+
+    /// @notice Total amount of `assetId` owed to the Hub across all spokes (drawn + premium debt,
+    /// Hub-wide) -- the asset-level equivalent of `getSpokeTotalOwed`.
+    function getAssetTotalOwed(uint256 assetId) external view returns (uint256);
+}

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

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.20;
+
+import {IHubBase} from "./IHubBase.sol";
+
+/// https://github.com/aave/aave-v4/blob/main/src/spoke/interfaces/ISpoke.sol
+/// Modifications:
+/// - Trimmed to the structs and functions actually used by EulerMoneyMarket/View's Aave V4
+///   equivalent (initialize/lend/borrow/repay/withdraw/collateralBalance/debtBalance/oracle rate,
+///   plus thresholds/liquidity view queries). Governance, liquidation, and position-manager
+///   surfaces are intentionally omitted -- not called by this money market.
+interface ISpoke {
+    struct Reserve {
+        address underlying;
+        IHubBase hub;
+        uint16 assetId;
+        uint8 decimals;
+        uint24 collateralRisk;
+        uint8 flags;
+        uint32 dynamicConfigKey;
+    }
+
+    struct DynamicReserveConfig {
+        uint16 collateralFactor;
+        uint32 maxLiquidationBonus;
+        uint16 liquidationFee;
+    }
+
+    struct UserPosition {
+        uint120 drawnShares;
+        uint120 premiumShares;
+        int200 premiumOffsetRay;
+        uint120 suppliedShares;
+        uint32 dynamicConfigKey;
+    }
+
+    /// @notice Address of this Spoke's oracle. Public immutable on the real contract (auto-getter).
+    function ORACLE() external view returns (address);
+
+    /// @notice Supplies `amount` of the reserve's underlying, crediting `onBehalfOf`.
+    /// @dev Caller must be `onBehalfOf` or an approved position manager for it -- `msg.sender ==
+    /// onBehalfOf` always satisfies this with zero registration, which is the only case we use.
+    /// @return shares, assets (assets is `amount` echoed back, not a rounded conversion).
+    function supply(uint256 reserveId, uint256 amount, address onBehalfOf) external returns (uint256, uint256);
+
+    /// @return shares, assets actually withdrawn.
+    function withdraw(uint256 reserveId, uint256 amount, address onBehalfOf) external returns (uint256, uint256);
+
+    /// @return shares, assets actually borrowed (echoed back, not rounded).
+    function borrow(uint256 reserveId, uint256 amount, address onBehalfOf) external returns (uint256, uint256);
+
+    /// @return shares, total debt value restored. This is always exactly `min(amount, totalDebt)`:
+    /// `UserPositionUtils.calculateRestoreAmount` splits `amount` into drawn and premium components
+    /// whose sum reconstitutes `amount` exactly (or the full debt, when `amount` covers it), and
+    /// `Spoke.repay` pulls precisely that sum from `msg.sender`. It can never exceed the input, so
+    /// callers may rely on `repaid <= debtBefore` without a saturating subtraction.
+    function repay(uint256 reserveId, uint256 amount, address onBehalfOf) external returns (uint256, uint256);
+
+    /// @notice Enables/disables `reserveId` as collateral for `onBehalfOf`.
+    function setUsingAsCollateral(uint256 reserveId, bool usingAsCollateral, address onBehalfOf) external;
+
+    /// @notice Reverts if the reserve associated with `reserveId` is not listed.
+    function getReserve(uint256 reserveId) external view returns (Reserve memory);
+
+    /// @notice Reverts if `reserveId` is not listed; does not revert if `dynamicConfigKey` is unset.
+    function getDynamicReserveConfig(uint256 reserveId, uint32 dynamicConfigKey)
+        external
+        view
+        returns (DynamicReserveConfig memory);
+
+    /// @notice Assets supplied by `user` for `reserveId`, already resolved from shares to assets.
+    function getUserSuppliedAssets(uint256 reserveId, address user) external view returns (uint256);
+
+    /// @notice Total debt (drawn + risk-premium components already summed) owed by `user` for `reserveId`.
+    function getUserTotalDebt(uint256 reserveId, address user) external view returns (uint256);
+
+    /// @notice Per-user, per-reserve position data. `dynamicConfigKey` here is the config version
+    /// actually pinned to this position -- it can lag `Reserve.dynamicConfigKey` (the reserve's
+    /// current version) until the position's next `borrow`/`withdraw`/`setUsingAsCollateral(true)`
+    /// refreshes it. Use this, not `getReserve(...).dynamicConfigKey`, to read the config that's
+    /// actually enforced for a given position (verified against `Spoke._processUserAccountData`).
+    function getUserPosition(uint256 reserveId, address user) external view returns (UserPosition memory);
+
+    /// @notice The risk premium from `user`'s last position update, in BPS -- a per-position
+    /// surcharge on top of the reserve's base drawn rate, based on the quality of the collateral
+    /// backing their debt. Not reflected in `getAssetDrawnRate`, which is Hub-wide/market-level.
+    function getUserLastRiskPremium(address user) external view returns (uint256);
+}

package/contracts/pt-looping/money-market/implementations/euler/EulerMMPayloadLib.sol

@@ -0,0 +1,25 @@
+//SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.20;
+
+import {IEulerFactory} from "./dependencies/IEulerFactory.sol";
+import {IEulerVault} from "./dependencies/IEulerVault.sol";
+
+/// Library for decoding Euler MM payloads.
+/// - The first 128 bits are the base (PT) vault index.
+/// - The last 128 bits are the quote (debt) vault index.
+library EulerMMPayloadLib {
+    function unwrap(bytes32 payload) internal pure returns (uint128 baseIndex, uint128 quoteIndex) {
+        baseIndex = uint128(uint256(payload) >> 128);
+        quoteIndex = uint128(uint256(payload));
+    }
+
+    function baseVault(IEulerFactory factory, bytes32 payload) internal view returns (IEulerVault) {
+        (uint128 baseIndex,) = unwrap(payload);
+        return IEulerVault(factory.proxyList(baseIndex));
+    }
+
+    function quoteVault(IEulerFactory factory, bytes32 payload) internal view returns (IEulerVault) {
+        (, uint128 quoteIndex) = unwrap(payload);
+        return IEulerVault(factory.proxyList(quoteIndex));
+    }
+}

package/contracts/pt-looping/money-market/implementations/euler/EulerMoneyMarket.sol

@@ -0,0 +1,104 @@
+//SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.20;
+
+import {IERC20Metadata as IERC20} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+import {IEVC} from "./dependencies/IEthereumVaultConnector.sol";
+import {IEulerVault} from "./dependencies/IEulerVault.sol";
+import {IEulerPriceOracle} from "./dependencies/IEulerPriceOracle.sol";
+import {IEulerFactory} from "./dependencies/IEulerFactory.sol";
+
+import {MarketCtx} from "../../../../interfaces/IMoneyMarket.sol";
+import {BaseMoneyMarket} from "../../BaseMoneyMarket.sol";
+import {EulerMMPayloadLib} from "./EulerMMPayloadLib.sol";
+import {PMath} from "../../../../core/libraries/math/PMath.sol";
+
+contract EulerMoneyMarket is BaseMoneyMarket {
+    using PMath for uint256;
+    using EulerMMPayloadLib for IEulerFactory;
+
+    IEVC public immutable EVC;
+    IEulerFactory public immutable FACTORY;
+
+    constructor(address ptLooper, address _evc, address _factory) BaseMoneyMarket(ptLooper) {
+        EVC = IEVC(_evc);
+        FACTORY = IEulerFactory(_factory);
+    }
+
+    function _initialize(MarketCtx memory ctx) internal virtual override {
+        IEulerVault baseVault = FACTORY.baseVault(ctx.mmPayload);
+        IEulerVault quoteVault = FACTORY.quoteVault(ctx.mmPayload);
+        require(baseVault.asset() == ctx.collateral, "EulerMoneyMarket: base vault asset mismatch");
+        require(quoteVault.asset() == ctx.debtAsset, "EulerMoneyMarket: quote vault asset mismatch");
+
+        _safeApproveInf(ctx.collateral, address(baseVault));
+        _safeApproveInf(ctx.debtAsset, address(quoteVault));
+
+        EVC.enableCollateral(address(this), address(baseVault));
+        EVC.enableController(address(this), address(quoteVault));
+
+        // Opt in to reward-stream balance tracking on the collateral (PT) vault.
+        // No-op if the vault has no active reward streams.
+        // Cheap to always call.
+        baseVault.enableBalanceForwarder();
+    }
+
+    /// @dev Function is view, it already reflects accrued interest.
+    function collateralBalance(MarketCtx memory ctx) public view override returns (uint256 balance) {
+        IEulerVault baseVault = FACTORY.baseVault(ctx.mmPayload);
+        return baseVault.convertToAssets(baseVault.balanceOf(address(this)));
+    }
+
+    /// @dev Function is view, it already reflects accrued interest.
+    function debtBalance(MarketCtx memory ctx) public view override returns (uint256 balance) {
+        return FACTORY.quoteVault(ctx.mmPayload).debtOf(address(this));
+    }
+
+    function _lend(MarketCtx memory ctx, uint256 amount) internal virtual override returns (uint256 actualAmount) {
+        _transferIn(ctx.collateral, address(ctx.box), amount);
+        IEulerVault baseVault = FACTORY.baseVault(ctx.mmPayload);
+        uint256 shares = baseVault.deposit(amount, address(this));
+        actualAmount = baseVault.convertToAssets(shares);
+    }
+
+    function _borrow(MarketCtx memory ctx, uint256 amount) internal virtual override returns (uint256 actualAmount) {
+        actualAmount = FACTORY.quoteVault(ctx.mmPayload).borrow(amount, address(ctx.box));
+    }
+
+    function _repay(MarketCtx memory ctx, uint256 amount, uint256 balanceBefore)
+        internal
+        virtual
+        override
+        returns (uint256 actualAmount)
+    {
+        actualAmount = PMath.min(amount, balanceBefore);
+        if (actualAmount > 0) {
+            _transferFrom(IERC20(ctx.debtAsset), address(ctx.box), address(this), actualAmount);
+            actualAmount = FACTORY.quoteVault(ctx.mmPayload).repay(actualAmount, address(this));
+        }
+    }
+
+    function _withdraw(MarketCtx memory ctx, uint256 amount) internal virtual override returns (uint256 actualAmount) {
+        IEulerVault baseVault = FACTORY.baseVault(ctx.mmPayload);
+        baseVault.withdraw(amount, address(ctx.box), address(this));
+        actualAmount = amount;
+    }
+
+    /// @notice Sourced both PT and debt price from the debt (quote) vault's oracle and unitOfAccount,
+    /// because quote vault is the CONTROLLER vault, and Euler's price oracle is scoped per controller vault,
+    /// not global per asset.
+    /// Therefore the quote vault is the canonical price source.
+    function oraclePtDebtRate(MarketCtx memory ctx) public view override returns (uint256) {
+        IEulerVault controllerVault = FACTORY.quoteVault(ctx.mmPayload);
+        IEulerPriceOracle oracle = controllerVault.oracle();
+        address unit = controllerVault.unitOfAccount();
+
+        uint256 collatUnit = 10 ** IERC20(ctx.collateral).decimals();
+        uint256 debtUnit = 10 ** IERC20(ctx.debtAsset).decimals();
+
+        uint256 ptPrice = oracle.getQuote(collatUnit, ctx.collateral, unit);
+        uint256 debtPrice = oracle.getQuote(debtUnit, ctx.debtAsset, unit);
+
+        return (ptPrice * debtUnit).divDown(debtPrice * collatUnit);
+    }
+}

package/contracts/pt-looping/money-market/implementations/euler/EulerMoneyMarketView.sol

@@ -0,0 +1,105 @@
+//SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.20;
+
+import {IERC20Metadata as IERC20} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+import {IEulerVault, AmountCap, NO_CAP} from "./dependencies/IEulerVault.sol";
+import {IEulerFactory} from "./dependencies/IEulerFactory.sol";
+import {EulerMMPayloadLib} from "./EulerMMPayloadLib.sol";
+
+import {BaseMoneyMarketView} from "../../BaseMoneyMarketView.sol";
+import {IPLoopPositionBox, BoxData} from "../../../../interfaces/IPLoopPositionBox.sol";
+import {Reward} from "../../../../interfaces/IMoneyMarketView.sol";
+import {PMath} from "../../../../core/libraries/math/PMath.sol";
+
+contract EulerMoneyMarketView is BaseMoneyMarketView {
+    using EulerMMPayloadLib for IEulerFactory;
+    using PMath for uint256;
+
+    IEulerFactory public immutable FACTORY;
+
+    constructor(string memory _moneyMarketName, address _ptLooper, address _factory)
+        BaseMoneyMarketView(_moneyMarketName, _ptLooper)
+    {
+        FACTORY = IEulerFactory(_factory);
+    }
+
+    /// @notice Known limitations:
+    /// `LTVFull` also returns (initialLiquidationLTV, targetTimestamp,
+    /// rampDuration) for governance LTV ramps, which are discarded here --
+    /// during an active ramp this reports the fully-converged value, which is
+    /// *lower* than the actually-in-effect value (conservative/fail-safe
+    /// direction, but can cause premature LTV-check reactions upstream).
+    /// Documented as a follow-up, not fixed now.
+    function _thresholds(IPLoopPositionBox, BoxData memory bd)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 ltv, uint256 liquidationThreshold)
+    {
+        IEulerVault baseVault = FACTORY.baseVault(bd.mmPayload);
+        IEulerVault quoteVault = FACTORY.quoteVault(bd.mmPayload);
+
+        (uint256 borrowLTV, uint256 liquidationLTV,,,) = quoteVault.LTVFull(baseVault);
+
+        // Euler LTV is bps (1e4). Convert to WAD (1e18) by multiplying by 1e14.
+        ltv = borrowLTV * 1e14;
+        liquidationThreshold = liquidationLTV * 1e14;
+    }
+
+    function _liquidity(IPLoopPositionBox, BoxData memory bd)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 borrowing, uint256 lending)
+    {
+        IEulerVault baseVault = FACTORY.baseVault(bd.mmPayload);
+        IEulerVault quoteVault = FACTORY.quoteVault(bd.mmPayload);
+
+        lending = PMath.min(baseVault.maxDeposit(address(0)), IERC20(bd.spokePt).totalSupply());
+
+        (, AmountCap borrowCapAmt) = quoteVault.caps();
+        uint256 borrowCap = borrowCapAmt.resolve();
+        uint256 quoteVaultCash = quoteVault.cash();
+
+        if (borrowCap == NO_CAP) {
+            borrowing = quoteVaultCash;
+        } else {
+            uint256 borrowRemain = borrowCap.subMax0(quoteVault.totalBorrows());
+            borrowing = PMath.min(quoteVaultCash, borrowRemain);
+        }
+    }
+
+    function _rates(IPLoopPositionBox, BoxData memory bd)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 borrowing, uint256 lending)
+    {
+        borrowing = _borrowingApy(FACTORY.quoteVault(bd.mmPayload));
+        lending = _supplyApy(FACTORY.baseVault(bd.mmPayload));
+    }
+
+    function _borrowingApy(IEulerVault vault) internal view returns (uint256) {
+        // interestRate() is RAY (1e27). Convert to WAD (1e18) by dividing by 1e9.
+        return _apy({rate: vault.interestRate() / 1e9, perSeconds: 1});
+    }
+
+    uint256 private constant EULER_CONFIG_SCALE = 1e4;
+
+    // See Euler's `UtilLens._computeAPYs`: https://github.com/euler-xyz/evk-periphery/blob/6e41cbec944920b30dfcccbcbfb563b4c4d3d932/src/Lens/Utils.sol#L106
+    function _supplyApy(IEulerVault vault) internal view returns (uint256) {
+        uint256 borrows = vault.totalBorrows();
+        uint256 totalAssets = vault.cash() + borrows;
+        if (totalAssets == 0) return 0;
+
+        uint256 borrowingApy = _borrowingApy(vault);
+        uint256 interestFee = vault.interestFee();
+
+        // verbatim formula: https://github.com/euler-xyz/evk-periphery/blob/6e41cbec944920b30dfcccbcbfb563b4c4d3d932/src/Lens/Utils.sol#L120
+        return borrowingApy * borrows * (EULER_CONFIG_SCALE - interestFee) / totalAssets / EULER_CONFIG_SCALE;
+    }
+}