@pendle/core-v2 6.7.1 → 6.8.1

package/contracts/pt-looping/PTLooperBase.sol

@@ -0,0 +1,236 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.30;
+
+import {BoringOwnableUpgradeableV2} from "../core/libraries/BoringOwnableUpgradeableV2.sol";
+import {TokenHelper} from "../core/libraries/TokenHelper.sol";
+import {IMoneyMarket} from "../interfaces/IMoneyMarket.sol";
+import {BoxData, IPLoopPositionBox} from "../interfaces/IPLoopPositionBox.sol";
+import {IPLoopPositionBoxFactory} from "../interfaces/IPLoopPositionBoxFactory.sol";
+import {IPPTLooper} from "../interfaces/IPPTLooper.sol";
+import {EIP712Upgradeable} from "@openzeppelin/contracts-upgradeable/utils/cryptography/EIP712Upgradeable.sol";
+import {SignatureChecker} from "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
+import {PTLooperEIP712TypesEncodeDataLib} from "./PTLooperEIP712TypesEncodeDataLib.sol";
+
+abstract contract PTLooperBase is IPPTLooper, EIP712Upgradeable, BoringOwnableUpgradeableV2, TokenHelper {
+    using PTLooperEIP712TypesEncodeDataLib for *;
+
+    address public immutable TREASURY;
+    IPLoopPositionBoxFactory public immutable POSITION_BOX_FACTORY;
+
+    address public executor;
+    address public proposer;
+    mapping(address owner => mapping(bytes32 requestHash => uint256 nonce)) public proposerNonce;
+    mapping(address owner => mapping(bytes32 boxId => UserRequestInfo)) internal _userRequest;
+
+    constructor(address treasury_, address positionBoxFactory_) {
+        TREASURY = treasury_;
+        POSITION_BOX_FACTORY = IPLoopPositionBoxFactory(positionBoxFactory_);
+    }
+
+    function userRequest(address owner, bytes32 boxId) external view returns (UserRequestInfo memory) {
+        return _userRequest[owner][boxId];
+    }
+
+    modifier onlyExecutor() {
+        require(msg.sender == executor, "PTLooper: unauthorized");
+        _;
+    }
+
+    modifier onlyExecutorOrBoxOwner(address boxOwner) {
+        require(msg.sender == executor || msg.sender == boxOwner, "PTLooper: unauthorized");
+        _;
+    }
+
+    function setExecutor(address executor_) external onlyOwner {
+        executor = executor_;
+        emit SetExecutor(executor_);
+    }
+
+    function setProposer(address proposer_) external onlyOwner {
+        proposer = proposer_;
+        emit SetProposer(proposer_);
+    }
+
+    // ========== Hash functions ==========
+
+    function hashRaw(BoxPermit memory permit) public pure returns (bytes32) {
+        return permit.encodeData();
+    }
+
+    function hashRaw(RequestHeader memory header) public pure returns (bytes32) {
+        return header.encodeData();
+    }
+
+    function hashRaw(BoxApprovedCall memory call) public pure returns (bytes32) {
+        return call.encodeData();
+    }
+
+    function hashRaw(BridgeData memory bridge) public pure returns (bytes32) {
+        return bridge.encodeData();
+    }
+
+    function hashRaw(IncreasePositionRequest memory req) public pure returns (bytes32) {
+        return req.encodeData();
+    }
+
+    function hashRaw(DecreasePositionRequest memory req) public pure returns (bytes32) {
+        return req.encodeData();
+    }
+
+    function hashRaw(SwapBridgeWithdrawAllRequest memory req) public pure returns (bytes32) {
+        return req.encodeData();
+    }
+
+    function hashRaw(ClaimMMRewardsRequest memory req) public pure returns (bytes32) {
+        return req.encodeData();
+    }
+
+    function hashRaw(ClaimMMRewardsMessage memory ms) public pure returns (bytes32) {
+        return ms.encodeData();
+    }
+
+    function hashTyped(IncreasePositionRequest memory req) public view returns (bytes32) {
+        return _hashTypedDataV4(req.encodeData());
+    }
+
+    function hashTyped(IncreasePositionMessage memory ms) public view returns (bytes32) {
+        return _hashTypedDataV4(ms.encodeData());
+    }
+
+    function hashTyped(DecreasePositionRequest memory req) public view returns (bytes32) {
+        return _hashTypedDataV4(req.encodeData());
+    }
+
+    function hashTyped(DecreasePositionMessage memory ms) public view returns (bytes32) {
+        return _hashTypedDataV4(ms.encodeData());
+    }
+
+    function hashTyped(SwapBridgeWithdrawAllRequest memory req) public view returns (bytes32) {
+        return _hashTypedDataV4(req.encodeData());
+    }
+
+    function hashTyped(SwapBridgeWithdrawAllMessage memory ms) public view returns (bytes32) {
+        return _hashTypedDataV4(ms.encodeData());
+    }
+
+    function hashTyped(ClaimMMRewardsRequest memory req) public view returns (bytes32) {
+        return _hashTypedDataV4(req.encodeData());
+    }
+
+    function hashTyped(ClaimMMRewardsMessage memory ms) public view returns (bytes32) {
+        return _hashTypedDataV4(ms.encodeData());
+    }
+
+    /// @dev Per-iteration ctx returned by `_ensureSessionAndAuth`. `spokeMM` is unread on the
+    /// swap-bridge-withdraw path but always populated — splitting per entry point would cost
+    /// more bytecode than it saves. On chains that are neither hub nor spoke for the box,
+    /// `spokeMM` is `address(0)`; downstream calls to it then revert at the EVM level (zero-
+    /// address call) — that implicit check replaces an explicit chain-id assert. Note: paths that
+    /// resolve the debt token via `PendlePTLooper._debtTokenHere` instead get an explicit
+    /// "PTLooper: unsupported chainid" revert before any `spokeMM` use.
+    struct Session {
+        IPLoopPositionBox box;
+        IMoneyMarket spokeMM;
+        BoxData bd;
+    }
+
+    function _ensureSessionAndAuth(
+        IncreasePositionMessage memory ms,
+        IncreasePositionRequest memory req,
+        bytes memory proposerSig,
+        bytes memory ownerSigIfFirstCall
+    ) internal returns (Session memory s, bytes32 requestHash) {
+        requestHash = hashTyped(req);
+        s = _ensureSessionAndAuthCore(
+            ms.permit, req.header, hashTyped(ms), proposerSig, requestHash, ownerSigIfFirstCall
+        );
+    }
+
+    function _ensureSessionAndAuth(
+        DecreasePositionMessage memory ms,
+        DecreasePositionRequest memory req,
+        bytes memory proposerSig,
+        bytes memory ownerSigIfFirstCall
+    ) internal returns (Session memory s, bytes32 requestHash) {
+        requestHash = hashTyped(req);
+        s = _ensureSessionAndAuthCore(
+            ms.permit, req.header, hashTyped(ms), proposerSig, requestHash, ownerSigIfFirstCall
+        );
+    }
+
+    function _ensureSessionAndAuth(
+        SwapBridgeWithdrawAllMessage memory ms,
+        SwapBridgeWithdrawAllRequest memory req,
+        bytes memory proposerSig,
+        bytes memory ownerSigIfFirstCall
+    ) internal returns (Session memory s, bytes32 requestHash) {
+        requestHash = hashTyped(req);
+        s = _ensureSessionAndAuthCore(
+            ms.permit, req.header, hashTyped(ms), proposerSig, requestHash, ownerSigIfFirstCall
+        );
+    }
+
+    function _ensureSessionAndAuth(
+        ClaimMMRewardsMessage memory ms,
+        ClaimMMRewardsRequest memory req,
+        bytes memory proposerSig,
+        bytes memory ownerSigIfFirstCall
+    ) internal returns (Session memory s, bytes32 requestHash) {
+        requestHash = hashTyped(req);
+        s = _ensureSessionAndAuthCore(
+            ms.permit, req.header, hashTyped(ms), proposerSig, requestHash, ownerSigIfFirstCall
+        );
+    }
+
+    /// @dev Per-iteration auth + implicit session init. First call for a slot
+    /// (`userReq.requestHash == 0`) opens the session — checks `boxId`/`sessionNonce` agree and
+    /// verifies the owner sig. Subsequent calls just match `userReq.requestHash`;
+    /// `ownerSigIfFirstCall` is ignored. Proposer auth runs in both branches; the per-iteration
+    /// nonce slot is keyed by `(owner, requestHash)` so distinct sessions or owners never share
+    /// a counter.
+    function _ensureSessionAndAuthCore(
+        BoxPermit memory permit,
+        RequestHeader memory header,
+        bytes32 msgHash,
+        bytes memory proposerSig,
+        bytes32 requestHash,
+        bytes memory ownerSigIfFirstCall
+    ) private returns (Session memory s) {
+        UserRequestInfo storage userReq = _userRequest[permit.owner][permit.boxId];
+
+        // Expiry checked before the `requestHash` write below (CEI).
+        require(header.expiry > block.timestamp, "PTLooper: request expired"); // forge-lint: disable-line(block-timestamp)
+
+        if (userReq.requestHash == bytes32(0)) {
+            // First call for this slot — implicit session init.
+            require(header.boxId == permit.boxId, "PTLooper: req/permit boxId mismatch");
+            require(header.sessionNonce == userReq.sessionNonce, "PTLooper: invalid session nonce");
+            require(
+                SignatureChecker.isValidSignatureNow(permit.owner, requestHash, ownerSigIfFirstCall),
+                "PTLooper: invalid owner signature"
+            );
+            userReq.requestHash = requestHash;
+            emit SessionInitiated(permit.owner, permit.boxId, requestHash, userReq.sessionNonce);
+        } else {
+            require(userReq.requestHash == requestHash, "PTLooper: request hash mismatch");
+        }
+
+        return _authPermit(permit, msgHash, proposerSig, header.permitNonceCap, requestHash);
+    }
+
+    function _authPermit(
+        BoxPermit memory permit,
+        bytes32 msgHash,
+        bytes memory proposerSig,
+        uint256 permitNonceCap,
+        bytes32 requestHash
+    ) private returns (Session memory s) {
+        require(permit.expiry > block.timestamp, "PTLooper: message expired"); // forge-lint: disable-line(block-timestamp)
+        require(SignatureChecker.isValidSignatureNow(proposer, msgHash, proposerSig), "PTLooper: invalid signature");
+        require(permit.nonce < permitNonceCap, "PTLooper: permitNonceCap exceeded");
+        require(proposerNonce[permit.owner][requestHash] == permit.nonce, "PTLooper: invalid proposer nonce");
+        proposerNonce[permit.owner][requestHash] = permit.nonce + 1;
+
+        (s.box, s.spokeMM, s.bd) = POSITION_BOX_FACTORY.deployPositionBoxAndMoneyMarket(permit.owner, permit.boxId);
+    }
+}

package/contracts/pt-looping/PTLooperEIP712TypesEncodeDataLib.sol

@@ -0,0 +1,210 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.30;
+
+////////// GENERATED FILE. DO NOT EDIT DIRECTLY.
+// FOUNDRY_PROFILE=v2-script forge script script/GenEIP712.sol -- "./contracts/interfaces/IPPTLooper.sol" "IPPTLooperEIP712Types" '[]' "./contracts/pt-looping/PTLooperEIP712TypesEncodeDataLib.sol"
+
+import {IPPTLooperEIP712Types} from "./../interfaces/IPPTLooper.sol";
+
+/// @notice Generate EIP712 `encodeData` function for types in IPPTLooperEIP712Types based on specification:
+/// https://eips.ethereum.org/EIPS/eip-712#definition-of-encodedata
+// forgefmt: disable-next-item
+library PTLooperEIP712TypesEncodeDataLib {
+    // IPPTLooper.sol > IPPTLooperEIP712Types > BoxPermit
+    function encodeData(IPPTLooperEIP712Types.BoxPermit memory data) internal pure returns (bytes32) {
+        /* bytes32 typeHash = keccak256(
+            "BoxPermit(address owner,bytes32 boxId,uint256 expiry,uint256 nonce)" 
+        ); */
+        bytes32 typeHash = 0x822aa76455d3f0b945088018ee29f25999f8e1b1cbe462cd90f78d0c038148ec;
+        return keccak256(abi.encode(
+            typeHash,
+            data.owner,
+            data.boxId,
+            data.expiry,
+            data.nonce
+        ));
+    }
+    
+    // IPPTLooper.sol > IPPTLooperEIP712Types > RequestHeader
+    function encodeData(IPPTLooperEIP712Types.RequestHeader memory data) internal pure returns (bytes32) {
+        /* bytes32 typeHash = keccak256(
+            "RequestHeader(bytes32 boxId,uint256 expiry,uint32 sessionNonce,uint32 permitNonceCap,uint256 swapBridgeSlippage,bytes offchainMetadata)" 
+        ); */
+        bytes32 typeHash = 0x4b5c157e13c9c70173fbe4c990f516a87f1bcb79deeb7706156cfd0a4bb4ee84;
+        return keccak256(abi.encode(
+            typeHash,
+            data.boxId,
+            data.expiry,
+            data.sessionNonce,
+            data.permitNonceCap,
+            data.swapBridgeSlippage,
+            keccak256(data.offchainMetadata)
+        ));
+    }
+    
+    // IPPTLooper.sol > IPPTLooperEIP712Types > BoxApprovedCall
+    function encodeData(IPPTLooperEIP712Types.BoxApprovedCall memory data) internal pure returns (bytes32) {
+        /* bytes32 typeHash = keccak256(
+            "BoxApprovedCall(address extRouter,address approve,bytes callData)" 
+        ); */
+        bytes32 typeHash = 0xd3355b017a4df5ab14bfe30be8fc74cf288d6cbdd53b7fb9a45cb406e14cb425;
+        return keccak256(abi.encode(
+            typeHash,
+            data.extRouter,
+            data.approve,
+            keccak256(data.callData)
+        ));
+    }
+    
+    // IPPTLooper.sol > IPPTLooperEIP712Types > BridgeData
+    function encodeData(IPPTLooperEIP712Types.BridgeData memory data) internal pure returns (bytes32) {
+        /* bytes32 typeHash = keccak256(
+            "BridgeData(BoxApprovedCall call,uint256 maxAmount,uint256 nativeFee)" 
+            "BoxApprovedCall(address extRouter,address approve,bytes callData)" 
+        ); */
+        bytes32 typeHash = 0x2e509eca09b391e74bb50ce10f43a13d6dfd1390e626fcfc40c60b1d7369a4b0;
+        return keccak256(abi.encode(
+            typeHash,
+            encodeData(data.call),
+            data.maxAmount,
+            data.nativeFee
+        ));
+    }
+    
+    // IPPTLooper.sol > IPPTLooperEIP712Types > IncreasePositionRequest
+    function encodeData(IPPTLooperEIP712Types.IncreasePositionRequest memory data) internal pure returns (bytes32) {
+        /* bytes32 typeHash = keccak256(
+            "IncreasePositionRequest(RequestHeader header,address initTokenIn,uint256 initMinToPtSwapRate,uint256 minDebtToPtSwapRate,uint256 postBorrowMaxLTV,bool isZeroPriceImpact,uint256 maxFeeRate)" 
+            "RequestHeader(bytes32 boxId,uint256 expiry,uint32 sessionNonce,uint32 permitNonceCap,uint256 swapBridgeSlippage,bytes offchainMetadata)" 
+        ); */
+        bytes32 typeHash = 0x3dbdcfb2686d43e144206a30f06f896545dd0bf378284ab15ce7d25ca65ed9cc;
+        return keccak256(abi.encode(
+            typeHash,
+            encodeData(data.header),
+            data.initTokenIn,
+            data.initMinToPtSwapRate,
+            data.minDebtToPtSwapRate,
+            data.postBorrowMaxLTV,
+            data.isZeroPriceImpact,
+            data.maxFeeRate
+        ));
+    }
+    
+    // IPPTLooper.sol > IPPTLooperEIP712Types > IncreasePositionMessage
+    function encodeData(IPPTLooperEIP712Types.IncreasePositionMessage memory data) internal pure returns (bytes32) {
+        /* bytes32 typeHash = keccak256(
+            "IncreasePositionMessage(BoxPermit permit,BoxApprovedCall swap,uint256 fee,BridgeData bridge,uint256 amountDebtBorrowed,bytes postStateCheckData)" 
+            "BoxApprovedCall(address extRouter,address approve,bytes callData)" 
+            "BoxPermit(address owner,bytes32 boxId,uint256 expiry,uint256 nonce)" 
+            "BridgeData(BoxApprovedCall call,uint256 maxAmount,uint256 nativeFee)" 
+        ); */
+        bytes32 typeHash = 0x40d59af1d5bbd55280d0f7131b112cf40ffd6775f6ca26b477734c4dca0cf64e;
+        return keccak256(abi.encode(
+            typeHash,
+            encodeData(data.permit),
+            encodeData(data.swap),
+            data.fee,
+            encodeData(data.bridge),
+            data.amountDebtBorrowed,
+            keccak256(data.postStateCheckData)
+        ));
+    }
+    
+    // IPPTLooper.sol > IPPTLooperEIP712Types > DecreasePositionRequest
+    function encodeData(IPPTLooperEIP712Types.DecreasePositionRequest memory data) internal pure returns (bytes32) {
+        /* bytes32 typeHash = keccak256(
+            "DecreasePositionRequest(RequestHeader header,uint256 minPtToDebtSwapRate,uint256 postWithdrawMaxLTV)" 
+            "RequestHeader(bytes32 boxId,uint256 expiry,uint32 sessionNonce,uint32 permitNonceCap,uint256 swapBridgeSlippage,bytes offchainMetadata)" 
+        ); */
+        bytes32 typeHash = 0xf2fd81fd04f9cee0ece251f806445c3b1d5103fcd06f31002a34371094102b59;
+        return keccak256(abi.encode(
+            typeHash,
+            encodeData(data.header),
+            data.minPtToDebtSwapRate,
+            data.postWithdrawMaxLTV
+        ));
+    }
+    
+    // IPPTLooper.sol > IPPTLooperEIP712Types > DecreasePositionMessage
+    function encodeData(IPPTLooperEIP712Types.DecreasePositionMessage memory data) internal pure returns (bytes32) {
+        /* bytes32 typeHash = keccak256(
+            "DecreasePositionMessage(BoxPermit permit,BoxApprovedCall swap,BridgeData bridge,uint256 amountPtWithdrawn,bytes postStateCheckData)" 
+            "BoxApprovedCall(address extRouter,address approve,bytes callData)" 
+            "BoxPermit(address owner,bytes32 boxId,uint256 expiry,uint256 nonce)" 
+            "BridgeData(BoxApprovedCall call,uint256 maxAmount,uint256 nativeFee)" 
+        ); */
+        bytes32 typeHash = 0xa2638841c0c7fcfce10275ef9bc3e8b2711ac24f07818116b6942c54a9805f12;
+        return keccak256(abi.encode(
+            typeHash,
+            encodeData(data.permit),
+            encodeData(data.swap),
+            encodeData(data.bridge),
+            data.amountPtWithdrawn,
+            keccak256(data.postStateCheckData)
+        ));
+    }
+    
+    // IPPTLooper.sol > IPPTLooperEIP712Types > SwapBridgeWithdrawAllRequest
+    function encodeData(IPPTLooperEIP712Types.SwapBridgeWithdrawAllRequest memory data) internal pure returns (bytes32) {
+        /* bytes32 typeHash = keccak256(
+            "SwapBridgeWithdrawAllRequest(RequestHeader header,bool receiveOnSpoke,address hubTokenOut,address dstTokenOut,uint256 minTokenWithdrawn)" 
+            "RequestHeader(bytes32 boxId,uint256 expiry,uint32 sessionNonce,uint32 permitNonceCap,uint256 swapBridgeSlippage,bytes offchainMetadata)" 
+        ); */
+        bytes32 typeHash = 0x8ac3df3c6aafa50fff9c9cdb9de52954f7d1bcb8a41375bb202fca85c4f86cab;
+        return keccak256(abi.encode(
+            typeHash,
+            encodeData(data.header),
+            data.receiveOnSpoke,
+            data.hubTokenOut,
+            data.dstTokenOut,
+            data.minTokenWithdrawn
+        ));
+    }
+    
+    // IPPTLooper.sol > IPPTLooperEIP712Types > SwapBridgeWithdrawAllMessage
+    function encodeData(IPPTLooperEIP712Types.SwapBridgeWithdrawAllMessage memory data) internal pure returns (bytes32) {
+        /* bytes32 typeHash = keccak256(
+            "SwapBridgeWithdrawAllMessage(BoxPermit permit,BoxApprovedCall swap,BridgeData bridge,bytes postStateCheckData)" 
+            "BoxApprovedCall(address extRouter,address approve,bytes callData)" 
+            "BoxPermit(address owner,bytes32 boxId,uint256 expiry,uint256 nonce)" 
+            "BridgeData(BoxApprovedCall call,uint256 maxAmount,uint256 nativeFee)" 
+        ); */
+        bytes32 typeHash = 0x6cd5da344d135a773661e166411b132de126661c92b5d13b7b83c71ff0110f1f;
+        return keccak256(abi.encode(
+            typeHash,
+            encodeData(data.permit),
+            encodeData(data.swap),
+            encodeData(data.bridge),
+            keccak256(data.postStateCheckData)
+        ));
+    }
+    
+    // IPPTLooper.sol > IPPTLooperEIP712Types > ClaimMMRewardsRequest
+    function encodeData(IPPTLooperEIP712Types.ClaimMMRewardsRequest memory data) internal pure returns (bytes32) {
+        /* bytes32 typeHash = keccak256(
+            "ClaimMMRewardsRequest(RequestHeader header,address extRewardController,bytes data,address[] rewardTokens)" 
+            "RequestHeader(bytes32 boxId,uint256 expiry,uint32 sessionNonce,uint32 permitNonceCap,uint256 swapBridgeSlippage,bytes offchainMetadata)" 
+        ); */
+        bytes32 typeHash = 0xc43b1ddd31b47c3575e0cfab0ba34c9546a4f739fce4f13625dc9ae5cc44df62;
+        return keccak256(abi.encode(
+            typeHash,
+            encodeData(data.header),
+            data.extRewardController,
+            keccak256(data.data),
+            keccak256(abi.encodePacked(data.rewardTokens))
+        ));
+    }
+    
+    // IPPTLooper.sol > IPPTLooperEIP712Types > ClaimMMRewardsMessage
+    function encodeData(IPPTLooperEIP712Types.ClaimMMRewardsMessage memory data) internal pure returns (bytes32) {
+        /* bytes32 typeHash = keccak256(
+            "ClaimMMRewardsMessage(BoxPermit permit)" 
+            "BoxPermit(address owner,bytes32 boxId,uint256 expiry,uint256 nonce)" 
+        ); */
+        bytes32 typeHash = 0xeb325b74167005941f5d4aacf4aa3fd86a6d4dcb7695d06bcc66de38ad87d3c2;
+        return keccak256(abi.encode(
+            typeHash,
+            encodeData(data.permit)
+        ));
+    }
+}