@pendle/core-v2 0.5.1-beta-4 → 0.6.0

package/contracts/libraries/math/MarketMathCore.sol

@@ -6,19 +6,19 @@ import "./LogExpMath.sol";
 import "../SCYIndex.sol";
 
 struct MarketState {
-    int256 totalOt;
+    int256 totalPt;
     int256 totalScy;
     int256 totalLp;
     uint256 oracleRate;
     address treasury;
     /// immutable variables ///
     int256 scalarRoot;
-    uint256 feeRateRoot;
+    uint256 lnFeeRateRoot;
     uint256 rateOracleTimeWindow;
     uint256 expiry;
     uint256 reserveFeePercent; // base 100
     /// last trade data ///
-    uint256 lastImpliedRate;
+    uint256 lastLnImpliedRate;
     uint256 lastTradeTime;
 }
 
@@ -27,15 +27,7 @@ struct MarketPreCompute {
     int256 rateScalar;
     int256 totalAsset;
     int256 rateAnchor;
-    int256 feeRate;
-}
-
-struct MarketStorage {
-    int128 totalOt;
-    int128 totalScy;
-    uint112 lastImpliedRate;
-    uint112 oracleRate;
-    uint32 lastTradeTime;
+    int256 lnFeeRate;
 }
 
 // solhint-disable ordering
@@ -56,7 +48,7 @@ library MarketMathCore {
         MarketState memory market,
         SCYIndex index,
         int256 scyDesired,
-        int256 otDesired,
+        int256 ptDesired,
         bool updateState
     )
         internal
@@ -65,13 +57,13 @@ library MarketMathCore {
             int256 lpToReserve,
             int256 lpToAccount,
             int256 scyUsed,
-            int256 otUsed
+            int256 ptUsed
         )
     {
         /// ------------------------------------------------------------
         /// CHECKS
         /// ------------------------------------------------------------
-        require(scyDesired > 0 && otDesired > 0, "ZERO_AMOUNTS");
+        require(scyDesired > 0 && ptDesired > 0, "ZERO_AMOUNTS");
 
         /// ------------------------------------------------------------
         /// MATH
@@ -80,18 +72,18 @@ library MarketMathCore {
             lpToAccount = index.scyToAsset(scyDesired).subNoNeg(MINIMUM_LIQUIDITY);
             lpToReserve = MINIMUM_LIQUIDITY;
             scyUsed = scyDesired;
-            otUsed = otDesired;
+            ptUsed = ptDesired;
         } else {
-            int256 netLpByOt = (otDesired * market.totalLp) / market.totalOt;
+            int256 netLpByPt = (ptDesired * market.totalLp) / market.totalPt;
             int256 netLpByScy = (scyDesired * market.totalLp) / market.totalScy;
-            if (netLpByOt < netLpByScy) {
-                lpToAccount = netLpByOt;
-                otUsed = otDesired;
+            if (netLpByPt < netLpByScy) {
+                lpToAccount = netLpByPt;
+                ptUsed = ptDesired;
                 scyUsed = (market.totalScy * lpToAccount) / market.totalLp;
             } else {
                 lpToAccount = netLpByScy;
                 scyUsed = scyDesired;
-                otUsed = (market.totalOt * lpToAccount) / market.totalLp;
+                ptUsed = (market.totalPt * lpToAccount) / market.totalLp;
             }
         }
 
@@ -102,7 +94,7 @@ library MarketMathCore {
         /// ------------------------------------------------------------
         if (updateState) {
             market.totalScy += scyUsed;
-            market.totalOt += otUsed;
+            market.totalPt += ptUsed;
             market.totalLp += lpToAccount + lpToReserve;
         }
     }
@@ -111,7 +103,7 @@ library MarketMathCore {
         MarketState memory market,
         int256 lpToRemove,
         bool updateState
-    ) internal pure returns (int256 scyToAccount, int256 netOtToAccount) {
+    ) internal pure returns (int256 scyToAccount, int256 netPtToAccount) {
         /// ------------------------------------------------------------
         /// CHECKS
         /// ------------------------------------------------------------
@@ -121,14 +113,14 @@ library MarketMathCore {
         /// MATH
         /// ------------------------------------------------------------
         scyToAccount = (lpToRemove * market.totalScy) / market.totalLp;
-        netOtToAccount = (lpToRemove * market.totalOt) / market.totalLp;
+        netPtToAccount = (lpToRemove * market.totalPt) / market.totalLp;
 
         /// ------------------------------------------------------------
         /// WRITE
         /// ------------------------------------------------------------
         if (updateState) {
             market.totalLp = market.totalLp.subNoNeg(lpToRemove);
-            market.totalOt = market.totalOt.subNoNeg(netOtToAccount);
+            market.totalPt = market.totalPt.subNoNeg(netPtToAccount);
             market.totalScy = market.totalScy.subNoNeg(scyToAccount);
         }
     }
@@ -136,7 +128,7 @@ library MarketMathCore {
     function executeTradeCore(
         MarketState memory market,
         SCYIndex index,
-        int256 netOtToAccount,
+        int256 netPtToAccount,
         uint256 blockTime,
         bool updateState
     ) internal pure returns (int256 netScyToAccount, int256 netScyToReserve) {
@@ -144,7 +136,7 @@ library MarketMathCore {
         /// CHECKS
         /// ------------------------------------------------------------
         require(blockTime < market.expiry, "market expired");
-        require(market.totalOt > netOtToAccount, "insufficient liquidity");
+        require(market.totalPt > netPtToAccount, "insufficient liquidity");
 
         /// ------------------------------------------------------------
         /// MATH
@@ -154,7 +146,7 @@ library MarketMathCore {
         (int256 netAssetToAccount, int256 netAssetToReserve) = calcTrade(
             market,
             comp,
-            netOtToAccount
+            netPtToAccount
         );
 
         netScyToAccount = index.assetToScy(netAssetToAccount);
@@ -168,7 +160,7 @@ library MarketMathCore {
                 market,
                 comp,
                 index,
-                netOtToAccount,
+                netPtToAccount,
                 netScyToAccount,
                 blockTime
             );
@@ -187,35 +179,35 @@ library MarketMathCore {
         res.rateScalar = _getRateScalar(market, timeToExpiry);
         res.totalAsset = index.scyToAsset(market.totalScy);
 
-        require(market.totalOt != 0 && res.totalAsset != 0, "invalid market state");
+        require(market.totalPt != 0 && res.totalAsset != 0, "invalid market state");
 
         res.rateAnchor = _getRateAnchor(
-            market.totalOt,
-            market.lastImpliedRate,
+            market.totalPt,
+            market.lastLnImpliedRate,
             res.totalAsset,
             res.rateScalar,
             timeToExpiry
         );
-        res.feeRate = _getExchangeRateFromImpliedRate(market.feeRateRoot, timeToExpiry);
+        res.lnFeeRate = _getExchangeRateFromImpliedRate(market.lnFeeRateRoot, timeToExpiry);
     }
 
     function calcTrade(
         MarketState memory market,
         MarketPreCompute memory comp,
-        int256 netOtToAccount
+        int256 netPtToAccount
     ) internal pure returns (int256 netAssetToAccount, int256 netAssetToReserve) {
         int256 preFeeExchangeRate = _getExchangeRate(
-            market.totalOt,
+            market.totalPt,
             comp.totalAsset,
             comp.rateScalar,
             comp.rateAnchor,
-            netOtToAccount
+            netPtToAccount
         );
 
-        int256 preFeeAssetToAccount = netOtToAccount.divDown(preFeeExchangeRate).neg();
-        int256 fee = comp.feeRate;
+        int256 preFeeAssetToAccount = netPtToAccount.divDown(preFeeExchangeRate).neg();
+        int256 fee = comp.lnFeeRate;
 
-        if (netOtToAccount > 0) {
+        if (netPtToAccount > 0) {
             int256 postFeeExchangeRate = preFeeExchangeRate.divDown(fee);
             require(postFeeExchangeRate >= Math.IONE, "exchange rate below 1");
             fee = preFeeAssetToAccount.mulDown(Math.IONE - fee);
@@ -233,7 +225,7 @@ library MarketMathCore {
         MarketState memory market,
         MarketPreCompute memory comp,
         SCYIndex index,
-        int256 netOtToAccount,
+        int256 netPtToAccount,
         int256 netScyToAccount,
         uint256 blockTime
     ) internal pure {
@@ -241,112 +233,92 @@ library MarketMathCore {
 
         market.lastTradeTime = blockTime;
 
-        market.totalOt = market.totalOt.subNoNeg(netOtToAccount);
+        market.totalPt = market.totalPt.subNoNeg(netPtToAccount);
         market.totalScy = market.totalScy.subNoNeg(netScyToAccount);
 
-        market.lastImpliedRate = _getImpliedRate(
-            market.totalOt,
+        market.lastLnImpliedRate = _getLnImpliedRate(
+            market.totalPt,
             index.scyToAsset(market.totalScy),
             comp.rateScalar,
             comp.rateAnchor,
             timeToExpiry
         );
-        require(market.lastImpliedRate != 0, "zero impliedRate");
+        require(market.lastLnImpliedRate != 0, "zero lnImpliedRate");
     }
 
     function _getRateAnchor(
-        int256 totalOt,
-        uint256 lastImpliedRate,
+        int256 totalPt,
+        uint256 lastLnImpliedRate,
         int256 totalAsset,
         int256 rateScalar,
         uint256 timeToExpiry
     ) internal pure returns (int256 rateAnchor) {
-        // This is the exchange rate at the new time to expiry
-        int256 newExchangeRate = _getExchangeRateFromImpliedRate(lastImpliedRate, timeToExpiry);
+        int256 newExchangeRate = _getExchangeRateFromImpliedRate(lastLnImpliedRate, timeToExpiry);
 
         require(newExchangeRate >= Math.IONE, "exchange rate below 1");
 
         {
-            // totalOt / (totalOt + totalAsset)
-            int256 proportion = totalOt.divDown(totalOt + totalAsset);
+            int256 proportion = totalPt.divDown(totalPt + totalAsset);
 
             int256 lnProportion = _logProportion(proportion);
 
-            // newExchangeRate - ln(proportion / (1 - proportion)) / rateScalar
             rateAnchor = newExchangeRate - lnProportion.divDown(rateScalar);
         }
     }
 
     /// @notice Calculates the current market implied rate.
-    /// @return impliedRate the implied rate
-    function _getImpliedRate(
-        int256 totalOt,
+    /// @return lnImpliedRate the implied rate
+    function _getLnImpliedRate(
+        int256 totalPt,
         int256 totalAsset,
         int256 rateScalar,
         int256 rateAnchor,
         uint256 timeToExpiry
-    ) internal pure returns (uint256 impliedRate) {
+    ) internal pure returns (uint256 lnImpliedRate) {
         // This will check for exchange rates < Math.IONE
-        int256 exchangeRate = _getExchangeRate(totalOt, totalAsset, rateScalar, rateAnchor, 0);
+        int256 exchangeRate = _getExchangeRate(totalPt, totalAsset, rateScalar, rateAnchor, 0);
 
         // exchangeRate >= 1 so its ln >= 0
         uint256 lnRate = exchangeRate.ln().Uint();
 
-        impliedRate = (lnRate * IMPLIED_RATE_TIME) / timeToExpiry;
+        lnImpliedRate = (lnRate * IMPLIED_RATE_TIME) / timeToExpiry;
     }
 
     /// @notice Converts an implied rate to an exchange rate given a time to expiry. The
     /// formula is E = e^rt
-    function _getExchangeRateFromImpliedRate(uint256 impliedRate, uint256 timeToExpiry)
+    function _getExchangeRateFromImpliedRate(uint256 lnImpliedRate, uint256 timeToExpiry)
         internal
         pure
         returns (int256 exchangeRate)
     {
-        uint256 rt = (impliedRate * timeToExpiry) / IMPLIED_RATE_TIME;
+        uint256 rt = (lnImpliedRate * timeToExpiry) / IMPLIED_RATE_TIME;
 
         exchangeRate = LogExpMath.exp(rt.Int());
     }
 
-    /// @notice Returns the exchange rate between OT and Asset for the given market
-    /// Calculates the following exchange rate:
-    ///     (1 / rateScalar) * ln(proportion / (1 - proportion)) + rateAnchor
-    /// where:
-    ///     proportion = totalOt / (totalOt + totalUnderlyingAsset)
     function _getExchangeRate(
-        int256 totalOt,
+        int256 totalPt,
         int256 totalAsset,
         int256 rateScalar,
         int256 rateAnchor,
-        int256 netOtToAccount
+        int256 netPtToAccount
     ) internal pure returns (int256 exchangeRate) {
-        int256 numerator = totalOt.subNoNeg(netOtToAccount);
-
-        // This is the proportion scaled by Math.IONE
-        // (totalOt - netOtToAccount) / (totalOt + totalAsset)
-        int256 proportion = (numerator.divDown(totalOt + totalAsset));
-
-        // This limit is here to prevent the market from reaching extremely high interest rates via an
-        // excessively large proportion (high amounts of OT relative to Asset).
-        // Market proportion can only increase via swapping OT to SCY (OT is added to the market and SCY is
-        // removed). Over time, the yield from SCY will slightly decrease the proportion (the
-        // amount of Asset in the market must be monotonically increasing). Therefore it is not
-        // possible for the proportion to go over max market proportion unless borrowing occurs.
+        int256 numerator = totalPt.subNoNeg(netPtToAccount);
+
+        int256 proportion = (numerator.divDown(totalPt + totalAsset));
+
         require(proportion <= MAX_MARKET_PROPORTION, "max proportion exceeded");
 
         int256 lnProportion = _logProportion(proportion);
 
-        // lnProportion / rateScalar + rateAnchor
         exchangeRate = lnProportion.divDown(rateScalar) + rateAnchor;
 
-        // Do not succeed if interest rates fall below 1
         require(exchangeRate >= Math.IONE, "exchange rate below 1");
     }
 
     function _logProportion(int256 proportion) internal pure returns (int256 res) {
-        // This will result in divide by zero, short circuit
         require(proportion != Math.IONE, "proportion must not be one");
 
-        // Convert proportion to what is used inside the logit function (p / (1-p))
         int256 logitP = proportion.divDown(Math.IONE - proportion);
 
         res = logitP.ln();
@@ -361,7 +333,7 @@ library MarketMathCore {
         require(rateScalar > 0, "rateScalar underflow");
     }
 
-    function setInitialImpliedRate(
+    function setInitialLnImpliedRate(
         MarketState memory market,
         SCYIndex index,
         int256 initialAnchor,
@@ -382,8 +354,8 @@ library MarketMathCore {
         /// ------------------------------------------------------------
         /// WRITE
         /// ------------------------------------------------------------
-        market.lastImpliedRate = _getImpliedRate(
-            market.totalOt,
+        market.lastLnImpliedRate = _getLnImpliedRate(
+            market.totalPt,
             totalAsset,
             rateScalar,
             initialAnchor,
@@ -391,22 +363,20 @@ library MarketMathCore {
         );
     }
 
-    function updateNewRateOracle(MarketState memory market, uint256 blockTime)
+    function getNewRateOracle(MarketState memory market, uint256 blockTime)
         internal
         pure
         returns (uint256)
     {
         // This can occur when using a view function get to a market state in the past
         if (market.lastTradeTime > blockTime) {
-            market.oracleRate = market.lastImpliedRate;
-            return market.oracleRate;
+            return market.lastLnImpliedRate;
         }
 
         uint256 timeDiff = blockTime - market.lastTradeTime;
         if (timeDiff > market.rateOracleTimeWindow) {
-            // If past the time window just return the market.lastImpliedRate
-            market.oracleRate = market.lastImpliedRate;
-            return market.oracleRate;
+            // If past the time window just return the market.lastLnImpliedRate
+            return market.lastLnImpliedRate;
         }
 
         // (currentTs - previousTs) / timeWindow
@@ -418,7 +388,6 @@ library MarketMathCore {
         uint256 newOracleRate = market.lastTradeTime.mulDown(lastTradeWeight) +
             market.oracleRate.mulDown(oracleWeight);
 
-        market.oracleRate = newOracleRate;
-        return market.oracleRate;
+        return newOracleRate;
     }
 }

package/contracts/libraries/math/Math.sol

@@ -22,8 +22,6 @@ library Math {
     uint256 internal constant ONE = 1e18; // 18 decimal places
     int256 internal constant IONE = 1e18; // 18 decimal places
 
-    uint256 internal constant MAX_POW_RELATIVE_ERROR = 10000; // 10^(-14)
-
     function subMax0(uint256 a, uint256 b) internal pure returns (uint256) {
         unchecked {
             return (a >= b ? a - b : 0);
@@ -65,6 +63,15 @@ library Math {
         }
     }
 
+    function rawDivUp(uint256 a, uint256 b) internal pure returns (uint256) {
+        if (a == 0) return 0;
+        else {
+            unchecked {
+                return (a + b - 1) / b;
+            }
+        }
+    }
+
     function abs(int256 x) internal pure returns (uint256) {
         return uint256(x > 0 ? x : -x);
     }
@@ -118,6 +125,11 @@ library Math {
         return uint112(x);
     }
 
+    function Uint96(uint256 x) internal pure returns (uint96) {
+        require(x < (1 << 96)); // unsigned, lim = bit
+        return uint96(x);
+    }
+
     function isAApproxB(
         uint256 a,
         uint256 b,

package/contracts/periphery/PendleGovernanceManager.sol

@@ -13,6 +13,7 @@ contract PendleGovernanceManager {
     }
 
     constructor(address _governance) {
+        require(_governance != address(0), "zero address");
         governance = _governance;
     }
 
@@ -28,9 +29,10 @@ contract PendleGovernanceManager {
 
     /**
      * @dev Allows the current governance to set the pendingGovernance address.
-     * @param _governance The address to transfer ownership to.
+     * @param newGovernance The address to transfer ownership to.
      */
-    function transferGovernance(address _governance) external onlyGovernance {
-        pendingGovernance = _governance;
+    function transferGovernance(address newGovernance) external onlyGovernance {
+        require(newGovernance != address(0), "zero address");
+        pendingGovernance = newGovernance;
     }
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "0.5.1-beta-4",
+  "version": "0.6.0",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",
@@ -36,7 +36,8 @@
   "scripts": {
     "compile": "yarn hardhat compile",
     "size": "yarn hardhat size-contracts",
-    "clean": "yarn hardhat clean"
+    "clean": "yarn hardhat clean",
+    "fcompile": "yarn clean && yarn compile"
   },
   "packageManager": "yarn@3.1.1",
   "dependencies": {

package/typechain-types/ActionCallback.ts

@@ -81,7 +81,7 @@ export interface ActionCallback extends BaseContract {
     marketFactory(overrides?: CallOverrides): Promise<[string]>;
 
     swapCallback(
-      otToAccount: BigNumberish,
+      ptToAccount: BigNumberish,
       scyToAccount: BigNumberish,
       data: BytesLike,
       overrides?: Overrides & { from?: string | Promise<string> }
@@ -91,7 +91,7 @@ export interface ActionCallback extends BaseContract {
   marketFactory(overrides?: CallOverrides): Promise<string>;
 
   swapCallback(
-    otToAccount: BigNumberish,
+    ptToAccount: BigNumberish,
     scyToAccount: BigNumberish,
     data: BytesLike,
     overrides?: Overrides & { from?: string | Promise<string> }
@@ -101,7 +101,7 @@ export interface ActionCallback extends BaseContract {
     marketFactory(overrides?: CallOverrides): Promise<string>;
 
     swapCallback(
-      otToAccount: BigNumberish,
+      ptToAccount: BigNumberish,
       scyToAccount: BigNumberish,
       data: BytesLike,
       overrides?: CallOverrides
@@ -114,7 +114,7 @@ export interface ActionCallback extends BaseContract {
     marketFactory(overrides?: CallOverrides): Promise<BigNumber>;
 
     swapCallback(
-      otToAccount: BigNumberish,
+      ptToAccount: BigNumberish,
       scyToAccount: BigNumberish,
       data: BytesLike,
       overrides?: Overrides & { from?: string | Promise<string> }
@@ -125,7 +125,7 @@ export interface ActionCallback extends BaseContract {
     marketFactory(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
     swapCallback(
-      otToAccount: BigNumberish,
+      ptToAccount: BigNumberish,
       scyToAccount: BigNumberish,
       data: BytesLike,
       overrides?: Overrides & { from?: string | Promise<string> }