@pendle/core-v2 6.6.0 → 6.7.0

package/contracts/cross-chain/oftImpl/pendleOft/PendleOFTAlt.sol

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.22;
+
+import {PendleOFT} from "./PendleOFT.sol";
+import {
+    MessagingParams,
+    MessagingFee,
+    MessagingReceipt
+} from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
+import {IERC20, SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+/// @dev This contract inherits Ownable from OpenZeppelin v4.
+contract PendleOFTAlt is PendleOFT {
+    using SafeERC20 for IERC20;
+
+    error MsgValueNotZero(uint256 msgValue);
+    error NativeTokenUnavailable();
+
+    address public immutable nativeToken;
+
+    constructor(address _lzEndpoint, address _delegate) PendleOFT(_lzEndpoint, _delegate) {
+        nativeToken = endpoint.nativeToken();
+    }
+
+    function _lzSend(
+        uint32 _dstEid,
+        bytes memory _message,
+        bytes memory _options,
+        MessagingFee memory _fee,
+        address _refundAddress
+    ) internal override returns (MessagingReceipt memory receipt) {
+        // In Alt implementation, msg.value should always be 0 since we use ERC20 tokens for fees
+        if (msg.value > 0) revert MsgValueNotZero(msg.value);
+
+        // Push corresponding fees to the endpoint, any excess is sent back to the _refundAddress from the endpoint.
+        _payNative(_fee.nativeFee);
+        if (_fee.lzTokenFee > 0) _payLzToken(_fee.lzTokenFee);
+
+        return endpoint.send(
+            MessagingParams(_dstEid, _getPeerOrRevert(_dstEid), _message, _options, _fee.lzTokenFee > 0), _refundAddress
+        );
+    }
+
+    function _payNative(uint256 _nativeFee) internal override returns (uint256 nativeFee) {
+        if (nativeToken == address(0)) revert NativeTokenUnavailable();
+
+        // Pay Native token fee by sending tokens to the endpoint.
+        IERC20(nativeToken).safeTransferFrom(msg.sender, address(endpoint), _nativeFee);
+
+        return _nativeFee;
+    }
+}

package/contracts/cross-chain/oftImpl/spoke/PendleBridgedPrincipalToken.sol

@@ -2,40 +2,49 @@
 pragma solidity ^0.8.19;
 
 import {IPBridgedPrincipalToken} from "../../../interfaces/IPBridgedPrincipalToken.sol";
-import {IOFT, OFT, OFTCore} from "@layerzerolabs/oft-evm/contracts/OFT.sol";
-import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
-import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import {
+    IOFT,
+    OFTCoreUpgradeable,
+    OFTUpgradeable
+} from "@layerzerolabs/oft-evm-upgradeable/contracts/oft/OFTUpgradeable.sol";
+import {ERC20Upgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
+import {
+    IERC20MetadataUpgradeable
+} from "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol";
 
-contract PendleBridgedPrincipalToken is IPBridgedPrincipalToken, OFT {
+/// @notice Contract deployer must be IPBridgePTFactory for additional information.
+///         This is for deterministic deployment.
+contract PendleBridgedPrincipalToken is IPBridgedPrincipalToken, OFTUpgradeable {
     uint256 public immutable expiry;
     uint8 internal immutable LOCAL_DECIMALS;
-    uint8 internal immutable SHARED_DECIMALS;
-
-    constructor(
-        string memory _name,
-        string memory _symbol,
-        address _lzEndpoint,
-        address _delegate,
-        uint256 _expiry,
-        uint8 _localDecimals,
-        uint8 _sharedDecimals,
-        address initialOwner
-    ) OFT(_name, _symbol, _lzEndpoint, _delegate) {
+
+    constructor(address _lzEndpoint, uint256 _expiry, uint8 _decimals) OFTUpgradeable(_lzEndpoint) {
         expiry = _expiry;
-        _transferOwnership(initialOwner);
 
-        LOCAL_DECIMALS = _localDecimals;
-        SHARED_DECIMALS = _sharedDecimals;
+        LOCAL_DECIMALS = _decimals;
+
+        uint8 shared = sharedDecimals();
+        require(LOCAL_DECIMALS >= shared, "InvalidLocalDecimals");
 
         // override decimalConversionRate set in OFTCore constructor
-        decimalConversionRate = 10 ** (LOCAL_DECIMALS - SHARED_DECIMALS);
+        decimalConversionRate = 10 ** (LOCAL_DECIMALS - sharedDecimals());
+
+        _disableInitializers();
     }
 
-    function decimals() public view override(ERC20, IERC20Metadata) returns (uint8) {
-        return LOCAL_DECIMALS;
+    function initialize(string memory _name, string memory _symbol, address ownerDelegate) external initializer {
+        __OFT_init(_name, _symbol, ownerDelegate);
+        _transferOwnership(ownerDelegate);
     }
 
-    function sharedDecimals() public view override(OFTCore, IOFT) returns (uint8) {
-        return SHARED_DECIMALS;
+    /// @dev This functions is used to passed in the decimals to OFTCoreUpgradeable's constructor.
+    /// Since `LOCAL_DECIMALS` was not initialized at that point, we return 18 to avoid the `InvalidLocalDecimals`
+    /// revert.
+    ///
+    /// See
+    /// https://github.com/LayerZero-Labs/devtools/blob/128b697838f4b0fd53ae748093fd66cc409ae5c4/packages/oft-evm-upgradeable/contracts/oft/OFTCoreUpgradeable.sol#L72
+    function decimals() public view override(ERC20Upgradeable, IERC20MetadataUpgradeable) returns (uint8 res) {
+        res = LOCAL_DECIMALS;
+        if (res == 0) res = 18;
     }
 }

package/contracts/cross-chain/oftImpl/spoke/PendleBridgedPrincipalTokenAlt.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.19;
+
+import {PendleBridgedPrincipalToken} from "./PendleBridgedPrincipalToken.sol";
+import {
+    MessagingParams,
+    MessagingFee,
+    MessagingReceipt
+} from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
+import {IERC20, SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+/// @notice Contract deployer must be IPBridgePTFactory for additional information.
+///         This is for deterministic deployment.
+contract PendleBridgedPrincipalTokenAlt is PendleBridgedPrincipalToken {
+    using SafeERC20 for IERC20;
+
+    error MsgValueNotZero(uint256 msgValue);
+    error NativeTokenUnavailable();
+
+    address public immutable nativeToken;
+
+    constructor(address _lzEndpoint, uint256 _expiry, uint8 _decimals)
+        PendleBridgedPrincipalToken(_lzEndpoint, _expiry, _decimals)
+    {
+        nativeToken = endpoint.nativeToken();
+    }
+
+    function _lzSend(
+        uint32 _dstEid,
+        bytes memory _message,
+        bytes memory _options,
+        MessagingFee memory _fee,
+        address _refundAddress
+    ) internal override returns (MessagingReceipt memory receipt) {
+        // In Alt implementation, msg.value should always be 0 since we use ERC20 tokens for fees
+        if (msg.value > 0) revert MsgValueNotZero(msg.value);
+
+        // Push corresponding fees to the endpoint, any excess is sent back to the _refundAddress from the endpoint.
+        _payNative(_fee.nativeFee);
+        if (_fee.lzTokenFee > 0) _payLzToken(_fee.lzTokenFee);
+
+        return endpoint.send(
+            MessagingParams(_dstEid, _getPeerOrRevert(_dstEid), _message, _options, _fee.lzTokenFee > 0), _refundAddress
+        );
+    }
+
+    function _payNative(uint256 _nativeFee) internal override returns (uint256 nativeFee) {
+        if (nativeToken == address(0)) revert NativeTokenUnavailable();
+
+        // Pay Native token fee by sending tokens to the endpoint.
+        IERC20(nativeToken).safeTransferFrom(msg.sender, address(endpoint), _nativeFee);
+
+        return _nativeFee;
+    }
+}

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/IPBridgePTFactory.sol

@@ -0,0 +1,129 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import {IPGovernanceProxy} from "./IPGovernanceProxy.sol";
+import {SetConfigParam} from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/IMessageLibManager.sol";
+import {MessagingFee, MessagingReceipt} from "@layerzerolabs/oapp-evm/contracts/oapp/OApp.sol";
+import {IOAppCore} from "@layerzerolabs/oapp-evm/contracts/oapp/interfaces/IOAppCore.sol";
+
+interface IPBridgePTFactory is IOAppCore {
+    event PTOFTDeployed(uint32 indexed lzEid, bytes32 indexed originalPt, address indexed oft);
+
+    event PTOFTWired(uint32 indexed hubLzEid, address indexed hubPt, uint32[] toPeerEids);
+
+    event FactoryWired(uint32 indexed peerEid, address indexed peer);
+
+    ////////////////////////////////////////////////////////////////////////////////
+    /// Getters
+    ////////////////////////////////////////////////////////////////////////////////
+
+    function LZ_EID() external view returns (uint32);
+
+    function GOV_PROXY() external view returns (IPGovernanceProxy);
+
+    function HUB_PT_OFT_ADAPTER_CREATION_CODE() external view returns (address);
+
+    function SPOKE_PT_OFT_CREATION_CODE() external view returns (address);
+
+    function SELF_CHAIN_SHORT_NAME() external view returns (string memory);
+
+    function OFT_PROXY_ADMIN() external view returns (address);
+
+    function derivePtOftAddress(uint32 peerLzEid, uint32 hubLzEid, address hubPt) external view returns (address oft);
+
+    ////////////////////////////////////////////////////////////////////////////////
+    /// Deploy hub PT OFT adapter
+    ////////////////////////////////////////////////////////////////////////////////
+
+    function deployHubPtOftAdapter(address hubPt) external returns (address oft);
+
+    ////////////////////////////////////////////////////////////////////////////////
+    /// Deploy spoke PT OFT
+    ////////////////////////////////////////////////////////////////////////////////
+
+    struct SpokePtDeploymentParams {
+        address hubPt;
+        string name;
+        string symbol;
+        uint256 expiry;
+        uint8 decimals;
+    }
+
+    function quoteDeploySpokePtOft(address hubPt, uint32 toPeerEid, bytes calldata options, bool payInLzToken)
+        external
+        view
+        returns (MessagingFee memory fee);
+
+    function deploySpokePtOft(address hubPt, uint32 toPeerEid, bytes calldata options, MessagingFee memory fee)
+        external
+        payable
+        returns (MessagingReceipt memory msgReceipt);
+
+    ////////////////////////////////////////////////////////////////////////////////
+    /// wirePtOft on the self chain
+    ////////////////////////////////////////////////////////////////////////////////
+
+    struct WirePtOftParams {
+        uint32 hubLzEid;
+        address hubPt;
+        uint32[] toPeerEids;
+        /// @notice enforcedReceiveGas[i] is the gas limit for the receive call on toPeerEids[i];
+        ///         use 0 value = use DEFAULT_PT_OFT_ENFORCED_RECEIVE_GAS
+        uint128[] enforcedReceiveGas;
+        bool setSendLib;
+        bool setReceiveLib;
+    }
+
+    function wirePtOft(WirePtOftParams memory params) external;
+
+    ////////////////////////////////////////////////////////////////////////////////
+    /// Remote wirePtOft on the other chains
+    ////////////////////////////////////////////////////////////////////////////////
+
+    function quoteRemoteWirePtOft(
+        uint32 peerEid,
+        WirePtOftParams calldata wireParams,
+        bytes calldata options,
+        bool payInLzToken
+    ) external view returns (MessagingFee memory fee);
+
+    function remoteWirePtOft(
+        uint32 peerEid,
+        WirePtOftParams calldata wireParams,
+        bytes calldata options,
+        MessagingFee memory fee
+    ) external payable returns (MessagingReceipt memory msgReceipt);
+
+    ////////////////////////////////////////////////////////////////////////////////
+    /// Self wire
+    ////////////////////////////////////////////////////////////////////////////////
+
+    struct SelfWireParams {
+        uint32 peerEid;
+        address peer;
+        SetConfigParam[] sendConfigParam;
+        SetConfigParam[] receiveConfigParam;
+        bool setSendLib;
+        bool setReceiveLib;
+    }
+
+    function selfWire(SelfWireParams memory params) external;
+
+    ////////////////////////////////////////////////////////////////////////////////
+    /// Remote self wire
+    ////////////////////////////////////////////////////////////////////////////////
+
+    function quoteRemoteSelfWire(
+        uint32 peerEid,
+        SelfWireParams calldata wireParams,
+        bytes calldata options,
+        bool payInLzToken
+    ) external view returns (MessagingFee memory fee);
+
+    function remoteSelfWire(
+        uint32 peerEid,
+        SelfWireParams calldata wireParams,
+        bytes calldata options,
+        MessagingFee memory fee
+    ) external payable returns (MessagingReceipt memory msgReceipt);
+}

package/contracts/interfaces/IPBridgedPrincipalToken.sol

@@ -4,8 +4,10 @@ pragma solidity ^0.8.0;
 import {IOAppCore} from "@layerzerolabs/oapp-evm/contracts/oapp/interfaces/IOAppCore.sol";
 import {IOAppOptionsType3} from "@layerzerolabs/oapp-evm/contracts/oapp/interfaces/IOAppOptionsType3.sol";
 import {IOFT} from "@layerzerolabs/oft-evm/contracts/interfaces/IOFT.sol";
-import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import {
+    IERC20MetadataUpgradeable
+} from "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol";
 
-interface IPBridgedPrincipalToken is IOFT, IOAppCore, IOAppOptionsType3, IERC20Metadata {
+interface IPBridgedPrincipalToken is IOFT, IOAppCore, IOAppOptionsType3, IERC20MetadataUpgradeable {
     function expiry() external view returns (uint256);
 }

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/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
@@ -94,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,
@@ -105,6 +119,12 @@ 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;
@@ -131,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/IPMerkleDistributor.sol

@@ -3,7 +3,6 @@ pragma solidity ^0.8.0;
 
 interface IPMerkleDistributor {
     event Claimed(address indexed user, address indexed receiver, uint256 amount);
-    event Verified(address indexed user, uint256 amountClaimable);
     event SetMerkleRoot(bytes32 indexed merkleRoot);
 
     error InvalidMerkleProof();
@@ -11,10 +10,4 @@ interface IPMerkleDistributor {
     function claim(address receiver, uint256 totalAccrued, bytes32[] calldata proof)
         external
         returns (uint256 amountOut);
-
-    function claimVerified(address receiver) external returns (uint256 amountOut);
-
-    function verify(address user, uint256 totalAccrued, bytes32[] calldata proof)
-        external
-        returns (uint256 amountVerified);
 }

package/contracts/interfaces/IPMultiTokenMerkleDistributor.sol

@@ -3,9 +3,7 @@ pragma solidity ^0.8.0;
 
 interface IPMultiTokenMerkleDistributor {
     event Claimed(address indexed token, address indexed user, address indexed receiver, uint256 amount);
-    event Verified(address indexed token, address indexed user, uint256 amountClaimable);
     event SetMerkleRoot(bytes32 indexed merkleRoot);
-    event SetDefaultTokenList(address[] defaultTokenList);
 
     error InvalidMerkleProof();
 
@@ -13,15 +11,7 @@ interface IPMultiTokenMerkleDistributor {
 
     function claimed(address token, address user) external view returns (uint256);
 
-    function verified(address token, address user) external view returns (uint256);
-
     function claim(address receiver, address[] memory tokens, uint256[] memory totalAccrueds, bytes32[][] memory proofs)
         external
         returns (uint256[] memory amountOuts);
-
-    function claimVerified(address receiver, address[] memory tokens) external returns (uint256[] memory amountOuts);
-
-    function verify(address user, address[] memory tokens, uint256[] memory totalAccrueds, bytes32[][] memory proofs)
-        external
-        returns (uint256[] memory amountClaimable);
 }

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,