@pendle/core-v2 0.2.1 → 0.2.2

package/contracts/core/PendleBaseToken.sol

@@ -12,10 +12,6 @@ abstract contract PendleBaseToken is ERC20, IPBaseToken {
     uint256 public immutable expiry;
     address public immutable factory;
 
-    event Burn(address indexed user, uint256 amount);
-
-    event Mint(address indexed user, uint256 amount);
-
     constructor(
         string memory _name,
         string memory _symbol,

package/contracts/core/PendleMarket.sol

@@ -27,9 +27,6 @@ contract PendleMarket is PendleBaseToken, IPMarket, ReentrancyGuard {
 
     string private constant NAME = "Pendle Market";
     string private constant SYMBOL = "PENDLE-LPT";
-    uint256 private constant MINIMUM_LIQUIDITY = 10**3;
-    uint8 private constant DECIMALS = 18;
-    int256 internal constant RATE_PRECISION = 1e9;
 
     address public immutable OT;
     address public immutable SCY;
@@ -37,7 +34,7 @@ contract PendleMarket is PendleBaseToken, IPMarket, ReentrancyGuard {
 
     int256 public immutable scalarRoot;
     uint256 public immutable feeRateRoot; // allow fee to be changable?
-    int256 public immutable anchorRoot;
+    int256 public immutable initialAnchor;
 
     uint256 public immutable rateOracleTimeWindow;
     int8 public immutable reserveFeePercent;
@@ -49,7 +46,7 @@ contract PendleMarket is PendleBaseToken, IPMarket, ReentrancyGuard {
         uint256 _rateOracleTimeWindow,
         uint256 _feeRateRoot,
         int256 _scalarRoot,
-        int256 _anchorRoot,
+        int256 _initialAnchor,
         uint8 _reserveFeePercent
     ) PendleBaseToken(NAME, SYMBOL, 18, IPOwnershipToken(_OT).expiry()) {
         OT = _OT;
@@ -61,7 +58,7 @@ contract PendleMarket is PendleBaseToken, IPMarket, ReentrancyGuard {
 
         require(_reserveFeePercent <= 100, "invalid fee rate");
         reserveFeePercent = int8(_reserveFeePercent);
-        anchorRoot = _anchorRoot;
+        initialAnchor = _initialAnchor;
     }
 
     function addLiquidity(
@@ -90,7 +87,7 @@ contract PendleMarket is PendleBaseToken, IPMarket, ReentrancyGuard {
 
         // initializing the market
         if (lpToReserve != 0) {
-            market.setInitialImpliedRate(index, anchorRoot, block.timestamp);
+            market.setInitialImpliedRate(index, initialAnchor, block.timestamp);
             _mint(address(1), lpToReserve);
         }
 

package/contracts/core/PendleMarketFactory.sol

@@ -24,7 +24,7 @@ contract PendleMarketFactory is PermissionsV2, IPMarketFactory {
         address OT,
         uint256 feeRateRoot,
         int256 scalarRoot,
-        int256 anchorRoot,
+        int256 initialAnchor,
         uint8 reserveFeePercent,
         uint256 rateOracleTimeWindow
     ) external returns (address market) {
@@ -42,7 +42,7 @@ contract PendleMarketFactory is PermissionsV2, IPMarketFactory {
                 rateOracleTimeWindow,
                 feeRateRoot,
                 scalarRoot,
-                anchorRoot,
+                initialAnchor,
                 reserveFeePercent
             )
         );

package/contracts/core/PendleOwnershipToken.sol

@@ -34,11 +34,9 @@ contract PendleOwnershipToken is PendleBaseToken, IPOwnershipToken {
 
     function burnByYT(address user, uint256 amount) external onlyYT {
         _burn(user, amount);
-        emit Burn(user, amount);
     }
 
     function mintByYT(address user, uint256 amount) external onlyYT {
         _mint(user, amount);
-        emit Mint(user, amount);
     }
 }

package/contracts/core/router/PendleRouterProxy.sol

@@ -7,6 +7,7 @@ import "../misc/BoringOwnableUpg.sol";
 import "@openzeppelin/contracts/proxy/Proxy.sol";
 import "../../interfaces/IPRouterCore.sol";
 import "../../interfaces/IPRouterYT.sol";
+import "../../interfaces/IPRouterStatic.sol";
 
 /// @dev this contract will be deployed behind an ERC1967 proxy
 /// calls to the ERC1967 proxy will be resolved at this contract, and proxied again to the
@@ -14,10 +15,12 @@ import "../../interfaces/IPRouterYT.sol";
 contract PendleRouterProxy is Proxy, Initializable, UUPSUpgradeable, BoringOwnableUpg {
     address public immutable PENDLE_ROUTER_CORE;
     address public immutable PENDLE_ROUTER_YT;
+    address public immutable PENDLE_ROUTER_STATIC;
 
-    constructor(address _PENDLE_ROUTER_CORE, address _PENDLE_ROUTER_YT) {
+    constructor(address _PENDLE_ROUTER_CORE, address _PENDLE_ROUTER_YT, address _PENDLE_ROUTER_STATIC) {
         PENDLE_ROUTER_CORE = _PENDLE_ROUTER_CORE;
         PENDLE_ROUTER_YT = _PENDLE_ROUTER_YT;
+        PENDLE_ROUTER_STATIC = _PENDLE_ROUTER_STATIC;
     }
 
     function initialize() external initializer {
@@ -53,6 +56,17 @@ contract PendleRouterProxy is Proxy, Initializable, UUPSUpgradeable, BoringOwnab
             // only ROUTER_YT is doing callback
             return PENDLE_ROUTER_YT;
         }
+        /// FROM HERE ONWARDS, ONLY HAVE STATIC & VIEW FUNCTIONS
+        else if (
+            sig == IPRouterStatic.addLiquidityStatic.selector ||
+            sig == IPRouterStatic.removeLiquidityStatic.selector ||
+            sig == IPRouterStatic.swapOtForScyStatic.selector ||
+            sig == IPRouterStatic.swapScyForOtStatic.selector ||
+            sig == IPRouterStatic.scyIndex.selector ||
+            sig == IPRouterStatic.getOtImpliedYield.selector
+        ) {
+            return PENDLE_ROUTER_STATIC;
+        }
         require(false, "invalid market sig");
     }
 

package/contracts/core/router/PendleRouterStatic.sol

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+
+import "../../interfaces/IPRouterStatic.sol";
+
+contract PendleRouterStaticUpg is IPRouterStatic {
+    using MarketMathLib for MarketParameters;
+    using FixedPoint for uint256;
+    using FixedPoint for int256;
+    using LogExpMath for int256;
+
+    /// @dev since this contract will be proxied, it must not contains non-immutable variabless
+    constructor(
+        address _joeRouter,
+        address _joeFactory,
+        address _marketFactory //solhint-disable-next-line no-empty-blocks
+    ) {}
+
+    function addLiquidityStatic(
+        address market,
+        uint256 scyDesired,
+        uint256 otDesired
+    )
+        external
+        returns (
+            uint256 netLpOut,
+            uint256 scyUsed,
+            uint256 otUsed
+        )
+    {
+        MarketParameters memory state = IPMarket(market).readState();
+        (, netLpOut, scyUsed, otUsed) = state.addLiquidity(
+            scyIndex(market),
+            scyDesired,
+            otDesired
+        );
+    }
+
+    function removeLiquidityStatic(address market, uint256 lpToRemove)
+        external
+        view
+        returns (uint256 netScyOut, uint256 netOtOut)
+    {
+        MarketParameters memory state = IPMarket(market).readState();
+        (netScyOut, netOtOut) = state.removeLiquidity(lpToRemove);
+    }
+
+    function swapOtForScyStatic(address market, uint256 exactOtIn)
+        external
+        returns (uint256 netScyOut, uint256 netScyFee)
+    {
+        MarketParameters memory state = IPMarket(market).readState();
+        (netScyOut, netScyFee) = state.swapExactOtForScy(
+            scyIndex(market),
+            exactOtIn,
+            block.timestamp
+        );
+    }
+
+    function swapScyForOtStatic(address market, uint256 exactOtOut)
+        external
+        returns (uint256 netScyIn, uint256 netScyFee)
+    {
+        MarketParameters memory state = IPMarket(market).readState();
+        (netScyIn, netScyFee) = state.swapScyForExactOt(
+            scyIndex(market),
+            exactOtOut,
+            block.timestamp
+        );
+    }
+
+    function scyIndex(address market) public returns (SCYIndex index) {
+        return SCYIndexLib.newIndex(IPMarket(market).SCY());
+    }
+
+    function getOtImpliedYield(address market) external view returns (int256) {
+        MarketParameters memory state = IPMarket(market).readState();
+
+        int256 lnImpliedRate = (state.lastImpliedRate).Int();
+        return lnImpliedRate.exp();
+    }
+}

package/contracts/interfaces/IPRouterStatic.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+
+import "../libraries/math/MarketMathLib.sol";
+
+interface IPRouterStatic {
+    function addLiquidityStatic(
+        address market,
+        uint256 scyDesired,
+        uint256 otDesired
+    )
+        external
+        returns (
+            uint256 netLpOut,
+            uint256 scyUsed,
+            uint256 otUsed
+        );
+
+    function removeLiquidityStatic(address market, uint256 lpToRemove)
+        external
+        view
+        returns (uint256 netScyOut, uint256 netOtOut);
+
+    function swapOtForScyStatic(address market, uint256 exactOtIn)
+        external
+        returns (uint256 netScyOut, uint256 netScyFee);
+
+    function swapScyForOtStatic(address market, uint256 exactOtOut)
+        external
+        returns (uint256 netScyIn, uint256 netScyFee);
+
+    function scyIndex(address market) external returns (SCYIndex index);
+
+    function getOtImpliedYield(address market) external view returns (int256);
+}

package/contracts/libraries/math/FixedPoint.sol

@@ -24,9 +24,6 @@ library FixedPoint {
 
     uint256 internal constant MAX_POW_RELATIVE_ERROR = 10000; // 10^(-14)
 
-    // Minimum base for the power function when the exponent is 'free' (larger than ONE).
-    uint256 internal constant MIN_POW_BASE_FREE_EXPONENT = 0.7e18;
-
     function subMax0(uint256 a, uint256 b) internal pure returns (uint256) {
         return (a >= b ? a - b : 0);
     }
@@ -49,7 +46,7 @@ library FixedPoint {
 
     function mulDown(int256 a, int256 b) internal pure returns (int256) {
         int256 product = a * b;
-        return product / Int(ONE);
+        return product / ONE_INT;
     }
 
     function mulDown(int256 a, uint256 b) internal pure returns (int256) {
@@ -89,7 +86,7 @@ library FixedPoint {
         if (a == 0) {
             return 0;
         } else {
-            int256 aInflated = a * Int(ONE);
+            int256 aInflated = a * ONE_INT;
             return aInflated / b;
         }
     }
@@ -192,12 +189,12 @@ library FixedPoint {
     }
 
     function Int128(int256 x) internal pure returns (int128) {
-        require(0 <= x && x <= type(int128).max);
+        require(x <= type(int128).max);
         return int128(x);
     }
 
     function Uint32(uint256 x) internal pure returns (uint32) {
-        require(0 <= x && x <= type(uint32).max);
+        require(x <= type(uint32).max);
         return uint32(x);
     }