@pendle/core-v2 6.5.0 → 6.6.1

package/contracts/cross-chain/swap-hub/SwapHubBase.sol

@@ -0,0 +1,184 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.30;
+
+import {SignatureChecker} from "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
+import {EIP712Upgradeable} from "@openzeppelin/contracts-upgradeable/utils/cryptography/EIP712Upgradeable.sol";
+import {BoringOwnableUpgradeableV2} from "../../core/libraries/BoringOwnableUpgradeableV2.sol";
+import {TokenHelper} from "../../core/libraries/TokenHelper.sol";
+import {IPCrossChainSwapHub} from "../../interfaces/IPCrossChainSwapHub.sol";
+import {IPDepositBox} from "../../interfaces/IPDepositBox.sol";
+import {IPDepositBoxFactory} from "../../interfaces/IPDepositBoxFactory.sol";
+
+abstract contract SwapHubBase is IPCrossChainSwapHub, EIP712Upgradeable, BoringOwnableUpgradeableV2, TokenHelper {
+    // forgefmt: disable-next-item
+    bytes32 internal constant BOX_PERMIT_TYPEHASH = keccak256(
+        "BoxPermit("
+            "address owner,"
+            "uint32 boxId,"
+            "uint256 expiry,"
+            "uint256 requestId,"
+            "uint256 nonce"
+        ")"
+    );
+
+    // forgefmt: disable-next-item
+    bytes32 internal constant WITHDRAW_TOKEN_MESSAGE_TYPEHASH = keccak256(
+        "WithdrawTokenMessage("
+            "BoxPermit permit,"
+            "address token,"
+            "uint256 amountWithdraw,"
+            "uint256 amountFee"
+        ")"
+        "BoxPermit("
+            "address owner,"
+            "uint32 boxId,"
+            "uint256 expiry,"
+            "uint256 requestId,"
+            "uint256 nonce"
+        ")"
+    );
+
+    // forgefmt: disable-next-item
+    bytes32 internal constant BRIDGE_TOKEN_MESSAGE_TYPEHASH = keccak256(
+        "BridgeTokenMessage("
+            "BoxPermit permit,"
+            "address token,"
+            "uint256 amountBridge,"
+            "uint256 amountFee,"
+            //
+            "address bridgeExtRouter,"
+            "address bridgeApprove,"
+            "bytes bridgeCalldata"
+        ")"
+        "BoxPermit("
+            "address owner,"
+            "uint32 boxId,"
+            "uint256 expiry,"
+            "uint256 requestId,"
+            "uint256 nonce"
+        ")"
+    );
+
+    // forgefmt: disable-next-item
+    bytes32 internal constant SWAP_TOKEN_MESSAGE_TYPEHASH = keccak256(
+        "SwapTokenMessage("
+            "BoxPermit permit,"
+            "address tokenSpent,"
+            "uint256 amountSpent,"
+            "address tokenReceived,"
+            "uint256 minReceived,"
+            //
+            "address swapExtRouter,"
+            "address swapApprove,"
+            "bytes swapCalldata"
+        ")"
+        "BoxPermit("
+            "address owner,"
+            "uint32 boxId,"
+            "uint256 expiry,"
+            "uint256 requestId,"
+            "uint256 nonce"
+        ")"
+    );
+
+    address public immutable TREASURY;
+    IPDepositBoxFactory public immutable DEPOSIT_BOX_FACTORY;
+
+    address public executor;
+    address public proposer;
+    mapping(uint256 requestId => uint256 nonce) public requestNonce;
+
+    constructor(address treasury_, address depositBoxFactory_) {
+        TREASURY = treasury_;
+        DEPOSIT_BOX_FACTORY = IPDepositBoxFactory(depositBoxFactory_);
+    }
+
+    modifier onlyExecutor() {
+        require(msg.sender == executor, Unauthorized());
+        _;
+    }
+
+    function setExecutor(address executor_) external onlyOwner {
+        executor = executor_;
+        emit SetExecutor(executor);
+    }
+
+    function setProposer(address proposer_) external onlyOwner {
+        proposer = proposer_;
+        emit SetProposer(proposer);
+    }
+
+    function hashBoxPermit(BoxPermit memory permit) public pure returns (bytes32) {
+        return keccak256(
+            abi.encode(BOX_PERMIT_TYPEHASH, permit.owner, permit.boxId, permit.expiry, permit.requestId, permit.nonce)
+        );
+    }
+
+    function hashTypedData(WithdrawTokenMessage memory ms) public view returns (bytes32) {
+        return _hashTypedDataV4(
+            keccak256(
+                abi.encode(
+                    WITHDRAW_TOKEN_MESSAGE_TYPEHASH, hashBoxPermit(ms.permit), ms.token, ms.amountWithdraw, ms.amountFee
+                )
+            )
+        );
+    }
+
+    function hashTypedData(BridgeTokenMessage memory ms) public view returns (bytes32) {
+        return _hashTypedDataV4(
+            keccak256(
+                abi.encode(
+                    BRIDGE_TOKEN_MESSAGE_TYPEHASH,
+                    hashBoxPermit(ms.permit),
+                    ms.token,
+                    ms.amountBridge,
+                    ms.amountFee,
+                    //
+                    ms.bridgeExtRouter,
+                    ms.bridgeApprove,
+                    keccak256(ms.bridgeCalldata)
+                )
+            )
+        );
+    }
+
+    function hashTypedData(SwapTokenMessage memory ms) public view returns (bytes32) {
+        return _hashTypedDataV4(
+            keccak256(
+                abi.encode(
+                    SWAP_TOKEN_MESSAGE_TYPEHASH,
+                    hashBoxPermit(ms.permit),
+                    ms.tokenSpent,
+                    ms.amountSpent,
+                    ms.tokenReceived,
+                    ms.minReceived,
+                    //
+                    ms.swapExtRouter,
+                    ms.swapApprove,
+                    keccak256(ms.swapCalldata)
+                )
+            )
+        );
+    }
+
+    function _verifyProposerSig(
+        uint256 expiry,
+        uint256 requestId,
+        uint256 nonce,
+        bytes32 messageHash,
+        bytes memory signature
+    ) internal {
+        require(expiry > block.timestamp, MessageExpired());
+        require(SignatureChecker.isValidSignatureNow(proposer, messageHash, signature), InvalidSignature());
+        require(requestNonce[requestId] == nonce, InvalidNonce());
+        requestNonce[requestId] = nonce + 1;
+    }
+
+    function _checkBoxPermit(BoxPermit memory permit, bytes32 messageHash, bytes memory signature)
+        internal
+        returns (IPDepositBox)
+    {
+        _verifyProposerSig(permit.expiry, permit.requestId, permit.nonce, messageHash, signature);
+        return DEPOSIT_BOX_FACTORY.deployDepositBox(permit.owner, permit.boxId);
+    }
+}

package/contracts/interfaces/IPAllActionTypeV3.sol

@@ -3,6 +3,7 @@ pragma solidity ^0.8.0;
 
 import "../router/swap-aggregator/IPSwapAggregator.sol";
 import "./IPLimitRouter.sol";
+import "./IPYieldToken.sol";
 
 /*
  * NOTICE:

package/contracts/interfaces/IPAllActionV3.sol

@@ -4,7 +4,6 @@ pragma solidity ^0.8.0;
 
 import "./IPActionAddRemoveLiqV3.sol";
 import "./IPActionCallbackV3.sol";
-import "./IPActionCrossChain.sol";
 import "./IPActionMiscV3.sol";
 import "./IPActionSimple.sol";
 import "./IPActionStorageV4.sol";
@@ -18,6 +17,5 @@ interface IPAllActionV3 is
     IPActionMiscV3,
     IPActionCallbackV3,
     IPActionStorageV4,
-    IPActionSimple,
-    IPActionCrossChain
+    IPActionSimple
 {}

package/contracts/interfaces/IPBridgeFunder.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+struct BridgeData {
+    address bridgeToken;
+    uint256 bridgeAmount;
+    address feeToken;
+    uint256 feeAmount;
+    address bridgeExtRouter;
+    bytes bridgeCalldata;
+}
+
+interface IPBridgeFunder {
+    function bridge(BridgeData memory data) external returns (bytes memory);
+
+    function withdraw(address receiver, address token, uint256 amount) external;
+}

package/contracts/interfaces/IPCrossChainSwapHub.sol

@@ -0,0 +1,108 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IPCrossChainSwapHub {
+    error InsufficientTokenReceived();
+    error InvalidNonce();
+    error InvalidSignature();
+    error MessageExpired();
+    error Unauthorized();
+
+    struct BoxPermit {
+        address owner;
+        uint32 boxId;
+        uint256 expiry;
+        uint256 requestId;
+        uint256 nonce;
+    }
+
+    struct WithdrawTokenMessage {
+        BoxPermit permit;
+        address token;
+        uint256 amountWithdraw;
+        uint256 amountFee;
+    }
+
+    struct BridgeTokenMessage {
+        BoxPermit permit;
+        address token;
+        uint256 amountBridge;
+        uint256 amountFee;
+        //
+        address bridgeExtRouter;
+        address bridgeApprove;
+        bytes bridgeCalldata;
+    }
+
+    struct SwapTokenMessage {
+        BoxPermit permit;
+        address tokenSpent;
+        uint256 amountSpent;
+        address tokenReceived;
+        uint256 minReceived;
+        //
+        address swapExtRouter;
+        address swapApprove;
+        bytes swapCalldata;
+    }
+
+    event WithdrawToken(
+        address owner,
+        uint32 boxId,
+        uint256 requestId,
+        uint256 nonce,
+        address token,
+        uint256 amountWithdraw,
+        uint256 amountFee
+    );
+
+    event BridgeToken(
+        address owner,
+        uint32 boxId,
+        uint256 requestId,
+        uint256 nonce,
+        address bridgeExtRouter,
+        address token,
+        uint256 amountBridge,
+        uint256 amountFee
+    );
+
+    event SwapToken(
+        address owner,
+        uint32 boxId,
+        uint256 requestId,
+        uint256 nonce,
+        address tokenSpent,
+        uint256 amountSpent,
+        address tokenReceived,
+        uint256 netTokenReceived
+    );
+
+    event SetExecutor(address executor);
+
+    event SetProposer(address proposer);
+
+    function executor() external view returns (address);
+
+    function proposer() external view returns (address);
+
+    function setExecutor(address executor) external;
+
+    function setProposer(address proposer) external;
+
+    function requestNonce(uint256 requestId) external view returns (uint256);
+
+    function hashBoxPermit(BoxPermit memory permit) external view returns (bytes32);
+
+    function hashTypedData(WithdrawTokenMessage memory message) external view returns (bytes32);
+
+    function hashTypedData(BridgeTokenMessage memory message) external view returns (bytes32);
+
+    function hashTypedData(SwapTokenMessage memory message) external view returns (bytes32);
+
+    function withdrawToken(WithdrawTokenMessage memory message, bytes memory signature) external;
+
+    function bridgeToken(BridgeTokenMessage memory message, bytes memory signature) external payable;
+
+    function swapToken(SwapTokenMessage memory message, bytes memory signature) external;
+}

package/contracts/interfaces/IPDepositBox.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+struct ApprovedCall {
+    address token;
+    uint256 amount;
+    address approveTo;
+    address callTo;
+    bytes data;
+}
+
+interface IPDepositBox {
+    function MANAGER() external view returns (address);
+
+    function OWNER() external view returns (address);
+
+    function BOX_ID() external view returns (uint32);
+
+    function withdrawTo(address to, address token, uint256 amount) external;
+
+    function approveAndCall(ApprovedCall memory call, address nativeRefund) external payable returns (bytes memory);
+}

package/contracts/interfaces/IPDepositBoxFactory.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IPDepositBox} from "./IPDepositBox.sol";
+
+interface IPDepositBoxFactory {
+    function computeDepositBox(address owner, uint32 boxId)
+        external
+        view
+        returns (address box, bytes32 salt, bool deployed);
+
+    function deployDepositBox(address owner, uint32 boxId) external returns (IPDepositBox box);
+
+    function BEACON_PROXY_CODE_CONTRACT() external view returns (address);
+
+    function DEPOSIT_BOX_BEACON() external view returns (address);
+
+    function DEPOSIT_BOX_CODE_HASH() external view returns (bytes32);
+}

package/contracts/interfaces/IPFixedPricePTAMMV2.sol

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: SEE LICENSE IN LICENSE
+pragma solidity ^0.8.19;
+
+import {IPChainlinkOracleEssential} from "../interfaces/IPChainlinkOracleEssential.sol";
+import {
+    IERC20MetadataUpgradeable
+} from "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol";
+
+interface IPFixedPricePTAMMV2 is IERC20MetadataUpgradeable {
+    event Swap(address indexed caller, address indexed receiver, address PT, uint256 netPtIn, uint256 netTokenOut);
+
+    event PriceOracleUpdated(address indexed PT, address indexed priceOracle);
+
+    event TokenFunded(address indexed sender, uint256 amount);
+
+    event TokenWithdrawn(address indexed sender, uint256 amount);
+
+    event WhitelistUpdated(address indexed user, bool isWhitelisted);
+
+    event PauseStatusUpdated(address indexed PT, bool isPaused);
+
+    function outputToken() external view returns (address);
+
+    function priceOracle(address PT)
+        external
+        view
+        returns (bool isPaused, IPChainlinkOracleEssential, uint256 multiplier);
+
+    function totalPt(address PT) external view returns (uint256);
+
+    function isWhitelisted(address user) external view returns (bool);
+
+    function previewSwapExactPtForToken(address PT, uint256 exactPtIn) external view returns (uint256 amountTokenOut);
+
+    function swapExactPtForToken(address receiver, address PT, uint256 exactPtIn, bytes calldata data)
+        external
+        returns (uint256 netTokenOut);
+
+    // Add/remove funds
+
+    function addFundWhitelisted(uint256 amount) external;
+
+    function removeFund(uint256 amount) external;
+
+    // Admin functions
+
+    function withdrawPt(address PT, uint256 amount) external;
+
+    function setWhitelist(address user, bool isWhitelisted) external;
+
+    function setPriceOracle(address PT, address priceOracle, uint256 multiplier) external;
+
+    function setPausePtTrading(address PT, bool isPaused) external;
+}
+
+interface IPFixedPricePTAMMSwapCallback {
+    function swapCallback(uint256 exactTokenOut, uint256 netPtIn, bytes calldata data) external;
+}

package/contracts/interfaces/IPGaugeController.sol

@@ -12,6 +12,8 @@ interface IPGaugeController {
 
     event UpdateMarketRewardV2(address indexed market, uint128 pendlePerSec, uint128 incentiveEndsAt);
 
+    event WhitelistMarketSet(address indexed market, bool isWhitelisted);
+
     function setRewardDatas(
         address[] calldata markets,
         uint128[] calldata pendlePerSecs,
@@ -24,10 +26,12 @@ interface IPGaugeController {
 
     function redeemMarketReward() external;
 
-    function rewardData(
-        address market
-    )
+    function rewardData(address market)
         external
         view
         returns (uint128 pendlePerSec, uint128 accumulatedPendle, uint128 lastUpdated, uint128 incentiveEndsAt);
+
+    function isWhitelisted(address market) external view returns (bool);
+
+    function whitelistMarkets(address[] memory markets, bool _isWhitelisted) external;
 }

package/contracts/interfaces/IPLimitRouter.sol

@@ -2,6 +2,7 @@
 pragma solidity ^0.8.0;
 
 import "../core/StandardizedYield/PYIndex.sol";
+import "../interfaces/IPAllActionTypeV3.sol";
 
 interface IPLimitOrderType {
     enum OrderType {
@@ -59,6 +60,16 @@ struct FillOrderParams {
     uint256 makingAmount;
 }
 
+struct MintSyData {
+    TokenInput[] inps;
+    uint256[] minSyOuts;
+    uint256 expiry;
+    bytes32 fillParamsHash;
+
+    bytes sig1;
+    bytes sig2;
+}
+
 interface IPLimitRouterCallback is IPLimitOrderType {
     function limitRouterCallback(uint256 actualMaking, uint256 actualTaking, uint256 totalFee, bytes memory data)
         external
@@ -71,6 +82,9 @@ interface IPLimitRouter is IPLimitOrderType {
         uint128 remaining;
     }
 
+    // event added on 11/3/2026
+    event OrderPreSigned(bytes32 indexed orderHash, Order order);
+
     event OrderCanceled(address indexed maker, bytes32 indexed orderHash);
 
     event OrderForceCanceled(bytes32 indexed orderHash);
@@ -91,6 +105,9 @@ interface IPLimitRouter is IPLimitOrderType {
     // event added on 2/1/2025
     event LnFeeRateRootsSet(address[] YTs, uint256[] lnFeeRateRoots);
 
+    // event added on 11/3/2026
+    event MintSySignersSet(address signer1, address signer2);
+
     // @dev actualMaking, actualTaking are in the SY form
     function fill(
         FillOrderParams[] memory params,
@@ -102,8 +119,18 @@ interface IPLimitRouter is IPLimitOrderType {
 
     function feeRecipient() external view returns (address);
 
+    function mintSySigner1() external view returns (address);
+
+    function mintSySigner2() external view returns (address);
+
+    function hashFillParams(FillOrderParams[] memory params) external pure returns (bytes32);
+
     function hashOrder(Order memory order) external view returns (bytes32);
 
+    function preSignSingle(Order calldata order) external;
+
+    function preSignBatch(Order[] calldata order) external;
+
     function cancelSingle(Order calldata order) external;
 
     function cancelBatch(Order[] calldata orders) external;
@@ -124,6 +151,8 @@ interface IPLimitRouter is IPLimitOrderType {
 
     function WNATIVE() external view returns (address);
 
+    function ROUTER() external view returns (address);
+
     function _checkSig(Order memory order, bytes memory signature)
         external
         view

package/contracts/interfaces/{IPActionCrossChain.sol → IPSwapHelper.sol}

@@ -3,7 +3,7 @@ pragma solidity ^0.8.0;
 
 import {TokenOutput} from "./IPAllActionTypeV3.sol";
 
-interface IPActionCrossChain {
+interface IPSwapHelper {
     function swapWithFixedPricePTAMM(
         address receiver,
         address fixedPricePTAMM,