@pendle/core-v2 5.10.2 → 5.12.0-cross-chain-pt

package/contracts/LiquidityMining/CrossChainMsg/PendleMsgReceiveEndpointUpg.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.8.17;
 import "../../interfaces/ILayerZeroEndpoint.sol";
 import "../../interfaces/IPMsgReceiverApp.sol";
 import "../../interfaces/ILayerZeroReceiver.sol";
-import "../../core/libraries/BoringOwnableUpgradeable.sol";
+import "../../core/libraries/BoringOwnableUpgradeableV2.sol";
 import "../../core/libraries/Errors.sol";
 import "./libraries/LayerZeroHelper.sol";
 import "./libraries/ExcessivelySafeCall.sol";
@@ -15,7 +15,7 @@ import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
  * So we can leave the configuration unset.
  */
 
-contract PendleMsgReceiveEndpointUpg is ILayerZeroReceiver, Initializable, UUPSUpgradeable, BoringOwnableUpgradeable {
+contract PendleMsgReceiveEndpointUpg is ILayerZeroReceiver, Initializable, UUPSUpgradeable, BoringOwnableUpgradeableV2 {
     using ExcessivelySafeCall for address;
 
     address public immutable lzEndpoint;
@@ -50,8 +50,8 @@ contract PendleMsgReceiveEndpointUpg is ILayerZeroReceiver, Initializable, UUPSU
         sendEndpointChainId = _sendEndpointChainId;
     }
 
-    function initialize() external initializer {
-        __BoringOwnable_init();
+    function initialize(address _owner) external initializer {
+        __BoringOwnableV2_init(_owner);
     }
 
     function lzReceive(

package/contracts/LiquidityMining/CrossChainMsg/PendleMsgReceiverAppUpg.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.0;
 
 import "../../interfaces/IPMsgReceiverApp.sol";
-import "../../core/libraries/BoringOwnableUpgradeable.sol";
+import "../../core/libraries/BoringOwnableUpgradeableV2.sol";
 import "../../core/libraries/Errors.sol";
 
 // solhint-disable no-empty-blocks

package/contracts/LiquidityMining/CrossChainMsg/PendleMsgSendEndpointUpg.sol

@@ -3,7 +3,7 @@ pragma solidity ^0.8.17;
 
 import "../../interfaces/IPMsgSendEndpoint.sol";
 import "../../interfaces/ILayerZeroEndpoint.sol";
-import "../../core/libraries/BoringOwnableUpgradeable.sol";
+import "../../core/libraries/BoringOwnableUpgradeableV2.sol";
 import "../../core/libraries/Errors.sol";
 import "./libraries/LayerZeroHelper.sol";
 import "@openzeppelin/contracts/utils/structs/EnumerableMap.sol";
@@ -14,7 +14,7 @@ import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
  * So we can leave the configuration unset.
  */
 
-contract PendleMsgSendEndpointUpg is IPMsgSendEndpoint, Initializable, UUPSUpgradeable, BoringOwnableUpgradeable {
+contract PendleMsgSendEndpointUpg is IPMsgSendEndpoint, Initializable, UUPSUpgradeable, BoringOwnableUpgradeableV2 {
     using EnumerableMap for EnumerableMap.UintToAddressMap;
 
     address payable public immutable refundAddress;
@@ -33,8 +33,8 @@ contract PendleMsgSendEndpointUpg is IPMsgSendEndpoint, Initializable, UUPSUpgra
         lzEndpoint = _lzEndpoint;
     }
 
-    function initialize() external initializer {
-        __BoringOwnable_init();
+    function initialize(address _owner) external initializer {
+        __BoringOwnableV2_init(_owner);
     }
 
     function calcFee(

package/contracts/LiquidityMining/CrossChainMsg/PendleMsgSenderAppUpg.sol

@@ -2,13 +2,13 @@
 pragma solidity ^0.8.0;
 
 import "../../interfaces/IPMsgSendEndpoint.sol";
-import "../../core/libraries/BoringOwnableUpgradeable.sol";
+import "../../core/libraries/BoringOwnableUpgradeableV2.sol";
 import "../../core/libraries/Errors.sol";
 import "@openzeppelin/contracts/utils/structs/EnumerableMap.sol";
 
 // solhint-disable no-empty-blocks
 
-abstract contract PendleMsgSenderAppUpg is BoringOwnableUpgradeable {
+abstract contract PendleMsgSenderAppUpg is BoringOwnableUpgradeableV2 {
     using EnumerableMap for EnumerableMap.UintToAddressMap;
 
     uint256 public approxDstExecutionGas;

package/contracts/LiquidityMining/GaugeController/PendleGaugeControllerBaseUpg.sol

@@ -3,7 +3,7 @@ pragma solidity ^0.8.0;
 
 import "../../core/libraries/math/PMath.sol";
 import "../../core/libraries/Errors.sol";
-import "../../core/libraries/BoringOwnableUpgradeable.sol";
+import "../../core/libraries/BoringOwnableUpgradeableV2.sol";
 
 import "../libraries/WeekMath.sol";
 
@@ -24,7 +24,7 @@ import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
  * on inheriting contracts
  */
 
-abstract contract PendleGaugeControllerBaseUpg is IPGaugeController, BoringOwnableUpgradeable, UUPSUpgradeable {
+abstract contract PendleGaugeControllerBaseUpg is IPGaugeController, BoringOwnableUpgradeableV2, UUPSUpgradeable {
     using SafeERC20 for IERC20;
     using PMath for uint256;
 

package/contracts/LiquidityMining/GaugeController/PendleGaugeControllerMainchainUpg.sol

@@ -24,8 +24,8 @@ contract PendleGaugeControllerMainchainUpg is PendleGaugeControllerBaseUpg, IPGa
         _disableInitializers();
     }
 
-    function initialize() external initializer {
-        __BoringOwnable_init();
+    function initialize(address _owner) external initializer {
+        __BoringOwnableV2_init(_owner);
     }
 
     function updateVotingResults(

package/contracts/LiquidityMining/GaugeController/PendleGaugeControllerSidechainUpg.sol

@@ -21,8 +21,8 @@ contract PendleGaugeControllerSidechainUpg is PendleGaugeControllerBaseUpg, Pend
         _disableInitializers();
     }
 
-    function initialize() external initializer {
-        __BoringOwnable_init();
+    function initialize(address _owner) external initializer {
+        __BoringOwnableV2_init(_owner);
     }
 
     function _executeMessage(bytes memory message) internal virtual override {

package/contracts/LiquidityMining/PendleMerkleDistributor.sol

@@ -4,11 +4,11 @@ pragma solidity ^0.8.17;
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
-import "../core/libraries/BoringOwnableUpgradeable.sol";
+import "../core/libraries/BoringOwnableUpgradeableV2.sol";
 import "../core/libraries/TokenHelper.sol";
 import "../interfaces/IPMerkleDistributor.sol";
 
-contract PendleMerkleDistributor is IPMerkleDistributor, UUPSUpgradeable, BoringOwnableUpgradeable, TokenHelper {
+contract PendleMerkleDistributor is IPMerkleDistributor, UUPSUpgradeable, BoringOwnableUpgradeableV2, TokenHelper {
     address public immutable token;
 
     bytes32 public merkleRoot;
@@ -22,8 +22,8 @@ contract PendleMerkleDistributor is IPMerkleDistributor, UUPSUpgradeable, Boring
 
     receive() external payable {}
 
-    function initialize() external initializer {
-        __BoringOwnable_init();
+    function initialize(address _owner) external initializer {
+        __BoringOwnableV2_init(_owner);
     }
 
     function claim(

package/contracts/LiquidityMining/VotingController/PendleVotingControllerUpg.sol

@@ -52,8 +52,8 @@ contract PendleVotingControllerUpg is PendleMsgSenderAppUpg, VotingControllerSto
 
     }
 
-    function initialize() external initializer {
-        __BoringOwnable_init();
+    function initialize(address _owner) external initializer {
+        __BoringOwnableV2_init(_owner);
         deployedWTime = WeekMath.getCurrentWeekStart();
     }
 

package/contracts/LiquidityMining/VotingEscrow/VotingEscrowPendleMainchain.sol

@@ -47,7 +47,7 @@ contract VotingEscrowPendleMainchain is VotingEscrowTokenBase, IPVotingEscrowMai
     ) initializer PendleMsgSenderAppUpg(_pendleMsgSendEndpoint, initialApproxDestinationGas) {
         pendle = _pendle;
         lastSlopeChangeAppliedAt = WeekMath.getCurrentWeekStart();
-        __BoringOwnable_init();
+        __BoringOwnableV2_init(msg.sender);
     }
 
     /// @notice basically a proxy function to call increaseLockPosition & broadcastUserPosition at the same time

package/contracts/LiquidityMining/VotingEscrow/VotingEscrowPendleSidechain.sol

@@ -9,7 +9,7 @@ import "./VotingEscrowTokenBase.sol";
 import "../CrossChainMsg/PendleMsgReceiverAppUpg.sol";
 
 // solhint-disable no-empty-blocks
-contract VotingEscrowPendleSidechain is VotingEscrowTokenBase, PendleMsgReceiverAppUpg, BoringOwnableUpgradeable {
+contract VotingEscrowPendleSidechain is VotingEscrowTokenBase, PendleMsgReceiverAppUpg, BoringOwnableUpgradeableV2 {
     uint256 public lastTotalSupplyReceivedAt;
 
     mapping(address => address) internal delegatorOf;
@@ -23,7 +23,7 @@ contract VotingEscrowPendleSidechain is VotingEscrowTokenBase, PendleMsgReceiver
     constructor(
         address _PendleMsgReceiveEndpointUpg
     ) initializer PendleMsgReceiverAppUpg(_PendleMsgReceiveEndpointUpg) {
-        __BoringOwnable_init();
+        __BoringOwnableV2_init(msg.sender);
     }
 
     function totalSupplyCurrent() public view virtual override returns (uint128) {

package/contracts/core/Market/v3/PendleMarketFactoryV3.sol

@@ -8,9 +8,9 @@ import "../../../interfaces/IPMarketFactoryV3.sol";
 
 import "../../libraries/BaseSplitCodeFactory.sol";
 import "../../libraries/Errors.sol";
-import "../../libraries/BoringOwnableUpgradeable.sol";
+import "../../libraries/BoringOwnableUpgradeableV2.sol";
 
-contract PendleMarketFactoryV3 is BoringOwnableUpgradeable, IPMarketFactoryV3 {
+contract PendleMarketFactoryV3 is BoringOwnableUpgradeableV2, IPMarketFactoryV3 {
     using EnumerableSet for EnumerableSet.AddressSet;
 
     address public immutable marketCreationCodeContractA;
@@ -55,7 +55,7 @@ contract PendleMarketFactoryV3 is BoringOwnableUpgradeable, IPMarketFactoryV3 {
         marketCreationCodeContractB = _marketCreationCodeContractB;
         marketCreationCodeSizeB = _marketCreationCodeSizeB;
 
-        __BoringOwnable_init();
+        __BoringOwnableV2_init(msg.sender);
         setTreasuryAndFeeReserve(_treasury, _reserveFeePercent);
 
         vePendle = _vePendle;

package/contracts/core/YieldContracts/PendleYieldContractFactory.sol

@@ -32,14 +32,14 @@ import "../libraries/ExpiryUtilsLib.sol";
 import "../libraries/BaseSplitCodeFactory.sol";
 import "../libraries/MiniHelpers.sol";
 import "../libraries/Errors.sol";
-import "../libraries/BoringOwnableUpgradeable.sol";
+import "../libraries/BoringOwnableUpgradeableV2.sol";
 import "../libraries/StringLib.sol";
 
 import "./PendlePrincipalToken.sol";
 import "./PendleYieldToken.sol";
 
 /// @dev If this contract is ever made upgradeable, please pay attention to the numContractDeployed variable
-contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContractFactory {
+contract PendleYieldContractFactory is BoringOwnableUpgradeableV2, IPYieldContractFactory {
     using ExpiryUtils for string;
     using StringLib for string;
     using StringLib for StringLib.slice;
@@ -90,7 +90,7 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContract
         uint128 _rewardFeeRate,
         address _treasury
     ) external initializer {
-        __BoringOwnable_init();
+        __BoringOwnableV2_init(msg.sender);
         setExpiryDivisor(_expiryDivisor);
         setInterestFeeRate(_interestFeeRate);
         setRewardFeeRate(_rewardFeeRate);

package/contracts/core/libraries/BoringOwnableUpgradeableV2.sol

@@ -2,7 +2,11 @@
 pragma solidity ^0.8.0;
 
 import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
-import {BoringOwnableUpgradeableData} from "./BoringOwnableUpgradeable.sol";
+
+contract BoringOwnableUpgradeableData {
+    address public owner;
+    address public pendingOwner;
+}
 
 abstract contract BoringOwnableUpgradeableV2 is BoringOwnableUpgradeableData, Initializable {
     event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

package/contracts/cross-chain/FixedPricePTAMM.sol

@@ -0,0 +1,121 @@
+// SPDX-License-Identifier: SEE LICENSE IN LICENSE
+pragma solidity ^0.8.19;
+
+import {IPFixedPricePTAMM, IPFixedPricePTAMMSwapCallback} from "../interfaces/IPFixedPricePTAMM.sol";
+import {IPChainlinkOracleEssential} from "../interfaces/IPChainlinkOracleEssential.sol";
+import {IPBridgedPrincipalToken} from "../interfaces/IPBridgedPrincipalToken.sol";
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {ReentrancyGuardUpgradeable} from "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
+
+import {PMath} from "../core/libraries/math/PMath.sol";
+import {BoringOwnableUpgradeableV2} from "../core/libraries/BoringOwnableUpgradeableV2.sol";
+import {TokenHelper} from "../core/libraries/TokenHelper.sol";
+
+contract FixedPricePTAMM is IPFixedPricePTAMM, BoringOwnableUpgradeableV2, ReentrancyGuardUpgradeable, TokenHelper {
+    // cast index-erc7201 "pendle.FixedPricePTAMM.storage"
+    uint256 internal constant STORAGE_SLOT = 0xbbf04d9aae855c6bd76c8f4ba7a918994ad0d002f537323e58c83cbfe5249000;
+
+    error OracleNotSet(address PT, address token);
+    error InsufficientTokenForTrade(address token, uint256 actualAmount, uint256 requiredAmount);
+    error InsufficientPtReceived(address PT, uint256 actualAmount, uint256 requiredAmount);
+
+    using PMath for uint256;
+    using PMath for int256;
+
+    constructor() {
+        _disableInitializers();
+    }
+
+    function initialize(address _owner) external initializer {
+        __BoringOwnableV2_init(_owner);
+    }
+
+    struct Storage {
+        mapping(address PT => mapping(address token => address oracle)) priceOracle;
+        mapping(address token => uint256) totalToken;
+    }
+
+    function $() internal pure returns (Storage storage res) {
+        assembly ("memory-safe") {
+            res.slot := STORAGE_SLOT
+        }
+    }
+
+    function priceOracle(address PT, address token) public view returns (IPChainlinkOracleEssential) {
+        address res = $().priceOracle[PT][token];
+        if (res == address(0)) revert OracleNotSet(PT, token);
+        return IPChainlinkOracleEssential(res);
+    }
+
+    function getPtToTokenPrice(address PT, address token) public view returns (uint256) {
+        (, int256 ptPrice, , , ) = priceOracle(PT, token).latestRoundData();
+        return ptPrice.Uint();
+    }
+
+    function swapPtForExactToken(
+        address receiver,
+        address PT,
+        address token,
+        uint256 exactTokenOut,
+        bytes calldata data
+    ) external payable nonReentrant returns (uint256 netPtIn) {
+        netPtIn = exactTokenOut.divDown(getPtToTokenPrice(PT, token));
+        _swap(receiver, PT, netPtIn, token, exactTokenOut, data);
+    }
+
+    function swapExactPtForToken(
+        address receiver,
+        address PT,
+        uint256 exactPtIn,
+        address token,
+        bytes calldata data
+    ) external payable nonReentrant returns (uint256 netTokenOut) {
+        netTokenOut = exactPtIn.mulDown(getPtToTokenPrice(PT, token));
+        _swap(receiver, PT, exactPtIn, token, netTokenOut, data);
+    }
+
+    function _swap(
+        address receiver,
+        address PT,
+        uint256 exactPtIn,
+        address token,
+        uint256 exactTokenOut,
+        bytes calldata data
+    ) internal {
+        if ($().totalToken[token] < exactTokenOut)
+            revert InsufficientTokenForTrade(token, $().totalToken[token], exactTokenOut);
+
+        _transferOut(token, receiver, exactTokenOut);
+        $().totalToken[token] -= exactTokenOut;
+
+        if (data.length > 0) {
+            IPFixedPricePTAMMSwapCallback(msg.sender).swapCallback(exactTokenOut, exactPtIn, data);
+        }
+
+        $().totalToken[PT] += exactPtIn;
+        if (_selfBalance(PT) < $().totalToken[PT])
+            revert InsufficientPtReceived(PT, _selfBalance(PT), $().totalToken[PT]);
+
+        emit Swap(msg.sender, receiver, PT, exactPtIn, token, exactTokenOut);
+    }
+
+    // Admin functions
+
+    function setPriceOracle(address PT, address token, address _priceOracle) external onlyOwner {
+        $().priceOracle[PT][token] = _priceOracle;
+        emit PriceOracleUpdated(PT, token, _priceOracle);
+    }
+
+    function addFund(address token, uint256 amount) external payable onlyOwner {
+        _transferIn(token, owner, amount);
+        $().totalToken[token] += amount;
+        emit Seeded(token, amount);
+    }
+
+    function removeFund(address token, uint256 amount) external onlyOwner {
+        _transferOut(token, owner, amount);
+        $().totalToken[token] -= amount;
+        emit Unseeded(token, amount);
+    }
+}

package/contracts/cross-chain/factory/hub/PendlePTOFTAdapterFactory.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import {IPPTOFTAdapterFactory} from "../../../interfaces/IPPTOFTAdapterFactory.sol";
+import {BoringOwnableUpgradeableV2} from "../../../core/libraries/BoringOwnableUpgradeableV2.sol";
+import {OFTAdapterImpl} from "../..//oftImpl/hub/OFTAdapterImpl.sol";
+
+contract PendlePTOFTAdapterFactory is IPPTOFTAdapterFactory, BoringOwnableUpgradeableV2 {
+    error PTOFTAdapterExisted(address pt);
+
+    address internal immutable _lzEndpoint;
+
+    constructor(address lzEndpoint) {
+        _disableInitializers();
+        _lzEndpoint = lzEndpoint;
+    }
+
+    function initialize(address _owner) external initializer {
+        __BoringOwnableV2_init(_owner);
+    }
+
+    mapping(address pt => address) public ptAdapter;
+
+    function createPtAdapter(address pt) external override onlyOwner returns (address) {
+        if (ptAdapter[pt] != address(0)) revert PTOFTAdapterExisted(pt);
+
+        OFTAdapterImpl adapter = new OFTAdapterImpl(pt, _lzEndpoint, owner);
+        adapter.transferOwnership(owner);
+        emit PtAdapterCreated(pt, address(adapter));
+
+        return ptAdapter[pt] = address(adapter);
+    }
+}

package/contracts/cross-chain/oftImpl/hub/OFTAdapterImpl.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.0;
+
+import {OFTAdapter} from "@layerzerolabs/oft-evm/contracts/OFTAdapter.sol";
+
+// @notice Base OFT contract, without any additional functionality (like RateLimiter).
+// @dev This contract inherits Ownable from OpenZeppelin v4.
+// @dev Sender is set as the contract owner at deployment.
+contract OFTAdapterImpl is OFTAdapter {
+    constructor(address _token, address _endpoint, address _delegate) OFTAdapter(_token, _endpoint, _delegate) {}
+}

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

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.19;
+
+import {IPBridgedPrincipalToken} from "../../../interfaces/IPBridgedPrincipalToken.sol";
+import {OFT, OFTCore, IOFT} 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";
+
+abstract contract BasePendleBridgedPrincipalToken is IPBridgedPrincipalToken, OFT {
+    uint256 public immutable expiry;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _lzEndpoint,
+        address _delegate,
+        uint256 _expiry
+    ) OFT(_name, _symbol, _lzEndpoint, _delegate) {
+        expiry = _expiry;
+    }
+}
+
+/**
+ * The below contracts only overrides the `decimals()` and `sharedDecimals()` function
+ * - For Pendle PT, the decimals are based on the underlying asset. So we need
+ *   to set the decimals correctly at **deployment**.
+ * - For technical reason, in OFT's constructor, the `decimals()` function was
+ *   invoked.
+ *   (https://github.com/LayerZero-Labs/devtools/blob/feb000c1717ee89f965996cc9ab5a8a75effbcab/packages/oft-evm/contracts/OFT.sol#L25)
+ * - The current best way to do this is to hard-code the decimals in the contracts.
+ */
+
+// prettier-ignore
+contract PendleBridgedPrincipalToken_18Decimals is BasePendleBridgedPrincipalToken {
+    constructor(string memory _name, string memory _symbol, address _lzEndpoint, address _delegate, uint256 _expiry)
+        BasePendleBridgedPrincipalToken(_name, _symbol, _lzEndpoint, _delegate, _expiry)
+    {}
+
+    function decimals() public pure override(ERC20, IERC20Metadata) returns (uint8) { return 18; }
+    function sharedDecimals() public pure override(OFTCore, IOFT) returns (uint8) { return 6; }
+}
+
+// prettier-ignore
+contract PendleBridgedPrincipalToken_6Decimals is BasePendleBridgedPrincipalToken {
+    constructor(string memory _name, string memory _symbol, address _lzEndpoint, address _delegate, uint256 _expiry)
+        BasePendleBridgedPrincipalToken(_name, _symbol, _lzEndpoint, _delegate, _expiry)
+    {}
+
+    function decimals() public pure override(ERC20, IERC20Metadata) returns (uint8) { return 6; }
+    function sharedDecimals() public pure override(OFTCore, IOFT) returns (uint8) { return 6; }
+}
+
+// prettier-ignore
+contract PendleBridgedPrincipalToken_8Decimals is BasePendleBridgedPrincipalToken {
+    constructor(string memory _name, string memory _symbol, address _lzEndpoint, address _delegate, uint256 _expiry)
+        BasePendleBridgedPrincipalToken(_name, _symbol, _lzEndpoint, _delegate, _expiry)
+    {}
+
+    function decimals() public pure override(ERC20, IERC20Metadata) returns (uint8) { return 8; }
+    function sharedDecimals() public pure override(OFTCore, IOFT) returns (uint8) { return 6; }
+}