@pendle/core-v2 0.8.0-beta-12 → 0.8.1-beta

package/contracts/core/YieldContracts/PendleYieldToken.sol

@@ -253,13 +253,6 @@ contract PendleYieldToken is
         return SCYUtils.scyToAsset(scyIndexCurrent(), amountScy);
     }
 
-    function _calcScyRedeemableFromPY(uint256 amountPY)
-        internal
-        returns (uint256 scyToUser, uint256 scyInterestPostExpiry)
-    {
-        return _calcScyRedeemableFromPY(amountPY, scyIndexCurrent());
-    }
-
     function _calcScyRedeemableFromPY(uint256 amountPY, uint256 indexCurrent)
         internal
         view

package/contracts/core/actions/ActionCallback.sol

@@ -104,7 +104,9 @@ contract ActionCallback is IPMarketSwapCallback, CallbackHelper {
         /// ------------------------------------------------------------
         /// mint & transfer
         /// ------------------------------------------------------------
-        SCY.safeTransferFrom(vars.payer, address(YT), netScyToPull);
+        if (netScyToPull > 0) {
+            SCY.safeTransferFrom(vars.payer, address(YT), netScyToPull);
+        }
 
         uint256 amountPYout = YT.mintPY(market, vars.receiver);
         require(amountPYout >= ptOwed, "insufficient pt to pay");

package/contracts/core/actions/base/ActionSCYAndYTBase.sol

@@ -118,6 +118,7 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, CallbackHelper {
             exactYtOut, // exactPtIn = exactYtOut
             _encodeSwapScyForExactYt(msg.sender, receiver, maxScyIn)
         );
+
         netScyIn = preScyBalance - SCY.balanceOf(msg.sender);
     }
 

package/contracts/core/actions/base/CallbackHelper.sol

@@ -76,6 +76,6 @@ abstract contract CallbackHelper {
     /// Misc functions
     /// ------------------------------------------------------------
     function _getActionType(bytes memory data) internal pure returns (ActionType actionType) {
-        (actionType, ) = abi.decode(data, (ActionType, address));
+        actionType = abi.decode(data, (ActionType));
     }
 }

package/contracts/interfaces/IPGaugeController.sol

@@ -23,6 +23,6 @@ interface IPGaugeController {
             uint128,
             uint128
         );
-    
+
 
 }

package/contracts/interfaces/IPRouterStatic.sol

@@ -108,17 +108,29 @@ interface IPRouterStatic {
     function swapExactPtForScyStatic(address market, uint256 exactPtIn)
         external
         view
-        returns (uint256 netScyOut, uint256 netScyFee);
+        returns (
+            uint256 netScyOut,
+            uint256 netScyFee,
+            uint256 priceImpact
+        );
 
     function swapScyForExactPtStatic(address market, uint256 exactPtOut)
         external
         view
-        returns (uint256 netScyIn, uint256 netScyFee);
+        returns (
+            uint256 netScyIn,
+            uint256 netScyFee,
+            uint256 priceImpact
+        );
 
     function swapExactScyForPtStatic(address market, uint256 exactScyIn)
         external
         view
-        returns (uint256 netPtOut, uint256 netScyFee);
+        returns (
+            uint256 netPtOut,
+            uint256 netScyFee,
+            uint256 priceImpact
+        );
 
     // ============= OTHER HELPERS =============
 

package/contracts/interfaces/IStargateLPStaking.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: MIT
+/*
+ * MIT License
+ * ===========
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ */
+pragma solidity 0.8.15;
+
+interface IStargateLPStaking {
+    struct PoolInfo {
+        address lpToken; // Address of LP token contract.
+        uint256 allocPoint; // How many allocation points assigned to this pool. STGs to distribute per block.
+        uint256 lastRewardBlock; // Last block number that STGs distribution occurs.
+        uint256 accStargatePerShare; // Accumulated STGs per share, times 1e12. See below.
+    }
+
+    struct UserInfo {
+        uint256 amount; // How many LP tokens the user has provided.
+        uint256 rewardDebt; // Reward debt. See explanation below.
+    }
+
+    function stargate() external view returns (address);
+
+    function deposit(uint256 _pid, uint256 _amount) external;
+
+    function withdraw(uint256 _pid, uint256 _amount) external;
+
+    function poolInfo(uint256 _pid) external view returns (PoolInfo memory);
+
+    function userInfo(uint256 _pid, address _user) external view returns (UserInfo memory);
+}

package/contracts/interfaces/IStargatePool.sol

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: MIT
+/*
+ * MIT License
+ * ===========
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ */
+pragma solidity 0.8.15;
+
+interface IStargatePool {
+    struct SwapObj {
+        uint256 amount;
+        uint256 eqFee;
+        uint256 eqReward;
+        uint256 lpFee;
+        uint256 protocolFee;
+        uint256 lkbRemove;
+    }
+
+    function swapRemote(
+        uint16 _srcChainId,
+        uint256 _srcPoolId,
+        address _to,
+        SwapObj memory _s
+    ) external returns (uint256 amountLD);
+
+    function poolId() external view returns (uint256);
+
+    function amountLPtoLD(uint256 _amountLP) external view returns (uint256);
+
+    function token() external view returns (address);
+
+    function totalLiquidity() external view returns (uint256);
+}

package/contracts/interfaces/IStargateRouter.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: MIT
+/*
+ * MIT License
+ * ===========
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ */
+pragma solidity 0.8.15;
+
+interface IStargateRouter {
+    function addLiquidity(
+        uint256 _poolId,
+        uint256 _amountLD,
+        address _to
+    ) external;
+
+    function instantRedeemLocal(
+        uint16 _srcPoolId,
+        uint256 _amountLP,
+        address _to
+    ) external returns (uint256 amountSD);
+}

package/contracts/interfaces/ISuperComposableYield.sol

@@ -136,16 +136,13 @@ interface ISuperComposableYield is IERC20Metadata {
      */
     function yieldToken() external view returns (address);
 
-    /**
-     * @notice returns a list of all the base tokens that can be deposited to mint shares
-     */
-    function getBaseTokens() external view returns (address[] memory res);
+    function getTokensIn() external view returns (address[] memory res);
 
-    /**
-     * @notice checks whether a token is a valid base token
-     * @notice returns a boolean indicating whether this is a valid token
-     */
-    function isValidBaseToken(address token) external view returns (bool);
+    function getTokensOut() external view returns (address[] memory res);
+
+    function isValidTokenIn(address token) external view returns (bool);
+
+    function isValidTokenOut(address token) external view returns (bool);
 
     function previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
         external

package/contracts/libraries/RewardManager.sol

@@ -5,9 +5,8 @@ import "./RewardManagerAbstract.sol";
 import "./math/Math.sol";
 import "../libraries/helpers/ArrayLib.sol";
 
-/// * This RewardManager can be used with any contracts, regardless of what tokens that contract stores
-/// since the RewardManager will maintain its own internal balance
-/// * Use with SCY + PendleMarket. For YT, it has its own native implementation for gas saving
+/// NOTE: This RewardManager is used with PendleMarket & SCY. For YT, it will use RewardManagerAbstract
+/// NOTE: RewardManager must not have duplicated rewardTokens
 abstract contract RewardManager is RewardManagerAbstract {
     using Math for uint256;
     using ArrayLib for uint256[];

package/contracts/libraries/RewardManagerAbstract.sol

@@ -4,6 +4,7 @@ import "../interfaces/IRewardManager.sol";
 import "./helpers/TokenHelper.sol";
 import "./math/Math.sol";
 
+/// NOTE: RewardManager must not have duplicated rewardTokens
 abstract contract RewardManagerAbstract is IRewardManager, TokenHelper {
     using Math for uint256;
 

package/contracts/libraries/VeBalanceLib.sol

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.15;
 
+import "./math/Math.sol";
+
 struct VeBalance {
     uint128 bias;
     uint128 slope;
@@ -12,7 +14,9 @@ struct LockedPosition {
 }
 
 library VeBalanceLib {
+    using Math for uint256;
     uint128 internal constant MAX_LOCK_TIME = 104 weeks;
+    uint256 internal constant USER_VOTE_MAX_WEIGHT = 10**18;
 
     function add(VeBalance memory a, VeBalance memory b)
         internal
@@ -68,6 +72,15 @@ library VeBalanceLib {
         res.bias = res.slope * position.expiry;
     }
 
+    function convertToVeBalance(LockedPosition memory position, uint256 weight)
+        internal
+        pure
+        returns (VeBalance memory res)
+    {
+        res.slope = ((position.amount * weight) / MAX_LOCK_TIME / USER_VOTE_MAX_WEIGHT).Uint128();
+        res.bias = res.slope * position.expiry;
+    }
+
     function convertToVeBalance(uint128 amount, uint128 expiry)
         internal
         pure

package/contracts/libraries/helpers/ArrayLib.sol

@@ -2,23 +2,6 @@
 pragma solidity >=0.8.0;
 
 library ArrayLib {
-    function padZeroRight(uint256[] memory input, uint256 length)
-        internal
-        pure
-        returns (uint256[] memory)
-    {
-        uint256[] memory output = new uint256[](length);
-        uint256 inputLength = input.length;
-        for (uint8 i = 0; i < length; ) {
-            if (i < inputLength) output[i] = input[i];
-            else output[i] = 0;
-            unchecked {
-                i++;
-            }
-        }
-        return output;
-    }
-
     function sum(uint256[] memory input) internal pure returns (uint256) {
         uint256 value = 0;
         for (uint256 i = 0; i < input.length; ) {

package/contracts/libraries/helpers/TokenHelper.sol

@@ -12,8 +12,10 @@ abstract contract TokenHelper {
         address from,
         uint256 amount
     ) internal {
-        if (amount == 0 || token == NATIVE) return;
-        IERC20(token).safeTransferFrom(from, address(this), amount);
+        if (token == NATIVE) require(msg.value == amount, "eth mismatch");
+        else if (amount != 0) {
+            IERC20(token).safeTransferFrom(from, address(this), amount);
+        }
     }
 
     function _transferOut(

package/contracts/libraries/math/LogExpMath.sol

@@ -248,54 +248,56 @@ library LogExpMath {
      * Reverts if ln(x) * y is smaller than `MIN_NATURAL_EXPONENT`, or larger than `MAX_NATURAL_EXPONENT`.
      */
     function pow(uint256 x, uint256 y) internal pure returns (uint256) {
-        if (y == 0) {
-            // We solve the 0^0 indetermination by making it equal one.
-            return uint256(ONE_18);
-        }
+        unchecked {
+            if (y == 0) {
+                // We solve the 0^0 indetermination by making it equal one.
+                return uint256(ONE_18);
+            }
 
-        if (x == 0) {
-            return 0;
-        }
+            if (x == 0) {
+                return 0;
+            }
 
-        // Instead of computing x^y directly, we instead rely on the properties of logarithms and exponentiation to
-        // arrive at that r`esult. In particular, exp(ln(x)) = x, and ln(x^y) = y * ln(x). This means
-        // x^y = exp(y * ln(x)).
-
-        // The ln function takes a signed value, so we need to make sure x fits in the signed 256 bit range.
-        require(x < 2**255, "x out of bounds");
-        int256 x_int256 = int256(x);
-
-        // We will compute y * ln(x) in a single step. Depending on the value of x, we can either use ln or ln_36. In
-        // both cases, we leave the division by ONE_18 (due to fixed point multiplication) to the end.
-
-        // This prevents y * ln(x) from overflowing, and at the same time guarantees y fits in the signed 256 bit range.
-        require(y < MILD_EXPONENT_BOUND, "y out of bounds");
-        int256 y_int256 = int256(y);
-
-        int256 logx_times_y;
-        if (LN_36_LOWER_BOUND < x_int256 && x_int256 < LN_36_UPPER_BOUND) {
-            int256 ln_36_x = _ln_36(x_int256);
-
-            // ln_36_x has 36 decimal places, so multiplying by y_int256 isn't as straightforward, since we can't just
-            // bring y_int256 to 36 decimal places, as it might overflow. Instead, we perform two 18 decimal
-            // multiplications and add the results: one with the first 18 decimals of ln_36_x, and one with the
-            // (downscaled) last 18 decimals.
-            logx_times_y = ((ln_36_x / ONE_18) *
-                y_int256 +
-                ((ln_36_x % ONE_18) * y_int256) /
-                ONE_18);
-        } else {
-            logx_times_y = _ln(x_int256) * y_int256;
-        }
-        logx_times_y /= ONE_18;
+            // Instead of computing x^y directly, we instead rely on the properties of logarithms and exponentiation to
+            // arrive at that r`esult. In particular, exp(ln(x)) = x, and ln(x^y) = y * ln(x). This means
+            // x^y = exp(y * ln(x)).
+
+            // The ln function takes a signed value, so we need to make sure x fits in the signed 256 bit range.
+            require(x < 2**255, "x out of bounds");
+            int256 x_int256 = int256(x);
+
+            // We will compute y * ln(x) in a single step. Depending on the value of x, we can either use ln or ln_36. In
+            // both cases, we leave the division by ONE_18 (due to fixed point multiplication) to the end.
+
+            // This prevents y * ln(x) from overflowing, and at the same time guarantees y fits in the signed 256 bit range.
+            require(y < MILD_EXPONENT_BOUND, "y out of bounds");
+            int256 y_int256 = int256(y);
+
+            int256 logx_times_y;
+            if (LN_36_LOWER_BOUND < x_int256 && x_int256 < LN_36_UPPER_BOUND) {
+                int256 ln_36_x = _ln_36(x_int256);
+
+                // ln_36_x has 36 decimal places, so multiplying by y_int256 isn't as straightforward, since we can't just
+                // bring y_int256 to 36 decimal places, as it might overflow. Instead, we perform two 18 decimal
+                // multiplications and add the results: one with the first 18 decimals of ln_36_x, and one with the
+                // (downscaled) last 18 decimals.
+                logx_times_y = ((ln_36_x / ONE_18) *
+                    y_int256 +
+                    ((ln_36_x % ONE_18) * y_int256) /
+                    ONE_18);
+            } else {
+                logx_times_y = _ln(x_int256) * y_int256;
+            }
+            logx_times_y /= ONE_18;
 
-        // Finally, we compute exp(y * ln(x)) to arrive at x^y
-        require(
-            MIN_NATURAL_EXPONENT <= logx_times_y && logx_times_y <= MAX_NATURAL_EXPONENT,
-            "product out of bounds"
-        );
+            // Finally, we compute exp(y * ln(x)) to arrive at x^y
+            require(
+                MIN_NATURAL_EXPONENT <= logx_times_y && logx_times_y <= MAX_NATURAL_EXPONENT,
+                "product out of bounds"
+            );
 
-        return uint256(exp(logx_times_y));
+            return uint256(exp(logx_times_y));
+        }
     }
 
     /**

package/contracts/libraries/math/MarketApproxLib.sol

@@ -85,7 +85,7 @@ library MarketApproxLib {
 
         if (approx.guessMax == type(uint256).max) approx.guessMax = calcMaxPtIn(comp.totalAsset);
 
-        vars.minAssetOut = index.scyToAsset(minScyOut);
+        vars.minAssetOut = index.scyToAssetUp(minScyOut);
 
         for (uint256 iter = 0; iter < approx.maxIteration; ) {
             vars.netPtInGuess = getCurrentGuess(iter, approx);
@@ -155,7 +155,7 @@ library MarketApproxLib {
         returns (
             uint256, /*netYtOut*/
             uint256, /*netScyIn*/
-            uint256
+            uint256 /*netScyToReserve*/
         )
     {
         /*
@@ -254,7 +254,7 @@ library MarketApproxLib {
         returns (
             uint256, /*netPtOut*/
             uint256, /*netScyIn*/
-            uint256
+            uint256 /*netScyToReserve*/
         )
     {
         /*
@@ -336,7 +336,7 @@ library MarketApproxLib {
         returns (
             uint256, /*netYtIn*/
             uint256, /*netScyOut*/
-            uint256
+            uint256 /*netScyToReserve*/
         )
     {
         /*
@@ -448,9 +448,7 @@ library MarketApproxLib {
         pure
         returns (uint256)
     {
-        int256 logitP = (Math.IONE.mulDown(comp.feeRate) - comp.rateAnchor)
-            .mulDown(comp.rateScalar)
-            .exp();
+        int256 logitP = (comp.feeRate - comp.rateAnchor).mulDown(comp.rateScalar).exp();
         int256 proportion = logitP.divDown(logitP + Math.IONE);
         int256 numerator = proportion.mulDown(totalPt + comp.totalAsset);
         int256 maxPtOut = totalPt - numerator;

package/contracts/libraries/math/MarketMathCore.sol

@@ -159,7 +159,9 @@ library MarketMathCore {
         /// MATH
         /// ------------------------------------------------------------
         if (market.totalLp == 0) {
-            lpToAccount = index.scyToAsset(scyDesired).subNoNeg(MINIMUM_LIQUIDITY);
+            lpToAccount =
+                Math.sqrt((index.scyToAsset(scyDesired) * ptDesired).Uint()).Int() -
+                MINIMUM_LIQUIDITY;
             lpToReserve = MINIMUM_LIQUIDITY;
             scyUsed = scyDesired;
             ptUsed = ptDesired;
@@ -241,7 +243,15 @@ library MarketMathCore {
         /// ------------------------------------------------------------
         /// WRITE
         /// ------------------------------------------------------------
-        _setNewMarketStateTrade(market, comp, index, netPtToAccount, netScyToAccount, blockTime);
+        _setNewMarketStateTrade(
+            market,
+            comp,
+            index,
+            netPtToAccount,
+            netScyToAccount,
+            netScyToReserve,
+            blockTime
+        );
     }
 
     function getMarketPreCompute(
@@ -294,8 +304,6 @@ library MarketMathCore {
 
         netAssetToReserve = (fee * market.reserveFeePercent.Int()) / PERCENTAGE_DECIMALS;
         netAssetToAccount = preFeeAssetToAccount - fee;
-        // netAssetToMarket = (preFeeAssetToAccount - fee + netAssetToReserve)
-        //     .neg();
     }
 
     function _setNewMarketStateTrade(
@@ -304,6 +312,7 @@ library MarketMathCore {
         SCYIndex index,
         int256 netPtToAccount,
         int256 netScyToAccount,
+        int256 netScyToReserve,
         uint256 blockTime
     ) internal pure {
         uint256 timeToExpiry = market.expiry - blockTime;
@@ -311,7 +320,7 @@ library MarketMathCore {
         market.lastTradeTime = blockTime;
 
         market.totalPt = market.totalPt.subNoNeg(netPtToAccount);
-        market.totalScy = market.totalScy.subNoNeg(netScyToAccount);
+        market.totalScy = market.totalScy.subNoNeg(netScyToAccount + netScyToReserve);
 
         market.lastLnImpliedRate = _getLnImpliedRate(
             market.totalPt,

package/contracts/libraries/math/Math.sol

@@ -59,6 +59,20 @@ library Math {
         }
     }
 
+    // @author Uniswap
+    function sqrt(uint256 y) internal pure returns (uint256 z) {
+        if (y > 3) {
+            z = y;
+            uint256 x = y / 2 + 1;
+            while (x < z) {
+                z = x;
+                x = (y / x + x) / 2;
+            }
+        } else if (y != 0) {
+            z = 1;
+        }
+    }
+
     function abs(int256 x) internal pure returns (uint256) {
         return uint256(x > 0 ? x : -x);
     }