@pendle/core-v2 6.7.1 → 6.8.0

package/contracts/interfaces/IPLoopPositionBox.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IMoneyMarket} from "./IMoneyMarket.sol";
+import {ApprovedCall} from "./IPDepositBox.sol";
+
+struct BoxData {
+    uint32 hubChainId;
+    uint32 spokeChainId;
+
+    address hubPt;
+    address hubDebtToken;
+    address spokePt;
+    address spokeDebtToken;
+
+    address spokeMMBeacon;
+    // money market's specific payload
+    bytes32 mmPayload;
+}
+
+interface IPLoopPositionBox {
+    function MANAGER() external view returns (address);
+    function OWNER() external view returns (address);
+    function BOX_ID() external view returns (bytes32);
+    function SPOKE_MONEY_MARKET() external view returns (address);
+
+    function initialize(
+        address owner,
+        bytes32 boxId,
+        address spokeMoneyMarket,
+        address ptToApprove,
+        address debtTokenToApprove
+    ) external;
+
+    function withdrawTo(address to, address token, uint256 amount) external;
+
+    function approveAndCall(ApprovedCall memory call, address nativeRefund) external payable returns (bytes memory);
+}

package/contracts/interfaces/IPLoopPositionBoxFactory.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IMoneyMarket} from "./IMoneyMarket.sol";
+import {BoxData, IPLoopPositionBox} from "./IPLoopPositionBox.sol";
+
+interface IPLoopPositionBoxFactory {
+    event BoxDataRegistered(bytes32 indexed boxId, BoxData boxData);
+
+    function boxData(bytes32 boxId) external view returns (BoxData memory);
+
+    function computePositionBox(address owner, bytes32 boxId)
+        external
+        view
+        returns (address box, bytes32 salt, bool deployed);
+
+    /// @notice return computedAddr == address(0) when not on spoke chain
+    function computeMoneyMarket(address owner, bytes32 boxId)
+        external
+        view
+        returns (address computedAddr, bytes32 salt, bool deployed);
+
+    /// @notice return mm == address(0) when not on spoke chain
+    function deployPositionBoxAndMoneyMarket(address owner, bytes32 boxId)
+        external
+        returns (IPLoopPositionBox box, IMoneyMarket mm, BoxData memory boxData);
+
+    function BEACON_PROXY_CODE_CONTRACT() external view returns (address);
+
+    function POSITION_BOX_BEACON() external view returns (address);
+
+    function POSITION_BOX_CODE_HASH() external view returns (bytes32);
+
+    // ========== Admin functions ==========
+
+    function registerBoxData(BoxData calldata boxData) external returns (bytes32 boxId);
+}

package/contracts/interfaces/IPPTLooper.sol

@@ -0,0 +1,301 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IPLoopPositionBox} from "./IPLoopPositionBox.sol";
+import {IPLoopPositionBoxFactory} from "./IPLoopPositionBoxFactory.sol";
+import {IPPostPtLoopStateChecker} from "../interfaces/IPPostPtLoopStateChecker.sol";
+
+interface IPPTLooperEIP712Types {
+    /// @notice Per-iteration permit, proposer-signed. Binds the iteration to a `(owner, boxId)`
+    /// session; `nonce` matches `proposerNonce[owner][requestHash]`.
+    struct BoxPermit {
+        address owner;
+        bytes32 boxId;
+        uint256 expiry;
+        uint256 nonce;
+    }
+
+    /// @notice Shared header on every user-signed request. `sessionNonce` bumps on
+    /// `terminateSession` (defeats cross-session replay); `permitNonceCap` caps iterations.
+    struct RequestHeader {
+        bytes32 boxId;
+        uint256 expiry;
+        uint32 sessionNonce;
+        uint32 permitNonceCap;
+        uint256 swapBridgeSlippage;
+        bytes offchainMetadata;
+    }
+
+    struct BoxApprovedCall {
+        address extRouter;
+        address approve;
+        bytes callData;
+    }
+
+    /// @notice Bridge parameters shared by every cross-chain message.
+    /// - `call`: the bridge router approve+call payload.
+    /// - `maxAmount`: per-iteration cap on the bridged amount (proposer-imposed).
+    /// - `nativeFee`: native fee forwarded to the bridge call.
+    struct BridgeData {
+        BoxApprovedCall call;
+        uint256 maxAmount;
+        uint256 nativeFee;
+    }
+
+    struct IncreasePositionRequest {
+        RequestHeader header;
+        /// First iteration data. User can directly transfer any token into the box.
+        /// See `IncreasePositionMessage`.
+        address initTokenIn;
+        uint256 initMinToPtSwapRate;
+
+        uint256 minDebtToPtSwapRate;
+        uint256 postBorrowMaxLTV;
+        /// @notice when true, the "swap" is a 1:1 PT+YT mint via SY; the co-minted YT is
+        ///         immediately withdrawn to the owner.
+        bool isZeroPriceImpact;
+
+        /// @notice maximum fee rate allowed based on the amount of token in.
+        /// See `IncreasePositionMessage.fee`.
+        uint256 maxFeeRate;
+    }
+
+    struct IncreasePositionMessage {
+        BoxPermit permit;
+        // Hub-only.
+        /// @notice In the first iteration, swap initTokenIn->PT. Fee is in initTokenIn.
+        /// @notice In subsequent iterations, swap debtToken->PT. Fee is in debtToken.
+        /// @notice Set extRouter to address(0) to disable swapping.
+        BoxApprovedCall swap;
+        uint256 fee;
+
+        // Cross-chain only: hub bridges PT to spoke; spoke bridges debt back to hub.
+        BridgeData bridge;
+        // Spoke-only: lend then borrow.
+        uint256 amountDebtBorrowed;
+
+        bytes postStateCheckData;
+    }
+
+    struct DecreasePositionRequest {
+        RequestHeader header;
+        uint256 minPtToDebtSwapRate;
+        uint256 postWithdrawMaxLTV;
+    }
+
+    struct DecreasePositionMessage {
+        BoxPermit permit;
+        // Hub-only: swap PT→debtToken.
+        /// @notice Set extRouter to address(0) to disable swapping.
+        BoxApprovedCall swap;
+        // Cross-chain only: hub bridges debt to spoke; spoke bridges PT back to hub.
+        BridgeData bridge;
+        // Spoke-only: repay then withdraw.
+        uint256 amountPtWithdrawn;
+
+        bytes postStateCheckData;
+    }
+
+    /// @notice Withdraw the current `hubDebtToken`. Supports both orderings:
+    /// - swap-then-bridge: `hubDebtToken -> hubTokenOut -> dstTokenOut`
+    /// - bridge-then-swap: `hubDebtToken -> spokeDebtToken -> dstTokenOut` (set `hubTokenOut = hubDebtToken`)
+    /// @notice `minTokenWithdrawn` is the minimum amount of `hubTokenOut`/`dstTokenOut` to move out from box.
+    struct SwapBridgeWithdrawAllRequest {
+        RequestHeader header;
+        bool receiveOnSpoke;
+        address hubTokenOut;
+        address dstTokenOut;
+        uint256 minTokenWithdrawn;
+    }
+
+    struct SwapBridgeWithdrawAllMessage {
+        BoxPermit permit;
+        BoxApprovedCall swap;
+        BridgeData bridge;
+
+        bytes postStateCheckData;
+    }
+
+    struct ClaimMMRewardsRequest {
+        RequestHeader header;
+        address extRewardController;
+        bytes data;
+        address[] rewardTokens;
+    }
+
+    struct ClaimMMRewardsMessage {
+        BoxPermit permit;
+    }
+}
+
+interface IPPTLooper is IPPTLooperEIP712Types {
+    struct UserRequestInfo {
+        bytes32 requestHash;
+        uint32 sessionNonce;
+    }
+
+    /// @notice Emitted on the first iteration call of a session, when the implicit init branch
+    /// runs (owner signature verified, `userReq.requestHash` set). `sessionNonce` is the
+    /// pre-increment value the session was opened with.
+    event SessionInitiated(address indexed owner, bytes32 indexed boxId, bytes32 requestHash, uint32 sessionNonce);
+
+    /// @notice Emitted by `terminateSession`. `sessionNonce` is the post-increment value that
+    /// the next user request must match.
+    event SessionTerminated(address indexed owner, bytes32 indexed boxId, bytes32 requestHash, uint32 sessionNonce);
+
+    event SetExecutor(address executor);
+
+    event SetProposer(address proposer);
+
+    event TokenSwapped(
+        IPLoopPositionBox indexed box,
+        address indexed tokenIn,
+        uint256 netIn,
+        address indexed tokenOut,
+        uint256 netSwappedOut
+    );
+
+    event TokenBridged(IPLoopPositionBox indexed box, address indexed token, uint256 amount);
+
+    event MoneyMarketLentThenBorrowed(IPLoopPositionBox indexed box, uint256 ptLent, uint256 debtBorrowed);
+
+    event MoneyMarketRepaidThenWithdrawn(IPLoopPositionBox indexed box, uint256 debtRepaid, uint256 ptWithdrawn);
+
+    event PositionIncreased(
+        address indexed owner,
+        bytes32 indexed boxId,
+        bytes32 requestHash,
+        uint256 nonce,
+        /// @notice this field is filled only on hub chain
+        /// @notice on first iteration, this is the balance of initTokenIn
+        uint256 preInBalance,
+        uint256 netPtToMM,
+        /// @notice this field is filled only on spoke chain
+        uint256 postDebtBalance
+    );
+
+    event PositionDecreased(
+        address indexed owner,
+        bytes32 indexed boxId,
+        bytes32 requestHash,
+        uint256 nonce,
+        /// @notice this field is filled only on spoke chain
+        uint256 preDebtBalance,
+        uint256 netPtToSwap,
+        /// @notice this field is filled only on hub chain
+        uint256 postDebtBalance
+    );
+
+    event Withdrawn(
+        address indexed owner,
+        bytes32 indexed boxId,
+        bytes32 requestHash,
+        uint256 nonce,
+        address tokenOut,
+        uint256 netOut
+    );
+
+    event RewardsClaimed(
+        address indexed owner,
+        bytes32 indexed boxId,
+        bytes32 requestHash,
+        uint256 nonce,
+        address[] rewardTokens,
+        uint256[] claimedAmounts
+    );
+
+    // ========== Getters ==========
+
+    function POSITION_BOX_FACTORY() external view returns (IPLoopPositionBoxFactory);
+
+    function POST_LOOP_STATE_CHECKER() external view returns (IPPostPtLoopStateChecker);
+
+    function executor() external view returns (address);
+
+    function proposer() external view returns (address);
+
+    function proposerNonce(address owner, bytes32 requestHash) external view returns (uint256);
+
+    function userRequest(address owner, bytes32 boxId) external view returns (UserRequestInfo memory);
+
+    // ========== Hash functions (exposed for off-chain typed-data tooling) ==========
+
+    function hashRaw(BoxPermit memory permit) external pure returns (bytes32);
+
+    function hashRaw(RequestHeader memory header) external pure returns (bytes32);
+
+    function hashRaw(BoxApprovedCall memory call) external pure returns (bytes32);
+
+    function hashRaw(BridgeData memory bridge) external pure returns (bytes32);
+
+    function hashRaw(IncreasePositionRequest memory req) external pure returns (bytes32);
+
+    function hashRaw(DecreasePositionRequest memory req) external pure returns (bytes32);
+
+    function hashRaw(SwapBridgeWithdrawAllRequest memory req) external pure returns (bytes32);
+
+    function hashRaw(ClaimMMRewardsRequest memory req) external view returns (bytes32);
+
+    function hashRaw(ClaimMMRewardsMessage memory ms) external view returns (bytes32);
+
+    function hashTyped(IncreasePositionRequest memory req) external view returns (bytes32);
+
+    function hashTyped(IncreasePositionMessage memory ms) external view returns (bytes32);
+
+    function hashTyped(DecreasePositionRequest memory req) external view returns (bytes32);
+
+    function hashTyped(DecreasePositionMessage memory ms) external view returns (bytes32);
+
+    function hashTyped(SwapBridgeWithdrawAllRequest memory req) external view returns (bytes32);
+
+    function hashTyped(SwapBridgeWithdrawAllMessage memory ms) external view returns (bytes32);
+
+    function hashTyped(ClaimMMRewardsRequest memory req) external view returns (bytes32);
+
+    function hashTyped(ClaimMMRewardsMessage memory ms) external view returns (bytes32);
+
+    // ========== Actions ==========
+
+    /// @notice One increase iteration. The first call for a `(owner, boxId)` slot also opens
+    ///         the session — pass the owner's typed-data signature over `req` in
+    ///         `ownerSigIfFirstCall`. Subsequent iterations within the same session can pass
+    ///         empty bytes for that arg (it is ignored once the session is open).
+    function increaseLoopPosition(
+        IncreasePositionMessage memory ms,
+        bytes memory proposerSig,
+        IncreasePositionRequest memory req,
+        bytes memory ownerSigIfFirstCall
+    ) external payable;
+
+    function decreaseLoopPosition(
+        DecreasePositionMessage memory ms,
+        bytes memory proposerSig,
+        DecreasePositionRequest memory req,
+        bytes memory ownerSigIfFirstCall
+    ) external payable;
+
+    function swapBridgeWithdrawAll(
+        SwapBridgeWithdrawAllMessage memory ms,
+        bytes memory proposerSig,
+        SwapBridgeWithdrawAllRequest memory req,
+        bytes memory ownerSigIfFirstCall
+    ) external payable;
+
+    /// @notice Closes the open session at `(owner, boxId)`. `requestHash` must equal the
+    ///         currently-stored `userReq.requestHash` (proves the caller identifies which
+    ///         session is being closed). Bumps `sessionNonce`, clears `requestHash`.
+    function terminateSession(address owner, bytes32 boxId, bytes32 requestHash) external;
+
+    function claimMMRewards(
+        ClaimMMRewardsMessage memory ms,
+        bytes memory proposerSig,
+        ClaimMMRewardsRequest memory req,
+        bytes memory ownerSigIfFirstCall
+    ) external;
+
+    // ========== Admin functions ==========
+
+    function setExecutor(address executor) external;
+
+    function setProposer(address proposer) external;
+}

package/contracts/interfaces/IPPTLooperView.sol

@@ -0,0 +1,35 @@
+//SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.20;
+
+import {IMoneyMarketView, Reward, Limits} from "./IMoneyMarketView.sol";
+
+/// @notice Aggregate snapshot of a position. Returned by `getAll` — bundles every field
+///         the seven prior individual getters used to return, so a frontend pays one factory
+///         deploy/lookup per query instead of one per field.
+struct PositionView {
+    uint256 mmPtBalance;
+    uint256 mmDebtBalance;
+    uint256 ltv;
+    uint256 liquidationThreshold;
+    uint256 borrowingLiquidity;
+    uint256 lendingLiquidity;
+    Reward[] borrowingRewards;
+    Reward[] lendingRewards;
+    Limits limits;
+    uint256 borrowingRate;
+    uint256 lendingRate;
+    uint256 ptDebtRateWad;
+}
+
+/// @notice `getAll` is non-view because it will deploy the box and the money market clone
+///         if they do not yet exist.
+interface IPPTLooperView {
+    event MoneyMarketViewRegistered(address spokeMM, address mmView);
+
+    function moneyMarketView(address spokeMM) external view returns (IMoneyMarketView);
+
+    function getAll(address owner, bytes32 boxId) external returns (PositionView memory);
+
+    // ========== Admin functions ==========
+    function registerMoneyMarketView(address spokeMM, address mmView) external;
+}

package/contracts/interfaces/IPPostPtLoopStateChecker.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.30;
+
+import {IPLoopPositionBox} from "./IPLoopPositionBox.sol";
+
+interface IPPostPtLoopStateChecker {
+    function check(IPLoopPositionBox box, bytes calldata data) external;
+}

package/contracts/interfaces/IPStaticQuoter.sol

@@ -0,0 +1,13 @@
+//SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+interface IPStaticQuoter {
+    function quote(
+        uint256 chainidIn,
+        address tokenIn,
+        uint256 amountIn,
+        uint256 chainIdOut,
+        address tokenOut,
+        uint256 slippage
+    ) external view returns (uint256 minAmountOut);
+}

package/contracts/pt-looping/BridgeDataVerifier.sol

@@ -0,0 +1,158 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.30;
+
+import {IPBridgeDataVerifier, BridgeInfo} from "../interfaces/IPBridgeDataVerifier.sol";
+import {IBungeeSORInbox} from "./vendor/bungee/IBungeeInbox.sol";
+import {
+    IOFT,
+    SendParam as OFTSendParam,
+    MessagingFee as OFTMessagingFee
+} from "@layerzerolabs/oft-evm/contracts/interfaces/IOFT.sol";
+import {IOAppCore} from "@layerzerolabs/oapp-evm/contracts/oapp/interfaces/IOAppCore.sol";
+import {AddressCast} from "@layerzerolabs/lz-evm-protocol-v2/contracts/libs/AddressCast.sol";
+import {BoringOwnableUpgradeableV2} from "../core/libraries/BoringOwnableUpgradeableV2.sol";
+
+/**
+ * @notice Common things to check
+ * - Sender and receiver is box itself. They should be the same.
+ * - Refund address is the same as the sender/receiver.
+ * - Crosschain payload should be empty to avoid further execution on destination chain.
+ * - There should not be unexpected crosschain approved permission (such as Bungee's delegate).
+ */
+contract BridgeDataVerifier is IPBridgeDataVerifier, BoringOwnableUpgradeableV2 {
+    using AddressCast for address;
+    using AddressCast for bytes32;
+
+    event EidToChainIdSet(uint256 indexed eid, uint256 indexed chainId);
+    event OftToPtSet(uint256 indexed chainId, address indexed oft, address indexed pt);
+
+    address public immutable BUNGEE_INBOX;
+
+    mapping(uint256 chainId => mapping(address oft => address pt)) public oftToPt;
+    mapping(uint256 eid => uint256 chainId) public eidToChainId;
+
+    constructor(address bungeeInbox) {
+        _disableInitializers();
+        BUNGEE_INBOX = bungeeInbox;
+    }
+
+    function initialize(address owner) public initializer {
+        __BoringOwnableV2_init(owner);
+    }
+
+    function verify(
+        address extRouter,
+        bytes calldata callData,
+        uint256 nativeFee,
+        address approveTo,
+        BridgeInfo calldata exp
+    ) external view {
+        BridgeInfo memory act = parseAndCheck(extRouter, callData, nativeFee, approveTo);
+
+        // exact match
+        require(exp.originChainId == act.originChainId, "BDVerifier: originChainId exp != act");
+        require(exp.destinationChainId == act.destinationChainId, "BDVerifier: destinationChainId exp != act");
+        require(exp.senderReceiver == act.senderReceiver, "BDVerifier: senderReceiver exp != act");
+        require(exp.inputToken == act.inputToken, "BDVerifier: inputToken exp != act");
+        require(exp.outputToken == act.outputToken, "BDVerifier: outputToken exp != act");
+
+        // bounds: actual input must not exceed expected; actual min-output must not be below expected
+        require(exp.inputAmount >= act.inputAmount, "BDVerifier: inputAmount exp < act");
+        require(exp.minOutputAmount <= act.minOutputAmount, "BDVerifier: minOutputAmount exp > act");
+    }
+
+    function parseAndCheck(address extRouter, bytes calldata callData, uint256 nativeFee, address approveTo)
+        public
+        view
+        returns (BridgeInfo memory)
+    {
+        if (extRouter == BUNGEE_INBOX) {
+            return _parseAndCheckBungeeInbox(callData, approveTo);
+        }
+        address pt = oftToPt[block.chainid][extRouter];
+        if (pt != address(0)) {
+            return _parseAndCheckLZOFTSend(pt, extRouter, callData, nativeFee, approveTo);
+        }
+        revert("BDVerifier: unsupported router");
+    }
+
+    function _parseAndCheckBungeeInbox(bytes calldata callData, address approveTo)
+        internal
+        view
+        returns (BridgeInfo memory)
+    {
+        require(approveTo == BUNGEE_INBOX, "BDVerifier: invalid approve");
+        require(bytes4(callData[:4]) == IBungeeSORInbox.createRequest.selector, "BDVerifier: invalid selector");
+
+        (IBungeeSORInbox.SingleOutputRequest memory req, address inputRefundAddress) =
+            abi.decode(callData[4:], (IBungeeSORInbox.SingleOutputRequest, address));
+        IBungeeSORInbox.BasicRequest memory basicReq = req.basicReq;
+
+        require(req.destinationPayload.length == 0, "BDVerifier: non-empty crosschain payload");
+        require(basicReq.sender == basicReq.receiver, "BDVerifier: sender != receiver");
+        require(inputRefundAddress == basicReq.receiver, "BDVerifier: invalid refund addr");
+        require(basicReq.delegate == address(0), "BDVerifier: invalid delegate");
+
+        return BridgeInfo({
+            originChainId: basicReq.originChainId,
+            destinationChainId: basicReq.destinationChainId,
+            senderReceiver: basicReq.receiver,
+            inputToken: basicReq.inputToken,
+            inputAmount: basicReq.inputAmount,
+            outputToken: basicReq.outputToken,
+            minOutputAmount: basicReq.minOutputAmount
+        });
+    }
+
+    function _parseAndCheckLZOFTSend(
+        address pt,
+        address oft,
+        bytes calldata callData,
+        uint256 nativeFee,
+        address approveTo
+    ) internal view returns (BridgeInfo memory) {
+        require(approveTo == oft, "BDVerifier: invalid approve");
+        require(bytes4(callData[:4]) == IOFT.send.selector, "BDVerifier: invalid selector");
+
+        (OFTSendParam memory sendParam, OFTMessagingFee memory messagingFee, address gasRefundAddress) =
+            abi.decode(callData[4:], (OFTSendParam, OFTMessagingFee, address));
+        address senderReceiver = _parseBytes32ToAddress(sendParam.to);
+
+        require(
+            sendParam.composeMsg.length == 0 && sendParam.oftCmd.length == 0, "BDVerifier: non-empty crosschain payload"
+        );
+        require(gasRefundAddress == senderReceiver, "BDVerifier: invalid refund addr");
+        require(nativeFee >= messagingFee.nativeFee, "BDVerifier: missing nativeFee");
+
+        uint256 dstChainId = eidToChainId[sendParam.dstEid];
+        address peerOft = _parseBytes32ToAddress(IOAppCore(oft).peers(sendParam.dstEid));
+        address outputToken = oftToPt[dstChainId][peerOft];
+
+        return BridgeInfo({
+            originChainId: block.chainid,
+            destinationChainId: dstChainId,
+            senderReceiver: senderReceiver,
+            inputToken: pt,
+            inputAmount: sendParam.amountLD,
+            outputToken: outputToken,
+            minOutputAmount: sendParam.minAmountLD
+        });
+    }
+
+    function _parseBytes32ToAddress(bytes32 b) internal pure returns (address res) {
+        res = b.toAddress();
+        require(res.toBytes32() == b, "BDVerifier: invalid EVM address");
+    }
+
+    // ========== Admin functions ==========
+
+    function setEidToChainId(uint256 eid, uint256 chainId) external onlyOwner {
+        eidToChainId[eid] = chainId;
+        emit EidToChainIdSet(eid, chainId);
+    }
+
+    function setOftToPt(uint256 chainId, address oft, address pt) external onlyOwner {
+        oftToPt[chainId][oft] = pt;
+        emit OftToPtSet(chainId, oft, pt);
+    }
+}