@pendle/core-v2 5.11.0 → 5.12.1-cross-chain-pt

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; }
+}

package/contracts/interfaces/IPBridgedPrincipalToken.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import {IOFT} from "@layerzerolabs/oft-evm/contracts/interfaces/IOFT.sol";
+import {IOAppCore} from "@layerzerolabs/oapp-evm/contracts/oapp/interfaces/IOAppCore.sol";
+import {IOAppOptionsType3} from "@layerzerolabs/oapp-evm/contracts/oapp/interfaces/IOAppOptionsType3.sol";
+
+interface IPBridgedPrincipalToken is IOFT, IOAppCore, IOAppOptionsType3, IERC20Metadata {
+    function expiry() external view returns (uint256);
+}

package/contracts/interfaces/IPChainlinkOracleEssential.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IPChainlinkOracleEssential {
+    function decimals() external view returns (uint8);
+
+    function latestRoundData()
+        external
+        view
+        returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
+}

package/contracts/interfaces/IPFixedPricePTAMM.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: SEE LICENSE IN LICENSE
+pragma solidity ^0.8.19;
+
+import {IPBridgedPrincipalToken} from "./IPBridgedPrincipalToken.sol";
+import {IPChainlinkOracleEssential} from "../interfaces/IPChainlinkOracleEssential.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+interface IPFixedPricePTAMM {
+    event Swap(
+        address indexed caller,
+        address indexed receiver,
+        address PT,
+        uint256 netPtIn,
+        address token,
+        uint256 netTokenOut
+    );
+
+    event PriceOracleUpdated(address indexed PT, address indexed token, address indexed priceOracle);
+
+    event Seeded(address indexed token, uint256 amount);
+    event Unseeded(address indexed token, uint256 amount);
+
+    function priceOracle(address PT, address token) external view returns (IPChainlinkOracleEssential);
+
+    function getPtToTokenPrice(address PT, address token) external view returns (uint256);
+
+    function swapPtForExactToken(
+        address receiver,
+        address PT,
+        address token,
+        uint256 exactTokenOut,
+        bytes calldata data
+    ) external payable returns (uint256 netPtIn);
+
+    function swapExactPtForToken(
+        address receiver,
+        address PT,
+        uint256 exactPtIn,
+        address token,
+        bytes calldata data
+    ) external payable returns (uint256 netTokenOut);
+
+    // Admin functions
+
+    function setPriceOracle(address PT, address token, address priceOracle) external;
+
+    function addFund(address token, uint256 amount) external payable;
+
+    function removeFund(address token, uint256 amount) external;
+}
+
+interface IPFixedPricePTAMMSwapCallback {
+    function swapCallback(uint256 exactTokenOut, uint256 netPtIn, bytes calldata data) external;
+}

package/contracts/interfaces/IPPTOFTAdapterFactory.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IPPTOFTAdapterFactory {
+    event PtAdapterCreated(address indexed pt, address indexed adapter);
+
+    function initialize(address _owner) external;
+
+    function createPtAdapter(address pt) external returns (address);
+
+    function ptAdapter(address pt) external view returns (address);
+}

package/contracts/offchain-helpers/PendleMulticallOwnerV1.sol

@@ -10,7 +10,7 @@ contract PendleMulticallOwnerV1 is BoringOwnableUpgradeableV2 {
         bytes callData;
     }
 
-    constructor(address _owner) {
+    constructor(address _owner) initializer {
         __BoringOwnableV2_init(_owner);
     }
 

package/contracts/oracles/internal/PendleSparkLinearDiscountOracle.sol

@@ -1,7 +1,9 @@
 // SPDX-License-Identifier: SEE LICENSE IN LICENSE
 pragma solidity ^0.8.19;
 
-contract PendleSparkLinearDiscountOracle {
+import {IPChainlinkOracleEssential} from "../../interfaces/IPChainlinkOracleEssential.sol";
+
+contract PendleSparkLinearDiscountOracle is IPChainlinkOracleEssential {
     uint256 private constant SECONDS_PER_YEAR = 365 days;
     uint256 private constant ONE = 1e18;
 

package/deployments/1-core.json

@@ -60,5 +60,6 @@
     "feeDistributor": "0xd7b34a6fDCb2A7ceD2115FF7f5fdD72aa6aA4dE2",
     "feeDistributorV2": "0x8C237520a8E14D658170A633D96F8e80764433b9",
     "lpWrapperFactory": "0x12930Bd944bb34B0A21CCc2E7d32a6834Bd58e19",
-    "decimalsFactory": "0x992ec6a490a4b7f256bd59e63746951d98b29be9"
+    "decimalsFactory": "0x992ec6a490a4b7f256bd59e63746951d98b29be9",
+    "ptOftAdapterFactory": "0x6f2a9b773778188727cc1f49c57213b1a758555e"
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "5.11.0",
+  "version": "5.12.1-cross-chain-pt",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",
@@ -46,8 +46,11 @@
   "packageManager": "yarn@3.3.1",
   "dependencies": {
     "@chainlink/contracts": "^0.8.0",
+    "@layerzerolabs/lz-evm-protocol-v2": "^3.0.75",
+    "@layerzerolabs/oapp-evm": "^0.3.2",
+    "@layerzerolabs/oft-evm": "^3.1.4",
     "@openzeppelin/contracts": "4.9.3",
     "@openzeppelin/contracts-upgradeable": "4.9.3",
     "ethers": "^5.7.2"
   }
-}
+}