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

package/contracts/interfaces/IStETH.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+interface IStETH {
+    function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);
+
+    function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);
+
+    function submit(address referral) external payable returns (uint256 amount);
+
+    function burnShares(address _account, uint256 _sharesAmount)
+        external
+        returns (uint256 newTotalShares);
+}

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/interfaces/IWAvax.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+/*
+ * 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;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+interface IWAvax is IERC20 {
+    event Deposit(address indexed dst, uint256 wad);
+    event Withdrawal(address indexed src, uint256 wad);
+
+    function deposit() external payable;
+
+    function withdraw(uint256 wad) 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/PYIndex.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+import "../../interfaces/IPYieldToken.sol";
+import "../../interfaces/IPPrincipalToken.sol";
+import "../SCY/SCYUtils.sol";
+import "../math/Math.sol";
+
+type PYIndex is uint256;
+
+library PYIndexLib {
+    using Math for uint256;
+    using Math for int256;
+
+    function newIndex(IPYieldToken YT) internal returns (PYIndex) {
+        return PYIndex.wrap(YT.pyIndexCurrent());
+    }
+
+    function scyToAsset(PYIndex index, uint256 scyAmount)
+        internal
+        pure
+        returns (uint256)
+    {
+        return SCYUtils.scyToAsset(PYIndex.unwrap(index), scyAmount);
+    }
+
+    function assetToScy(PYIndex index, uint256 assetAmount)
+        internal
+        pure
+        returns (uint256)
+    {
+        return SCYUtils.assetToScy(PYIndex.unwrap(index), assetAmount);
+    }
+
+    function assetToScyUp(PYIndex index, uint256 assetAmount)
+        internal
+        pure
+        returns (uint256)
+    {
+        return SCYUtils.assetToScyUp(PYIndex.unwrap(index), assetAmount);
+    }
+
+    function scyToAssetUp(PYIndex index, uint256 scyAmount)
+        internal
+        pure
+        returns (uint256)
+    {
+        uint256 _index = PYIndex.unwrap(index);
+        return SCYUtils.scyToAssetUp(_index, scyAmount);
+    }
+
+    function scyToAsset(PYIndex index, int256 scyAmount)
+        internal
+        pure
+        returns (int256)
+    {
+        int256 sign = scyAmount < 0 ? int256(-1) : int256(1);
+        return sign * (SCYUtils.scyToAsset(PYIndex.unwrap(index), scyAmount.abs())).Int();
+    }
+
+    function assetToScy(PYIndex index, int256 assetAmount)
+        internal
+        pure
+        returns (int256)
+    {
+        int256 sign = assetAmount < 0 ? int256(-1) : int256(1);
+        return sign * (SCYUtils.assetToScy(PYIndex.unwrap(index), assetAmount.abs())).Int();
+    }
+
+}

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

@@ -33,7 +33,7 @@ library MarketApproxLib {
     using Math for uint256;
     using Math for int256;
     using LogExpMath for int256;
-    using SCYIndexLib for SCYIndex;
+    using PYIndexLib for PYIndex;
     using MarketMathCore for MarketState;
 
     struct VarsSwapPtForExactScy {
@@ -50,7 +50,7 @@ library MarketApproxLib {
 
     function approxSwapPtForExactScy(
         MarketState memory market,
-        SCYIndex index,
+        PYIndex index,
         uint256 minScyOut,
         uint256 blockTime,
         ApproxParams memory approx
@@ -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);
@@ -145,7 +145,7 @@ library MarketApproxLib {
     /// `guessMin` & `guessMax` is to guess the `netPtIn` == `netYtOut`
     function approxSwapExactScyForYt(
         MarketState memory market,
-        SCYIndex index,
+        PYIndex index,
         uint256 maxScyIn,
         uint256 blockTime,
         ApproxParams memory approx
@@ -155,7 +155,7 @@ library MarketApproxLib {
         returns (
             uint256, /*netYtOut*/
             uint256, /*netScyIn*/
-            uint256
+            uint256 /*netScyToReserve*/
         )
     {
         /*
@@ -244,7 +244,7 @@ library MarketApproxLib {
 
     function approxSwapExactScyForPt(
         MarketState memory market,
-        SCYIndex index,
+        PYIndex index,
         uint256 maxScyIn,
         uint256 blockTime,
         ApproxParams memory approx
@@ -254,7 +254,7 @@ library MarketApproxLib {
         returns (
             uint256, /*netPtOut*/
             uint256, /*netScyIn*/
-            uint256
+            uint256 /*netScyToReserve*/
         )
     {
         /*
@@ -326,7 +326,7 @@ library MarketApproxLib {
 
     function approxSwapYtForExactScy(
         MarketState memory market,
-        SCYIndex index,
+        PYIndex index,
         uint256 minScyOut,
         uint256 blockTime,
         ApproxParams memory approx
@@ -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;