@pendle/core-v2 0.9.4-beta → 0.10.2-testnet

package/contracts/libraries/OracleLib.sol

@@ -0,0 +1,214 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+/// Adapted from UniswapV3's Oracle
+
+library OracleLib {
+    struct Observation {
+        uint32 blockTimestamp;
+        uint216 lnImpliedRateCumulative;
+        bool initialized;
+        // 1 SLOT = 256 bits
+    }
+
+    function transform(
+        Observation memory last,
+        uint32 blockTimestamp,
+        uint96 lnImpliedRate
+    ) public pure returns (Observation memory) {
+        return
+            Observation({
+                blockTimestamp: blockTimestamp,
+                lnImpliedRateCumulative: last.lnImpliedRateCumulative +
+                    uint216(lnImpliedRate) *
+                    (blockTimestamp - last.blockTimestamp),
+                initialized: true
+            });
+    }
+
+    function initialize(Observation[65535] storage self, uint32 time)
+        public
+        returns (uint16 cardinality, uint16 cardinalityNext)
+    {
+        self[0] = Observation({
+            blockTimestamp: time,
+            lnImpliedRateCumulative: 0,
+            initialized: true
+        });
+        return (1, 1);
+    }
+
+    function write(
+        Observation[65535] storage self,
+        uint16 index,
+        uint32 blockTimestamp,
+        uint96 lnImpliedRate,
+        uint16 cardinality,
+        uint16 cardinalityNext
+    ) public returns (uint16 indexUpdated, uint16 cardinalityUpdated) {
+        Observation memory last = self[index];
+
+        // early return if we've already written an observation this block
+        if (last.blockTimestamp == blockTimestamp) return (index, cardinality);
+
+        // if the conditions are right, we can bump the cardinality
+        if (cardinalityNext > cardinality && index == (cardinality - 1)) {
+            cardinalityUpdated = cardinalityNext;
+        } else {
+            cardinalityUpdated = cardinality;
+        }
+
+        indexUpdated = (index + 1) % cardinalityUpdated;
+        self[indexUpdated] = transform(last, blockTimestamp, lnImpliedRate);
+    }
+
+    function grow(
+        Observation[65535] storage self,
+        uint16 current,
+        uint16 next
+    ) public returns (uint16) {
+        require(current != 0, "uninitialized");
+        // no-op if the passed next value isn't greater than the current next value
+        if (next <= current) return current;
+        // store in each slot to prevent fresh SSTOREs in swaps
+        // this data will not be used because the initialized boolean is still false
+        for (uint16 i = current; i != next; ) {
+            self[i].blockTimestamp = 1;
+            unchecked {
+                ++i;
+            }
+        }
+        return next;
+    }
+
+    function binarySearch(
+        Observation[65535] storage self,
+        uint32 target,
+        uint16 index,
+        uint16 cardinality
+    ) public view returns (Observation memory beforeOrAt, Observation memory atOrAfter) {
+        uint256 l = (index + 1) % cardinality; // oldest observation
+        uint256 r = l + cardinality - 1; // newest observation
+        uint256 i;
+        while (true) {
+            i = (l + r) / 2;
+
+            beforeOrAt = self[i % cardinality];
+
+            // we've landed on an uninitialized observation, keep searching higher (more recently)
+            if (!beforeOrAt.initialized) {
+                l = i + 1;
+                continue;
+            }
+
+            atOrAfter = self[(i + 1) % cardinality];
+
+            bool targetAtOrAfter = beforeOrAt.blockTimestamp <= target;
+
+            // check if we've found the answer!
+            if (targetAtOrAfter && target <= atOrAfter.blockTimestamp) break;
+
+            if (!targetAtOrAfter) r = i - 1;
+            else l = i + 1;
+        }
+    }
+
+    function getSurroundingObservations(
+        Observation[65535] storage self,
+        uint32 target,
+        uint96 lnImpliedRate,
+        uint16 index,
+        uint16 cardinality
+    ) public view returns (Observation memory beforeOrAt, Observation memory atOrAfter) {
+        // optimistically set before to the newest observation
+        beforeOrAt = self[index];
+
+        // if the target is chronologically at or after the newest observation, we can early return
+        if (beforeOrAt.blockTimestamp <= target) {
+            if (beforeOrAt.blockTimestamp == target) {
+                // if newest observation equals target, we're in the same block, so we can ignore atOrAfter
+                return (beforeOrAt, atOrAfter);
+            } else {
+                // otherwise, we need to transform
+                return (beforeOrAt, transform(beforeOrAt, target, lnImpliedRate));
+            }
+        }
+
+        // now, set beforeOrAt to the oldest observation
+        beforeOrAt = self[(index + 1) % cardinality];
+        if (!beforeOrAt.initialized) beforeOrAt = self[0];
+
+        // ensure that the target is chronologically at or after the oldest observation
+        require(beforeOrAt.blockTimestamp <= target, "target too old for observation");
+
+        // if we've reached this point, we have to binary search
+        return binarySearch(self, target, index, cardinality);
+    }
+
+    function observeSingle(
+        Observation[65535] storage self,
+        uint32 time,
+        uint32 secondsAgo,
+        uint96 lnImpliedRate,
+        uint16 index,
+        uint16 cardinality
+    ) public view returns (uint216 lnImpliedRateCumulative) {
+        if (secondsAgo == 0) {
+            Observation memory last = self[index];
+            if (last.blockTimestamp != time) {
+                return transform(last, time, lnImpliedRate).lnImpliedRateCumulative;
+            }
+            return last.lnImpliedRateCumulative;
+        }
+
+        uint32 target = time - secondsAgo;
+
+        (Observation memory beforeOrAt, Observation memory atOrAfter) = getSurroundingObservations(
+            self,
+            target,
+            lnImpliedRate,
+            index,
+            cardinality
+        );
+
+        if (target == beforeOrAt.blockTimestamp) {
+            // we're at the left boundary
+            return beforeOrAt.lnImpliedRateCumulative;
+        } else if (target == atOrAfter.blockTimestamp) {
+            // we're at the right boundary
+            return atOrAfter.lnImpliedRateCumulative;
+        } else {
+            // we're in the middle
+            return (beforeOrAt.lnImpliedRateCumulative +
+                uint216(
+                    (uint256(
+                        atOrAfter.lnImpliedRateCumulative - beforeOrAt.lnImpliedRateCumulative
+                    ) * (target - beforeOrAt.blockTimestamp)) /
+                        (atOrAfter.blockTimestamp - beforeOrAt.blockTimestamp)
+                ));
+        }
+    }
+
+    function observe(
+        Observation[65535] storage self,
+        uint32 time,
+        uint32[] memory secondsAgos,
+        uint96 lnImpliedRate,
+        uint16 index,
+        uint16 cardinality
+    ) public view returns (uint216[] memory lnImpliedRateCumulative) {
+        require(cardinality != 0, "cardinality must be positive");
+
+        lnImpliedRateCumulative = new uint216[](secondsAgos.length);
+        for (uint256 i = 0; i < lnImpliedRateCumulative.length; ++i) {
+            lnImpliedRateCumulative[i] = observeSingle(
+                self,
+                time,
+                secondsAgos[i],
+                lnImpliedRate,
+                index,
+                cardinality
+            );
+        }
+    }
+}

package/contracts/libraries/RewardManagerAbstract.sol

@@ -18,7 +18,7 @@ abstract contract RewardManagerAbstract is IRewardManager, TokenHelper {
         uint128 accrued;
     }
 
-    // [token] => [user] => (index,accured)
+    // [token] => [user] => (index,accrued)
     mapping(address => mapping(address => UserReward)) public userReward;
 
     function _updateAndDistributeRewards(address user) internal virtual {

package/contracts/libraries/math/MarketApproxLib.sol

@@ -3,7 +3,6 @@ pragma solidity 0.8.15;
 
 import "./Math.sol";
 import "./MarketMathCore.sol";
-import "./MarketMathCore.sol";
 
 struct ApproxParams {
     uint256 guessMin;
@@ -132,7 +131,7 @@ library MarketApproxLib {
     }
 
     struct VarsSwapExactScyForYt {
-        uint256 ptInGuess;
+        uint256 netPtInGuess;
         int256 assetToAccount;
         int256 assetToReserve;
         uint256 netAssetOut;
@@ -184,34 +183,37 @@ library MarketApproxLib {
         VarsSwapExactScyForYt memory vars;
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
 
+        vars.maxAssetIn = index.scyToAsset(maxScyIn);
+
         if (approx.guessMax == type(uint256).max) approx.guessMax = calcMaxPtIn(comp.totalAsset);
 
-        vars.maxAssetIn = index.scyToAsset(maxScyIn);
+        // at minimum we will flashswap maxAssetIn since we have enough SCY to payback the PT loan
+        if (approx.guessMin == 0) approx.guessMin = vars.maxAssetIn;
 
         for (uint256 iter = 0; iter < approx.maxIteration; ) {
             // ytOutGuess = ptInGuess
-            vars.ptInGuess = getCurrentGuess(iter, approx);
+            vars.netPtInGuess = getCurrentGuess(iter, approx);
 
             (vars.isSlopeNonNeg, vars.largestGoodSlope) = updateSlope(
                 comp,
                 market.totalPt,
-                vars.ptInGuess,
+                vars.netPtInGuess,
                 vars.largestGoodSlope
             );
             if (!vars.isSlopeNonNeg) {
-                approx.guessMax = vars.ptInGuess - 1;
+                approx.guessMax = vars.netPtInGuess - 1;
                 continue;
             }
 
             (vars.assetToAccount, vars.assetToReserve) = market.calcTrade(
                 comp,
-                vars.ptInGuess.neg()
+                vars.netPtInGuess.neg()
             );
             vars.netAssetOut = vars.assetToAccount.Uint();
-            vars.amountAssetNeedMore = vars.ptInGuess - vars.netAssetOut;
+            vars.amountAssetNeedMore = vars.netPtInGuess - vars.netAssetOut;
 
             if (vars.amountAssetNeedMore <= vars.maxAssetIn) {
-                approx.guessMin = vars.ptInGuess;
+                approx.guessMin = vars.netPtInGuess;
                 bool isAnswerAccepted = Math.isASmallerApproxB(
                     vars.amountAssetNeedMore,
                     vars.maxAssetIn,
@@ -219,12 +221,12 @@ library MarketApproxLib {
                 );
                 if (isAnswerAccepted)
                     return (
-                        vars.ptInGuess,
+                        vars.netPtInGuess,
                         index.assetToScy(vars.amountAssetNeedMore),
                         index.assetToScy(vars.assetToReserve.Uint())
                     );
             } else {
-                approx.guessMax = vars.ptInGuess - 1;
+                approx.guessMax = vars.netPtInGuess - 1;
             }
 
             unchecked {
@@ -368,7 +370,7 @@ library MarketApproxLib {
             approx.guessMax = calcMaxPtOut(market.totalPt, comp);
         }
 
-        vars.minAssetOut = index.scyToAsset(minScyOut);
+        vars.minAssetOut = index.scyToAssetUp(minScyOut);
 
         for (uint256 iter = 0; iter < approx.maxIteration; ) {
             // ytInGuess = ptOutGuess
@@ -405,16 +407,227 @@ library MarketApproxLib {
         revert("approx fail");
     }
 
+    struct VarsSwapPtToAddLiquidity {
+        uint256 netPtInGuess;
+        int256 assetToAccount;
+        int256 assetToReserve;
+        uint256 netAssetOut;
+        uint256 netPtRemaining;
+        uint256 newTotalPt;
+        uint256 newTotalAsset;
+        uint256 largestGoodSlope;
+        uint256 assetNumerator;
+        uint256 ptNumerator;
+        bool isSlopeNonNeg;
+    }
+
+    function approxSwapPtToAddLiquidity(
+        MarketState memory market,
+        PYIndex index,
+        uint256 netPtAdded,
+        uint256 blockTime,
+        ApproxParams memory approx
+    )
+        internal
+        pure
+        returns (
+            uint256, /*netPtIn*/
+            uint256, /*netScyOut*/
+            uint256 /*netScyToReserve*/
+        )
+    {
+        /*
+        The algorithm is essentially to:
+        1. Binary search netPtIn (therefore netScyOut)
+        2. Swap netPtIn for netScyOut
+        3. Use (netPtAdded - netPtIn) and netScyOut to mint LP
+        4. If (netPtAdded - netPtIn) / netScyOut ratio is close enough to the market's PT/SCY ratio
+        => answer found
+
+        Note that market maintains PT/SCY ratio, but here PT/asset is used instead
+        */
+
+        require(market.totalLp != 0, "no existing lp");
+
+        VarsSwapPtToAddLiquidity memory vars;
+        MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
+
+        if (approx.guessMax == type(uint256).max) {
+            // ensures that netPtIn is always valid and not greater than netPtAdded
+            approx.guessMax = Math.min(calcMaxPtIn(comp.totalAsset), netPtAdded);
+        }
+
+        require(isValidApproxParams(approx), "invalid approx");
+
+        for (uint256 iter = 0; iter < approx.maxIteration; ) {
+            vars.netPtInGuess = getCurrentGuess(iter, approx);
+
+            (vars.isSlopeNonNeg, vars.largestGoodSlope) = updateSlope(
+                comp,
+                market.totalPt,
+                vars.netPtInGuess,
+                vars.largestGoodSlope
+            );
+            if (!vars.isSlopeNonNeg) {
+                approx.guessMax = vars.netPtInGuess;
+                continue;
+            }
+
+            (vars.assetToAccount, vars.assetToReserve) = market.calcTrade(
+                comp,
+                vars.netPtInGuess.neg()
+            );
+
+            vars.netAssetOut = vars.assetToAccount.Uint();
+            vars.netPtRemaining = netPtAdded - vars.netPtInGuess;
+            vars.newTotalPt = market.totalPt.Uint() + vars.netPtInGuess;
+            vars.newTotalAsset = (comp.totalAsset - vars.assetToAccount - vars.assetToReserve)
+                .Uint();
+
+            // it is desired that
+            // netAssetOut / newTotalAsset = netPtRemaining / newTotalPt
+            // which is equivalent to
+            // netAssetOut * newTotalPt = netPtRemaining * newTotalAsset
+
+            vars.assetNumerator = vars.netAssetOut * vars.newTotalPt;
+            vars.ptNumerator = vars.netPtRemaining * vars.newTotalAsset;
+
+            if (Math.isAApproxB(vars.assetNumerator, vars.ptNumerator, approx.eps)) {
+                return (
+                    vars.netPtInGuess,
+                    index.assetToScy(vars.netAssetOut),
+                    index.assetToScy(vars.assetToReserve.Uint())
+                );
+            }
+
+            if (vars.assetNumerator <= vars.ptNumerator) {
+                // needs more asset --> swap more PT
+                approx.guessMin = vars.netPtInGuess + 1;
+            } else {
+                // needs less asset --> swap less PT
+                approx.guessMax = vars.netPtInGuess - 1;
+            }
+
+            unchecked {
+                ++iter;
+            }
+        }
+        revert("approx fail");
+    }
+
+    struct VarsSwapScyToAddLiquidity {
+        uint256 netAssetAdded;
+        uint256 ptOutGuess;
+        int256 assetToAccount;
+        int256 assetToReserve;
+        uint256 netAssetIn;
+        uint256 netAssetRemaining;
+        uint256 newTotalPt;
+        uint256 newTotalAsset;
+        uint256 ptNumerator;
+        uint256 assetNumerator;
+    }
+
+    function approxSwapScyToAddLiquidity(
+        MarketState memory market,
+        PYIndex index,
+        uint256 netScyAdded,
+        uint256 blockTime,
+        ApproxParams memory approx
+    )
+        internal
+        pure
+        returns (
+            uint256, /*netPtOut*/
+            uint256, /*netScyIn*/
+            uint256 /*netScyToReserve*/
+        )
+    {
+        /*
+        The algorithm is essentially to:
+        1. Binary search netPtOut (therefore netScyIn)
+        2. Swap netScyIn for netPtOut
+        3. Use netPtOut and (netScyAdded - netScyIn) to mint LP
+        4. If netPtOut / (netScyAdded - netScyIn) ratio is close enough to the market's PT/SCY ratio
+        => answer found
+
+        Note that market maintains PT/SCY ratio, but here PT/asset is used instead
+        */
+        require(market.totalLp != 0, "no existing lp");
+
+        VarsSwapScyToAddLiquidity memory vars;
+        MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
+        if (approx.guessMax == type(uint256).max) {
+            approx.guessMax = calcMaxPtOut(market.totalPt, comp);
+        }
+
+        require(isValidApproxParams(approx), "invalid approx");
+
+        vars.netAssetAdded = index.scyToAsset(netScyAdded);
+
+        for (uint256 iter = 0; iter < approx.maxIteration; ) {
+            vars.ptOutGuess = getCurrentGuess(iter, approx);
+            (vars.assetToAccount, vars.assetToReserve) = market.calcTrade(
+                comp,
+                vars.ptOutGuess.Int()
+            );
+
+            vars.netAssetIn = vars.assetToAccount.abs();
+
+            if (vars.netAssetIn > vars.netAssetAdded) {
+                approx.guessMax = vars.ptOutGuess - 1;
+                unchecked {
+                    ++iter;
+                }
+                continue;
+            }
+
+            vars.netAssetRemaining = vars.netAssetAdded - vars.netAssetIn;
+            vars.newTotalPt = market.totalPt.Uint() - vars.ptOutGuess;
+            vars.newTotalAsset = (comp.totalAsset - vars.assetToAccount - vars.assetToReserve)
+                .Uint();
+
+            // it is desired that
+            // ptOutGuess / newTotalPt = netAssetRemaining / newTotalAsset
+            // which is equivalent to
+            // ptOutGuess * newTotalAsset = netAssetRemaining * newTotalPt
+
+            vars.ptNumerator = vars.ptOutGuess * vars.newTotalAsset;
+            vars.assetNumerator = vars.netAssetRemaining * vars.newTotalPt;
+
+            if (Math.isAApproxB(vars.ptNumerator, vars.assetNumerator, approx.eps)) {
+                return (
+                    vars.ptOutGuess,
+                    index.assetToScy(vars.netAssetIn),
+                    index.assetToScy(vars.assetToReserve.Uint())
+                );
+            }
+
+            if (vars.ptNumerator <= vars.assetNumerator) {
+                // needs more PT
+                approx.guessMin = vars.ptOutGuess + 1;
+            } else {
+                // needs less PT
+                approx.guessMax = vars.ptOutGuess - 1;
+            }
+
+            unchecked {
+                ++iter;
+            }
+        }
+        revert("approx fail");
+    }
+
     function updateSlope(
         MarketPreCompute memory comp,
         int256 totalPt,
         uint256 ptInGuess,
         uint256 largestGoodSlope
-    ) internal pure returns (bool isSlopeNonNeg, uint256 newLargestGoodSlop) {
+    ) internal pure returns (bool isSlopeNonNeg, uint256 newLargestGoodSlope) {
         if (ptInGuess <= largestGoodSlope) {
             return (true, largestGoodSlope);
         }
-        // it's not guaranteed that the current slop is good
+        // it's not guaranteed that the current slope is good
         // we therefore have to recalculate the slope
         int256 slope = slopeFactor(totalPt, ptInGuess.neg(), comp);
         if (slope >= 0) return (true, ptInGuess);

package/contracts/libraries/math/MarketMathCore.sol

@@ -10,17 +10,14 @@ struct MarketState {
     int256 totalPt;
     int256 totalScy;
     int256 totalLp;
-    uint256 oracleRate;
     address treasury;
     /// immutable variables ///
     int256 scalarRoot;
     uint256 lnFeeRateRoot;
-    uint256 rateOracleTimeWindow;
     uint256 expiry;
     uint256 reserveFeePercent; // base 100
     /// last trade data ///
     uint256 lastLnImpliedRate;
-    uint256 lastTradeTime;
 }
 
 // params that are expensive to compute, therefore we pre-compute them
@@ -317,8 +314,6 @@ library MarketMathCore {
     ) internal pure {
         uint256 timeToExpiry = market.expiry - blockTime;
 
-        market.lastTradeTime = blockTime;
-
         market.totalPt = market.totalPt.subNoNeg(netPtToAccount);
         market.totalScy = market.totalScy.subNoNeg(netScyToAccount + netScyToReserve);
 
@@ -448,32 +443,4 @@ library MarketMathCore {
             timeToExpiry
         );
     }
-
-    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) {
-            return market.lastLnImpliedRate;
-        }
-
-        uint256 timeDiff = blockTime - market.lastTradeTime;
-        if (timeDiff > market.rateOracleTimeWindow) {
-            // If past the time window just return the market.lastLnImpliedRate
-            return market.lastLnImpliedRate;
-        }
-
-        // (currentTs - previousTs) / timeWindow
-        uint256 lastTradeWeight = timeDiff.divDown(market.rateOracleTimeWindow);
-
-        // 1 - (currentTs - previousTs) / timeWindow
-        uint256 oracleWeight = Math.ONE - lastTradeWeight;
-
-        uint256 newOracleRate = market.lastLnImpliedRate.mulDown(lastTradeWeight) +
-            market.oracleRate.mulDown(oracleWeight);
-
-        return newOracleRate;
-    }
 }