@pendle/core-v2 0.6.9 → 0.7.1-beta

package/contracts/interfaces/IQiToken.sol

@@ -21,9 +21,30 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  */
 
-pragma solidity 0.8.9;
+pragma solidity 0.8.15;
 import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "./IBenQiInterestRateModel.sol";
 
 interface IQiToken is IERC20 {
     function exchangeRateCurrent() external returns (uint256);
+
+    function exchangeRateStored() external view returns (uint256);
+
+    function comptroller() external view returns (address);
+
+    function accrualBlockTimestamp() external view returns (uint256);
+
+    function getCash() external view returns (uint256);
+
+    function totalBorrows() external view returns (uint256);
+
+    function totalReserves() external view returns (uint256);
+
+    function borrowIndex() external view returns (uint256);
+
+    function interestRateModel() external view returns (IBenQiInterestRateModel);
+
+    function totalSupply() external view returns (uint256);
+
+    function reserveFactorMantissa() external view returns (uint256);
 }

package/contracts/interfaces/IREDACTEDStaking.sol

@@ -20,7 +20,7 @@
  * 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.9;
+pragma solidity 0.8.15;
 
 interface IREDACTEDStaking {
     function stake(uint256 _amount, address _receiver) external returns (bool);

package/contracts/interfaces/IRewardManager.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+interface IRewardManager {
+    function userReward(address token, address user)
+        external
+        view
+        returns (uint128 index, uint128 accured);
+}

package/contracts/interfaces/ISuperComposableYield.sol

@@ -0,0 +1,182 @@
+// 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/extensions/IERC20Metadata.sol";
+
+interface ISuperComposableYield is IERC20Metadata {
+    /// @dev Emitted when any base tokens is deposited to mint shares
+    event Deposit(
+        address indexed caller,
+        address indexed receiver,
+        address indexed tokenIn,
+        uint256 amountDeposited,
+        uint256 amountScyOut
+    );
+
+    /// @dev Emitted when any shares are redeemed for base tokens
+    event Redeem(
+        address indexed caller,
+        address indexed receiver,
+        address indexed tokenOut,
+        uint256 amountScyToRedeem,
+        uint256 amountTokenOut
+    );
+
+    /// @dev check assetInfo for more information
+    enum AssetType {
+        TOKEN,
+        LIQUIDITY
+    }
+
+    /// @dev Emitted when (`user`) claims their rewards
+    event ClaimRewards(address indexed user, address[] rewardTokens, uint256[] rewardAmounts);
+
+    /**
+     * @notice mints an amount of shares by depositing a base token.
+     * @param receiver shares recipient address
+     * @param tokenIn address of the base tokens to mint shares
+     * @param amountTokenToPull amount of base tokens to be transferred from (`msg.sender`)
+     * @param minSharesOut reverts if amount of shares minted is lower than this
+     * @return amountSharesOut amount of shares minted
+     * @dev
+     *
+     * This contract receives base tokens using these two (possibly both) methods:
+     * - The tokens have been transferred directly to this contract prior to calling deposit().
+     * - Exactly `amountTokenToPull` are transferred to this contract using `transferFrom()` upon calling deposit().
+     *
+     * The amount of shares minted will be based on the combined amount of base tokens deposited
+     * using the given two methods.
+     *
+     * Emits a {Deposit} event
+     *
+     * Requirements:
+     * - (`baseTokenIn`) must be a valid base token.
+     * - There must be an ongoing approval from (`msg.sender`) for this contract with
+     * at least `amountTokenToPull` base tokens.
+     */
+    function deposit(
+        address receiver,
+        address tokenIn,
+        uint256 amountTokenToPull,
+        uint256 minSharesOut
+    ) external payable returns (uint256 amountSharesOut);
+
+    /**
+     * @notice redeems an amount of base tokens by burning some shares
+     * @param receiver recipient address
+     * @param amountSharesToPull amount of shares to be transferred from (`msg.sender`)
+     * @param tokenOut address of the base token to be redeemed
+     * @param minTokenOut reverts if amount of base token redeemed is lower than this
+     * @return amountTokenOut amount of base tokens redeemed
+     * @dev
+     *
+     * This contract receives shares using these two (possibly both) methods:
+     * - The shares have been transferred directly to this contract prior to calling redeem().
+     * - Exactly `amountSharesToPull` are transferred to this contract using `transferFrom()` upon calling redeem().
+     *
+     * The amount of base tokens redeemed based on the combined amount of shares deposited
+     * using the given two methods
+     *
+     * Emits a {Redeem} event
+     *
+     * Requirements:
+     * - (`tokenOut`) must be a valid base token.
+     * - There must be an ongoing approval from (`msg.sender`) for this contract with
+     * at least `amountSharesToPull` shares.
+     */
+    function redeem(
+        address receiver,
+        uint256 amountSharesToPull,
+        address tokenOut,
+        uint256 minTokenOut
+    ) external returns (uint256 amountTokenOut);
+
+    /**
+     * @notice exchangeRate * scyBalance / 1e18 must return the asset balance of the account
+     * @notice vice-versa, if a user uses some amount of tokens equivalent to X asset, the amount of scy
+     he can mint must be X * exchangeRate / 1e18
+     * @dev SCYUtils's assetToScy & scyToAsset should be used instead of raw multiplication
+     & division
+     */
+    function exchangeRate() external view returns (uint256 res);
+
+    /**
+     * @notice claims reward for (`user`)
+     * @param user the user receiving their rewards
+     * @return rewardAmounts an array of reward amounts in the same order as `getRewardTokens`
+     * @dev
+     * Emits a `ClaimRewardss` event
+     * See {getRewardTokens} for list of reward tokens
+     */
+    function claimRewards(address user) external returns (uint256[] memory rewardAmounts);
+
+    /**
+     * @notice get the amount of unclaimed rewards for (`user`)
+     * @param user the user to check for
+     * @return rewardAmounts an array of reward amounts in the same order as `getRewardTokens`
+     */
+    function accruedRewards(address user) external view returns (uint256[] memory rewardAmounts);
+
+    function rewardIndexesCurrent() external returns (uint256[] memory indexes);
+
+    function rewardIndexesStored() external view returns (uint256[] memory indexes);
+
+    /**
+     * @notice returns the list of reward token addresses
+     */
+    function getRewardTokens() external view returns (address[] memory);
+
+    /**
+     * @notice returns the address of the underlying yield token
+     */
+    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);
+
+    /**
+     * @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);
+
+    /**
+    * @notice This function contains information to interpret what the asset is
+    * @notice decimals is the decimals to format asset balances
+    * @notice if asset is an ERC20 token, assetType = 0, assetAddress is the address of the token
+    * @notice if asset is liquidity of an AMM (like sqrt(k) in UniswapV2 forks), assetType = 1,
+    assetAddress is the address of the LP token
+    * @notice assetDecimals is the decimals of the asset
+    */
+    function assetInfo()
+        external
+        view
+        returns (
+            AssetType assetType,
+            address assetAddress,
+            uint8 assetDecimals
+        );
+}

package/contracts/interfaces/IWETH.sol

@@ -20,7 +20,7 @@
  * 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.9;
+pragma solidity 0.8.15;
 
 import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 

package/contracts/interfaces/IWXBTRFLY.sol

@@ -20,7 +20,7 @@
  * 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.9;
+pragma solidity 0.8.15;
 
 interface IWXBTRFLY {
     function wrapFromBTRFLY(uint256 _amount) external returns (uint256);
@@ -31,6 +31,8 @@ interface IWXBTRFLY {
 
     function unwrapToxBTRFLY(uint256 _amount) external returns (uint256);
 
+    function BTRFLY() external view returns (address);
+
     function xBTRFLY() external view returns (address);
 
     function xBTRFLYValue(uint256 _amount) external view returns (uint256);

package/contracts/interfaces/IWstETH.sol

@@ -1,10 +1,12 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
+pragma solidity 0.8.15;
 
 interface IWstETH {
     function wrap(uint256 _stETHAmount) external returns (uint256);
 
     function unwrap(uint256 _wstETHAmount) external returns (uint256);
 
+    function stETH() external view returns (address);
+
     function stEthPerToken() external view returns (uint256);
 }

package/contracts/interfaces/IYearnVault.sol

@@ -21,7 +21,7 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  */
 
-pragma solidity 0.8.9;
+pragma solidity 0.8.15;
 
 interface IYearnVault {
     function deposit(uint256 amount) external returns (uint256);
@@ -29,4 +29,6 @@ interface IYearnVault {
     function withdraw(uint256 maxShares) external returns (uint256);
 
     function pricePerShare() external view returns (uint256);
+
+    function token() external view returns (address);
 }

package/contracts/libraries/RewardManager.sol

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+import "../interfaces/IRewardManager.sol";
+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
+abstract contract RewardManager is RewardManagerAbstract {
+    using Math for uint256;
+    using ArrayLib for uint256[];
+
+    uint256 public lastRewardBlock;
+
+    mapping(address => RewardState) public rewardState;
+
+    uint256 internal constant INITIAL_REWARD_INDEX = 1;
+
+    function _updateRewardIndex()
+        internal
+        virtual
+        override
+        returns (address[] memory tokens, uint256[] memory indexes)
+    {
+        tokens = _getRewardTokens();
+        indexes = new uint256[](tokens.length);
+
+        if (tokens.length == 0) return (tokens, indexes);
+
+        if (lastRewardBlock != block.number) {
+            // if we have not yet update the index for this block
+            lastRewardBlock = block.number;
+
+            uint256 totalShares = _rewardSharesTotal();
+
+            uint256[] memory preBalances = _selfBalances(tokens);
+
+            _redeemExternalReward();
+
+            uint256[] memory accrued = _selfBalances(tokens).sub(preBalances);
+
+            for (uint256 i = 0; i < tokens.length; ++i) {
+                address token = tokens[i];
+                uint256 index = rewardState[token].index;
+
+                if (index == 0) index = INITIAL_REWARD_INDEX;
+                if (totalShares != 0) index += accrued[i].divDown(totalShares);
+
+                rewardState[token].index = index.Uint128();
+                rewardState[token].lastBalance += accrued[i].Uint128();
+            }
+        }
+
+        for (uint256 i = 0; i < tokens.length; i++) indexes[i] = rewardState[tokens[i]].index;
+    }
+
+    /// @dev this function doesn't need redeemExternal since redeemExternal is bundled in updateRewardIndex
+    /// @dev this function also has to update rewardState.lastBalance
+    function _doTransferOutRewards(address user, address receiver)
+        internal
+        virtual
+        override
+        returns (uint256[] memory rewardAmounts)
+    {
+        address[] memory tokens = _getRewardTokens();
+        rewardAmounts = new uint256[](tokens.length);
+        for (uint256 i = 0; i < tokens.length; i++) {
+            rewardAmounts[i] = userReward[tokens[i]][user].accrued;
+            if (rewardAmounts[i] != 0) {
+                userReward[tokens[i]][user].accrued = 0;
+                rewardState[tokens[i]].lastBalance -= rewardAmounts[i].Uint128();
+                _transferOut(tokens[i], receiver, rewardAmounts[i]);
+            }
+        }
+    }
+}

package/contracts/libraries/RewardManagerAbstract.sol

@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+import "../interfaces/IRewardManager.sol";
+import "./helpers/TokenHelper.sol";
+import "./math/Math.sol";
+
+abstract contract RewardManagerAbstract is IRewardManager, TokenHelper {
+    using Math for uint256;
+
+    struct RewardState {
+        uint128 index;
+        uint128 lastBalance;
+    }
+
+    struct UserReward {
+        uint128 index;
+        uint128 accrued;
+    }
+
+    // [token] => [user] => (index,accured)
+    mapping(address => mapping(address => UserReward)) public userReward;
+
+    function _updateAndDistributeRewards(address user) internal virtual {
+        _updateAndDistributeRewardsForTwo(user, address(0));
+    }
+
+    function _updateAndDistributeRewardsForTwo(address user1, address user2) internal virtual {
+        (address[] memory tokens, uint256[] memory indexes) = _updateRewardIndex();
+        if (tokens.length == 0) return;
+
+        if (user1 != address(0) && user1 != address(this))
+            _distributeRewards(user1, tokens, indexes);
+        if (user2 != address(0) && user2 != address(this))
+            _distributeRewards(user2, tokens, indexes);
+    }
+
+    /// @dev private function
+    function _distributeRewards(
+        address user,
+        address[] memory tokens,
+        uint256[] memory indexes
+    ) private {
+        uint256 userShares = _rewardSharesUser(user);
+
+        for (uint256 i = 0; i < tokens.length; ++i) {
+            address token = tokens[i];
+            uint256 index = indexes[i];
+            uint256 userIndex = userReward[token][user].index;
+
+            if (userIndex == 0) {
+                userReward[token][user].index = index.Uint128();
+                continue;
+            }
+
+            if (userIndex == index) continue;
+
+            uint256 deltaIndex = index - userIndex;
+            uint256 rewardDelta = userShares.mulDown(deltaIndex);
+            uint256 rewardAccrued = userReward[token][user].accrued + rewardDelta;
+
+            userReward[token][user] = UserReward({
+                index: index.Uint128(),
+                accrued: rewardAccrued.Uint128()
+            });
+        }
+    }
+
+    function _updateRewardIndex()
+        internal
+        virtual
+        returns (address[] memory tokens, uint256[] memory indexes);
+
+    function _redeemExternalReward() internal virtual;
+
+    function _doTransferOutRewards(address user, address receiver)
+        internal
+        virtual
+        returns (uint256[] memory rewardAmounts);
+
+    function _getRewardTokens() internal view virtual returns (address[] memory);
+
+    function _rewardSharesUser(address user) internal view virtual returns (uint256);
+
+    function _rewardSharesTotal() internal view virtual returns (uint256);
+}

package/contracts/libraries/{SCYIndex.sol → SCY/SCYIndex.sol}

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
-import "../SuperComposableYield/ISuperComposableYield.sol";
-import "../SuperComposableYield/SCYUtils.sol";
-import "./math/Math.sol";
+pragma solidity 0.8.15;
+import "../../interfaces/ISuperComposableYield.sol";
+import "./SCYUtils.sol";
+import "../math/Math.sol";
 
 type SCYIndex is uint256;
 
@@ -10,12 +10,12 @@ library SCYIndexLib {
     using Math for uint256;
     using Math for int256;
 
-    function newIndex(ISuperComposableYield SCY) internal returns (SCYIndex) {
-        return SCYIndex.wrap(SCY.scyIndexCurrent());
+    function newIndex(ISuperComposableYield SCY) internal view returns (SCYIndex) {
+        return SCYIndex.wrap(SCY.exchangeRate());
     }
 
-    function newIndex(address SCY) internal returns (SCYIndex) {
-        return SCYIndex.wrap(ISuperComposableYield(SCY).scyIndexCurrent());
+    function newIndex(address SCY) internal view returns (SCYIndex) {
+        return SCYIndex.wrap(ISuperComposableYield(SCY).exchangeRate());
     }
 
     function scyToAsset(SCYIndex index, uint256 scyAmount)

package/contracts/libraries/SCY/SCYUtils.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+library SCYUtils {
+    uint256 internal constant ONE = 1e18;
+
+    function scyToAsset(uint256 exchangeRate, uint256 scyAmount) internal pure returns (uint256) {
+        return (scyAmount * exchangeRate) / ONE;
+    }
+
+    function assetToScy(uint256 exchangeRate, uint256 assetAmount)
+        internal
+        pure
+        returns (uint256)
+    {
+        return (assetAmount * ONE) / exchangeRate;
+    }
+}

package/contracts/libraries/VeBalanceLib.sol

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+struct VeBalance {
+    uint128 bias;
+    uint128 slope;
+}
+
+struct LockedPosition {
+    uint128 amount;
+    uint128 expiry;
+}
+
+library VeBalanceLib {
+    uint128 internal constant MAX_LOCK_TIME = 104 weeks;
+
+    function add(VeBalance memory a, VeBalance memory b)
+        internal
+        pure
+        returns (VeBalance memory res)
+    {
+        res.bias = a.bias + b.bias;
+        res.slope = a.slope + b.slope;
+    }
+
+    function sub(VeBalance memory a, VeBalance memory b)
+        internal
+        pure
+        returns (VeBalance memory res)
+    {
+        res.bias = a.bias - b.bias;
+        res.slope = a.slope - b.slope;
+    }
+
+    function sub(
+        VeBalance memory a,
+        uint128 slope,
+        uint128 expiry
+    ) internal pure returns (VeBalance memory res) {
+        res.slope = a.slope - slope;
+        res.bias = a.bias - slope * expiry;
+    }
+
+    function isExpired(VeBalance memory a) internal view returns (bool) {
+        return a.slope * uint128(block.timestamp) >= a.bias;
+    }
+
+    function getCurrentValue(VeBalance memory a) internal view returns (uint128) {
+        if (isExpired(a)) return 0;
+        return getValueAt(a, uint128(block.timestamp));
+    }
+
+    function getValueAt(VeBalance memory a, uint128 t) internal pure returns (uint128) {
+        return a.bias - a.slope * t;
+    }
+
+    function getExpiry(VeBalance memory a) internal pure returns (uint128) {
+        require(a.slope != 0, "zero slope");
+        return a.bias / a.slope;
+    }
+
+    function convertToVeBalance(LockedPosition memory position)
+        internal
+        pure
+        returns (VeBalance memory res)
+    {
+        res.slope = position.amount / MAX_LOCK_TIME;
+        require(res.slope > 0, "zero slope");
+        res.bias = res.slope * position.expiry;
+    }
+
+    function convertToVeBalance(uint128 amount, uint128 expiry)
+        internal
+        pure
+        returns (uint128, uint128)
+    {
+        VeBalance memory balance = convertToVeBalance(LockedPosition(amount, expiry));
+        return (balance.bias, balance.slope);
+    }
+}

package/contracts/libraries/VeHistoryLib.sol

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: MIT
+// Forked from OpenZeppelin (v4.5.0) (utils/Checkpoints.sol)
+pragma solidity ^0.8.0;
+
+import "./math/Math.sol";
+import "./VeBalanceLib.sol";
+
+library Checkpoints {
+    struct Checkpoint {
+        uint32 _timestamp;
+        VeBalance _value;
+    }
+
+    struct History {
+        Checkpoint[] _checkpoints;
+    }
+
+    /**
+     * @dev Returns the value at a given block number. If a checkpoint is not available at that block, the closest one
+     * before it is returned, or zero otherwise.
+     */
+    function getAtTimestamp(History storage self, uint256 timestamp)
+        internal
+        view
+        returns (uint128)
+    {
+        require(timestamp < block.timestamp, "Checkpoints: block not yet mined");
+
+        uint256 high = self._checkpoints.length;
+        uint256 low = 0;
+        while (low < high) {
+            uint256 mid = (low + high) / 2;
+            if (self._checkpoints[mid]._timestamp > timestamp) {
+                high = mid;
+            } else {
+                low = mid + 1;
+            }
+        }
+        return
+            high == 0
+                ? 0
+                : VeBalanceLib.getValueAt(self._checkpoints[high - 1]._value, uint128(timestamp));
+    }
+
+    /**
+     * @dev Pushes a value onto a History so that it is stored as the checkpoint for the current block.
+     *
+     * Returns previous value and new value.
+     */
+    function push(History storage self, VeBalance memory value) internal {
+        uint256 pos = self._checkpoints.length;
+        if (pos > 0 && self._checkpoints[pos - 1]._timestamp == block.timestamp) {
+            self._checkpoints[pos - 1]._value = value;
+        } else {
+            self._checkpoints.push(
+                Checkpoint({ _timestamp: uint32(block.timestamp), _value: value })
+            );
+        }
+    }
+}