@pendle/core-v2 6.7.1 → 6.8.0

package/contracts/pt-looping/loop-position-box/LoopPositionBoxFactory.sol

@@ -0,0 +1,123 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.30;
+
+import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
+
+import {BoringOwnableUpgradeableV2} from "../../core/libraries/BoringOwnableUpgradeableV2.sol";
+import {IMoneyMarket, createMarketCtx} from "../../interfaces/IMoneyMarket.sol";
+import {BoxData, IPLoopPositionBox} from "../../interfaces/IPLoopPositionBox.sol";
+import {IPLoopPositionBoxFactory} from "../../interfaces/IPLoopPositionBoxFactory.sol";
+
+contract LoopPositionBoxFactory is IPLoopPositionBoxFactory, BoringOwnableUpgradeableV2 {
+    /// @dev creation code of OpenZeppelin's BeaconProxy
+    address public immutable BEACON_PROXY_CODE_CONTRACT;
+    address public immutable POSITION_BOX_BEACON;
+    bytes32 public immutable POSITION_BOX_CODE_HASH;
+
+    /// @dev Domain separator string baked into every boxId hash. Must not change — would
+    /// invalidate every previously-registered box.
+    string private constant BOX_ID_DOMAIN = "LoopPositionBox";
+
+    mapping(bytes32 boxId => BoxData) internal _boxData;
+
+    constructor(address _beaconProxyCodeContract, address _positionBoxBeacon) {
+        _disableInitializers();
+        BEACON_PROXY_CODE_CONTRACT = _beaconProxyCodeContract;
+        POSITION_BOX_BEACON = _positionBoxBeacon;
+        POSITION_BOX_CODE_HASH = keccak256(_beaconProxyInitCodeNoData(_positionBoxBeacon));
+    }
+
+    function initialize(address _owner) public initializer {
+        __BoringOwnableV2_init(_owner);
+    }
+
+    function boxData(bytes32 boxId) public view returns (BoxData memory bd) {
+        bd = _boxData[boxId];
+        require(bd.hubPt != address(0), "LoopPositionBoxFactory: box not registered");
+    }
+
+    function getBoxId(BoxData memory bd) public pure returns (bytes32) {
+        return keccak256(abi.encode(BOX_ID_DOMAIN, bd));
+    }
+
+    function computePositionBox(address owner, bytes32 boxId)
+        public
+        view
+        returns (address box, bytes32 salt, bool deployed)
+    {
+        salt = keccak256(abi.encode(owner, boxId));
+        box = Create2.computeAddress(salt, POSITION_BOX_CODE_HASH);
+        deployed = box.code.length > 0;
+    }
+
+    function computeMoneyMarket(address owner, bytes32 boxId)
+        public
+        view
+        returns (address computedAddr, bytes32 salt, bool deployed)
+    {
+        (computedAddr,, salt, deployed,) = _computeMoneyMarket(owner, boxId);
+    }
+
+    function _computeMoneyMarket(address owner, bytes32 boxId)
+        internal
+        view
+        returns (address computedAddr, bytes memory mmInitCode, bytes32 salt, bool deployed, BoxData memory bd)
+    {
+        bd = boxData(boxId);
+        if (bd.spokeChainId != block.chainid) {
+            return (address(0), "", bytes32(0), false, bd);
+        }
+
+        salt = keccak256(abi.encode(owner, boxId));
+        mmInitCode = _beaconProxyInitCodeNoData(bd.spokeMMBeacon);
+        computedAddr = Create2.computeAddress(salt, keccak256(mmInitCode));
+        deployed = computedAddr.code.length > 0;
+    }
+
+    function deployPositionBoxAndMoneyMarket(address owner, bytes32 boxId)
+        external
+        returns (IPLoopPositionBox box, IMoneyMarket mm, BoxData memory bd)
+    {
+        (address boxAddr, bytes32 boxSalt, bool boxDeployed) = computePositionBox(owner, boxId);
+        box = IPLoopPositionBox(payable(boxAddr));
+
+        (address mmAddr, bytes memory mmInitCode, bytes32 mmSalt, bool mmDeployed, BoxData memory _bd) =
+            _computeMoneyMarket(owner, boxId);
+
+        mm = IMoneyMarket(mmAddr);
+        bd = _bd;
+        if (mmAddr != address(0) && !mmDeployed) {
+            assert(Create2.deploy(0, mmSalt, mmInitCode) == mmAddr);
+            mm.initialize(createMarketCtx(box, bd));
+        }
+
+        if (!boxDeployed) {
+            bytes memory bytecode = _beaconProxyInitCodeNoData(POSITION_BOX_BEACON);
+            assert(Create2.deploy(0, boxSalt, bytecode) == boxAddr);
+
+            (address ptToApprove, address debtTokenToApprove) =
+                address(mm) == address(0) ? (address(0), address(0)) : (bd.spokePt, bd.spokeDebtToken);
+            box.initialize(owner, boxId, address(mm), ptToApprove, debtTokenToApprove);
+        }
+    }
+
+    // ========== Admin functions ==========
+
+    function registerBoxData(BoxData calldata bd) external onlyOwner returns (bytes32 boxId) {
+        require(
+            bd.hubChainId == block.chainid || bd.spokeChainId == block.chainid,
+            "LoopPositionBoxFactory: invalid chain id"
+        );
+
+        boxId = getBoxId(bd);
+        _boxData[boxId] = bd;
+
+        emit BoxDataRegistered(boxId, bd);
+    }
+
+    // ========== Internal helpers ==========
+
+    function _beaconProxyInitCodeNoData(address beacon) internal view returns (bytes memory) {
+        return abi.encodePacked(BEACON_PROXY_CODE_CONTRACT.code, abi.encode(beacon, ""));
+    }
+}

package/contracts/pt-looping/money-market/BaseMoneyMarket.sol

@@ -0,0 +1,129 @@
+//SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.20;
+
+import {TokenHelper} from "../../core/libraries/TokenHelper.sol";
+import {IMoneyMarket, MarketCtx} from "../../interfaces/IMoneyMarket.sol";
+import {IPLoopPositionBoxFactory} from "../../interfaces/IPLoopPositionBoxFactory.sol";
+import {IPPTLooper} from "../../interfaces/IPPTLooper.sol";
+
+abstract contract BaseMoneyMarket is IMoneyMarket, TokenHelper {
+    IPPTLooper public immutable PT_LOOPER;
+    IPLoopPositionBoxFactory public immutable POSITION_BOX_FACTORY;
+
+    constructor(address ptLooper) {
+        PT_LOOPER = IPPTLooper(ptLooper);
+        POSITION_BOX_FACTORY = PT_LOOPER.POSITION_BOX_FACTORY();
+    }
+
+    modifier onlyPtLooper() {
+        require(msg.sender == address(PT_LOOPER), "MoneyMarket: unauthorized");
+        _;
+    }
+
+    modifier onlyPositionBoxFactory() {
+        require(msg.sender == address(POSITION_BOX_FACTORY), "MoneyMarket: unauthorized");
+        _;
+    }
+
+    function initialize(MarketCtx memory ctx) external override onlyPositionBoxFactory {
+        _initialize(ctx);
+    }
+
+    function lend(MarketCtx memory ctx, uint256 amount)
+        external
+        override
+        onlyPtLooper
+        returns (uint256 lent, uint256 postCollateralBalance)
+    {
+        uint256 balanceBefore = collateralBalance(ctx);
+        if (amount == 0) return (0, balanceBefore);
+        lent = _lend(ctx, amount);
+        postCollateralBalance = lent + balanceBefore;
+        emit Lent(ctx.box, ctx.collateral, lent, balanceBefore);
+    }
+
+    function withdraw(MarketCtx memory ctx, uint256 amount)
+        external
+        override
+        onlyPtLooper
+        returns (uint256 withdrawn, uint256 postCollateralBalance)
+    {
+        uint256 balanceBefore = collateralBalance(ctx);
+        if (amount == 0 || balanceBefore == 0) return (0, balanceBefore);
+        withdrawn = _withdraw(ctx, amount);
+        postCollateralBalance = balanceBefore - withdrawn;
+        emit Withdrawn(ctx.box, ctx.collateral, withdrawn, balanceBefore);
+    }
+
+    function borrow(MarketCtx memory ctx, uint256 amount)
+        external
+        override
+        onlyPtLooper
+        returns (uint256 borrowed, uint256 postDebtBalance)
+    {
+        uint256 balanceBefore = debtBalance(ctx);
+        if (amount == 0) return (0, balanceBefore);
+        borrowed = _borrow(ctx, amount);
+        postDebtBalance = borrowed + balanceBefore;
+        emit Borrowed(ctx.box, ctx.debtAsset, borrowed, balanceBefore);
+    }
+
+    function repay(MarketCtx memory ctx, uint256 amount)
+        external
+        override
+        onlyPtLooper
+        returns (uint256 repaid, uint256 postDebtBalance)
+    {
+        uint256 balanceBefore = debtBalance(ctx);
+        if (amount == 0 || balanceBefore == 0) return (0, balanceBefore);
+        repaid = _repay(ctx, amount, balanceBefore);
+        postDebtBalance = balanceBefore - repaid;
+        emit Repaid(ctx.box, ctx.debtAsset, repaid, balanceBefore);
+    }
+
+    function claimRewards(
+        MarketCtx memory ctx,
+        address extRewardController,
+        bytes calldata data,
+        address[] memory rewardTokens
+    ) external onlyPtLooper returns (uint256[] memory claimedAmount) {
+        uint256 n = rewardTokens.length;
+        uint256[] memory preBalance = new uint256[](n);
+        for (uint256 i = 0; i < n; ++i) {
+            preBalance[i] = _selfBalance(rewardTokens[i]);
+        }
+
+        (bool success,) = extRewardController.call(data);
+        require(success, "MoneyMarket: claimRewards failed");
+
+        address owner = ctx.box.OWNER();
+        claimedAmount = new uint256[](n);
+        for (uint256 i = 0; i < n; ++i) {
+            claimedAmount[i] = _selfBalance(rewardTokens[i]) - preBalance[i];
+            _transferOut(rewardTokens[i], owner, claimedAmount[i]);
+        }
+
+        emit RewardsClaimed(extRewardController, rewardTokens, claimedAmount);
+    }
+
+    // ========== View functions ==========
+
+    function collateralBalance(MarketCtx memory ctx) public virtual returns (uint256);
+    function debtBalance(MarketCtx memory ctx) public virtual returns (uint256);
+    function oraclePtDebtRate(MarketCtx memory ctx) public view virtual returns (uint256 rate);
+
+    // ========== Internal implementation ==========
+
+    function _initialize(MarketCtx memory ctx) internal virtual;
+
+    function _lend(MarketCtx memory ctx, uint256 amount) internal virtual returns (uint256 actualAmount);
+
+    function _withdraw(MarketCtx memory ctx, uint256 amount) internal virtual returns (uint256 actualAmount);
+
+    function _borrow(MarketCtx memory ctx, uint256 amount) internal virtual returns (uint256 actualAmount);
+
+    function _repay(MarketCtx memory ctx, uint256 amount, uint256 balanceBefore)
+        internal
+        virtual
+        returns (uint256 actualAmount);
+}

package/contracts/pt-looping/money-market/BaseMoneyMarketView.sol

@@ -0,0 +1,123 @@
+//SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.20;
+
+import {IPPTLooper} from "../../interfaces/IPPTLooper.sol";
+import {IMoneyMarketView, Reward, Limits} from "../../interfaces/IMoneyMarketView.sol";
+import {IMoneyMarket, MarketCtx, createMarketCtx} from "../../interfaces/IMoneyMarket.sol";
+import {IPLoopPositionBoxFactory} from "../../interfaces/IPLoopPositionBoxFactory.sol";
+import {IPLoopPositionBox, BoxData} from "../../interfaces/IPLoopPositionBox.sol";
+import {LogExpMath} from "../../core/libraries/math/LogExpMath.sol";
+import {PMath} from "../../core/libraries/math/PMath.sol";
+
+abstract contract BaseMoneyMarketView is IMoneyMarketView {
+    using LogExpMath for uint256;
+
+    string public override moneyMarketName;
+    IPPTLooper public immutable PT_LOOPER;
+    IPLoopPositionBoxFactory public immutable POSITION_BOX_FACTORY;
+
+    uint256 private constant DAYS_PER_YEAR_SCALED = 365e18;
+
+    constructor(string memory _moneyMarketName, address _ptLooper) {
+        moneyMarketName = _moneyMarketName;
+        PT_LOOPER = IPPTLooper(_ptLooper);
+        POSITION_BOX_FACTORY = PT_LOOPER.POSITION_BOX_FACTORY();
+    }
+
+    function moneyMarketBalances(IPLoopPositionBox box)
+        public
+        override
+        returns (uint256 mmPtBalance, uint256 mmDebtBalance)
+    {
+        return _moneyMarketBalances(box, _boxData(box));
+    }
+
+    function thresholds(IPLoopPositionBox box)
+        public
+        view
+        override
+        returns (uint256 ltv, uint256 liquidationThreshold)
+    {
+        return _thresholds(box, _boxData(box));
+    }
+
+    function liquidity(IPLoopPositionBox box) public view override returns (uint256 borrowing, uint256 lending) {
+        return _liquidity(box, _boxData(box));
+    }
+
+    function rewards(IPLoopPositionBox box)
+        public
+        override
+        returns (Reward[] memory borrowing, Reward[] memory lending)
+    {
+        return _rewards(box, _boxData(box));
+    }
+
+    function limits(IPLoopPositionBox box) public view override returns (Limits memory limits_) {
+        return _limits(box, _boxData(box));
+    }
+
+    function rates(IPLoopPositionBox box) public view override returns (uint256 borrowing, uint256 lending) {
+        return _rates(box, _boxData(box));
+    }
+
+    function ptDebtRate(IPLoopPositionBox box) public view override returns (uint256) {
+        return _ptDebtRate(box, _boxData(box));
+    }
+
+    function _moneyMarketBalances(IPLoopPositionBox box, BoxData memory bd)
+        internal
+        virtual
+        returns (uint256 mmPtBalance, uint256 mmDebtBalance)
+    {
+        IMoneyMarket spokeMM = IMoneyMarket(box.SPOKE_MONEY_MARKET());
+        MarketCtx memory ctx = createMarketCtx(box, bd);
+        mmPtBalance = spokeMM.collateralBalance(ctx);
+        mmDebtBalance = spokeMM.debtBalance(ctx);
+    }
+
+    function _ptDebtRate(IPLoopPositionBox box, BoxData memory bd) internal view virtual returns (uint256) {
+        return IMoneyMarket(box.SPOKE_MONEY_MARKET()).oraclePtDebtRate(createMarketCtx(box, bd));
+    }
+
+    function _thresholds(IPLoopPositionBox box, BoxData memory bd)
+        internal
+        view
+        virtual
+        returns (uint256 ltv, uint256 liquidationThreshold);
+
+    function _liquidity(IPLoopPositionBox box, BoxData memory bd)
+        internal
+        view
+        virtual
+        returns (uint256 borrowing, uint256 lending);
+
+    function _rates(IPLoopPositionBox box, BoxData memory bd)
+        internal
+        view
+        virtual
+        returns (uint256 borrowing, uint256 lending);
+
+    function _rewards(IPLoopPositionBox box, BoxData memory bd)
+        internal
+        virtual
+        returns (Reward[] memory borrowing, Reward[] memory lending)
+    {}
+
+    function _boxData(IPLoopPositionBox box) internal view virtual returns (BoxData memory) {
+        return POSITION_BOX_FACTORY.boxData(box.BOX_ID());
+    }
+
+    /// @dev `rate` is a per-`perSeconds` WAD growth factor. Callers must pre-normalize:
+    /// Aave passes `perSeconds = 365 days` (annual WAD) and Morpho passes `perSeconds = 1`
+    /// (already per-second WAD). Returns the compounded APY in WAD.
+    function _apy(uint256 rate, uint256 perSeconds) internal pure returns (uint256) {
+        uint256 dailyRate = rate * 1 days / perSeconds;
+        return (dailyRate + PMath.ONE).pow(DAYS_PER_YEAR_SCALED) - PMath.ONE;
+    }
+
+    function _limits(IPLoopPositionBox, BoxData memory) internal view virtual returns (Limits memory limits_) {
+        limits_.minBorrowing = limits_.minLending = limits_.minBorrowingForRewards = limits_.minLendingForRewards = 0;
+        limits_.maxBorrowing = limits_.maxLending = type(uint256).max;
+    }
+}

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

@@ -0,0 +1,16 @@
+//SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.20;
+
+/// @dev Encoding:
+/// - first byte: to encode eModeCategoryId
+/// - second byte, bit 0: isolationMode flag
+/// @dev eModeCategoryId == 0 means no eMode
+library AaveMMPayloadLib {
+    uint256 private constant ISOLATION_MODE_MASK = 1 << 8;
+
+    function unwrap(bytes32 payload) internal pure returns (uint8 eModeCategoryId, bool isolationMode) {
+        uint256 rawPayload = uint256(payload);
+        eModeCategoryId = uint8(rawPayload);
+        isolationMode = (rawPayload & ISOLATION_MODE_MASK) != 0;
+    }
+}

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

@@ -0,0 +1,123 @@
+//SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.20;
+
+import {IERC20Metadata as IERC20} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+import {IPool} from "./dependencies/IPool.sol";
+import {IPoolAddressesProvider} from "./dependencies/IPoolAddressesProvider.sol";
+import {AaveDataTypes} from "./dependencies/AaveDataTypes.sol";
+import {IAaveOracle} from "./dependencies/IAaveOracle.sol";
+
+import {MarketCtx} from "../../../../interfaces/IMoneyMarket.sol";
+import {BaseMoneyMarket} from "../../BaseMoneyMarket.sol";
+import {AaveMMPayloadLib} from "./AaveMMPayloadLib.sol";
+import {PMath} from "../../../../core/libraries/math/PMath.sol";
+
+contract AaveMoneyMarket is BaseMoneyMarket {
+    IPoolAddressesProvider public immutable poolAddressesProvider;
+
+    constructor(address ptLooper, address _poolAddressesProvider) BaseMoneyMarket(ptLooper) {
+        poolAddressesProvider = IPoolAddressesProvider(_poolAddressesProvider);
+    }
+
+    function pool() public view virtual returns (IPool) {
+        return poolAddressesProvider.getPool();
+    }
+
+    function oracle() public view virtual returns (IAaveOracle) {
+        return poolAddressesProvider.getPriceOracle();
+    }
+
+    // ========== IMoneyMarket ==========
+
+    function _initialize(MarketCtx memory ctx) internal virtual override {
+        IPool _pool = pool();
+
+        (uint8 eModeCategoryId,) = AaveMMPayloadLib.unwrap(ctx.mmPayload);
+        _pool.setUserEMode(eModeCategoryId);
+
+        _safeApproveInf(ctx.collateral, address(_pool));
+        _safeApproveInf(ctx.debtAsset, address(_pool));
+    }
+
+    function collateralBalance(MarketCtx memory ctx) public view override returns (uint256 balance) {
+        return _aToken(pool(), ctx.collateral).balanceOf(address(this));
+    }
+
+    function debtBalance(MarketCtx memory ctx) public view override returns (uint256 balance) {
+        return _vToken(pool(), ctx.debtAsset).balanceOf(address(this));
+    }
+
+    function _lend(MarketCtx memory ctx, uint256 amount) internal virtual override returns (uint256 actualAmount) {
+        IPool _pool = pool();
+        address asset = ctx.collateral;
+        _transferFrom(IERC20(asset), address(ctx.box), address(this), amount);
+        _pool.supply({asset: asset, amount: amount, onBehalfOf: address(this), referralCode: 0});
+
+        actualAmount = amount;
+
+        (, bool isolationMode) = AaveMMPayloadLib.unwrap(ctx.mmPayload);
+        if (isolationMode) {
+            _pool.setUserUseReserveAsCollateral(asset, true);
+        }
+    }
+
+    function _borrow(MarketCtx memory ctx, uint256 amount) internal virtual override returns (uint256 actualAmount) {
+        address asset = ctx.debtAsset;
+        pool()
+            .borrow({
+            asset: asset,
+            amount: amount,
+            interestRateMode: uint8(AaveDataTypes.InterestRateMode.VARIABLE),
+            onBehalfOf: address(this),
+            referralCode: 0
+        });
+
+        _transferOut(asset, address(ctx.box), amount);
+        actualAmount = amount;
+    }
+
+    function _repay(MarketCtx memory ctx, uint256 amount, uint256 balanceBefore)
+        internal
+        virtual
+        override
+        returns (uint256 actualAmount)
+    {
+        actualAmount = PMath.min(amount, balanceBefore);
+        if (actualAmount > 0) {
+            address asset = ctx.debtAsset;
+            _transferFrom(IERC20(asset), address(ctx.box), address(this), actualAmount);
+            actualAmount =
+                pool().repay(asset, actualAmount, uint8(AaveDataTypes.InterestRateMode.VARIABLE), address(this));
+        }
+    }
+
+    function _withdraw(MarketCtx memory ctx, uint256 amount) internal virtual override returns (uint256 actualAmount) {
+        actualAmount = pool().withdraw(ctx.collateral, amount, address(ctx.box));
+    }
+
+    function _aToken(IPool _pool, address asset) internal view virtual returns (IERC20) {
+        return IERC20(_pool.getReserveData(IERC20(asset)).aTokenAddress);
+    }
+
+    function _vToken(IPool _pool, address asset) internal view virtual returns (IERC20) {
+        return IERC20(_pool.getReserveData(IERC20(asset)).variableDebtTokenAddress);
+    }
+
+    /// @dev `mmPayload` unused: Aave's price oracle is queried directly by asset address.
+    function oraclePtDebtRate(MarketCtx memory ctx) public view override returns (uint256) {
+        IAaveOracle _oracle = oracle();
+        uint256 ptPrice = _oraclePrice(_oracle, ctx.collateral);
+        uint256 debtPrice = _oraclePrice(_oracle, ctx.debtAsset);
+
+        // Aave oracle: price of 1 whole token in USD (1e8 base), not per raw unit.
+        return ptPrice * PMath.ONE * 10 ** IERC20(ctx.debtAsset).decimals()
+            / (debtPrice * 10 ** IERC20(ctx.collateral).decimals());
+    }
+
+    // ========== Internal helpers ==========
+
+    function _oraclePrice(IAaveOracle _oracle, address asset) internal view virtual returns (uint256) {
+        return _oracle.getAssetPrice(IERC20(asset));
+    }
+}