@pendle/core-v2 0.1.0

package/contracts/core/PendleYieldToken.sol

@@ -0,0 +1,240 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+
+import "./PendleBaseToken.sol";
+import "../SuperComposableYield/ISuperComposableYield.sol";
+import "../interfaces/IPYieldToken.sol";
+import "../interfaces/IPOwnershipToken.sol";
+import "../libraries/math/FixedPoint.sol";
+import "../interfaces/IPYieldContractFactory.sol";
+import "openzeppelin-solidity/contracts/utils/math/Math.sol";
+import "openzeppelin-solidity/contracts/token/ERC20/utils/SafeERC20.sol";
+import "../SuperComposableYield/SCYUtils.sol";
+import "../SuperComposableYield/implementations/RewardManager.sol";
+
+contract PendleYieldToken is PendleBaseToken, IPYieldToken, RewardManager {
+    using FixedPoint for uint256;
+    using SafeERC20 for IERC20;
+
+    struct UserData {
+        uint256 lastScyIndex;
+        uint256 dueInterest;
+    }
+
+    address public immutable SCY;
+    address public immutable OT;
+
+    /// params to do interests & rewards accounting
+    uint256 public lastScyBalance;
+    uint256 public lastScyIndexBeforeExpiry;
+    uint256[] public paramL;
+
+    /// params to do fee accounting
+    mapping(address => uint256) public totalRewardsPostExpiry;
+    uint256 public totalProtocolFee;
+
+    mapping(address => UserData) public data;
+
+    constructor(
+        address _SCY,
+        address _OT,
+        string memory _name,
+        string memory _symbol,
+        uint8 __decimals,
+        uint256 _expiry
+    ) PendleBaseToken(_name, _symbol, __decimals, _expiry) {
+        SCY = _SCY;
+        OT = _OT;
+    }
+
+    /**
+     * @notice this function splits scy into OT + YT of equal qty
+     * @dev the scy to tokenize has to be pre-transferred to this contract prior to the function call
+     */
+    function mintYO(address receiverOT, address receiverYT) public returns (uint256 amountYOOut) {
+        uint256 amountToTokenize = _receiveSCY();
+
+        amountYOOut = _calcAmountToMint(amountToTokenize);
+
+        _mint(receiverYT, amountYOOut);
+
+        IPOwnershipToken(OT).mintByYT(receiverOT, amountYOOut);
+    }
+
+    /// this function converts YO tokens into scy, but interests & rewards are not included
+    function redeemYO(address receiver) public returns (uint256 amountScyOut) {
+        // minimum of OT & YT balance
+        uint256 amountYOToRedeem = IERC20(OT).balanceOf(address(this));
+        if (!isExpired()) {
+            amountYOToRedeem = Math.min(amountYOToRedeem, balanceOf(address(this)));
+            _burn(address(this), amountYOToRedeem);
+        }
+        IPOwnershipToken(OT).burnByYT(address(this), amountYOToRedeem);
+
+        amountScyOut = _calcAmountRedeemable(amountYOToRedeem);
+
+        IERC20(SCY).safeTransfer(receiver, amountScyOut);
+        _afterTransferOutSCY();
+    }
+
+    function redeemDueInterest(address user) public returns (uint256 interestOut) {
+        _updateDueInterest(user);
+
+        uint256 interestPreFee = data[user].dueInterest;
+        data[user].dueInterest = 0;
+
+        uint256 feeRate = IPYieldContractFactory(factory).interestFeeRate();
+        uint256 feeAmount = interestPreFee.mulDown(feeRate);
+        totalProtocolFee += feeAmount;
+
+        interestOut = interestPreFee - feeAmount;
+        IERC20(SCY).safeTransfer(user, interestOut);
+        _afterTransferOutSCY();
+    }
+
+    function redeemDueRewards(address user, address receiver)
+        public
+        returns (uint256[] memory rewardsOut)
+    {
+        if (user != msg.sender) require(receiver == user, "invalid receiver");
+        else require(receiver != address(0), "zero address");
+
+        _updateUserReward(user, balanceOf(user), totalSupply());
+        rewardsOut = _doTransferOutRewardsForUser(user, receiver);
+    }
+
+    function updateGlobalReward() public virtual {
+        address[] memory rewardTokens = getRewardTokens();
+        _updateGlobalReward(rewardTokens, totalSupply());
+    }
+
+    function updateUserReward(address user) public virtual {
+        _updateUserReward(user, balanceOf(user), totalSupply());
+    }
+
+    function _updateGlobalReward(address[] memory rewardTokens, uint256 totalSupply)
+        internal
+        virtual
+        override
+    {
+        _redeemExternalReward();
+
+        _initGlobalReward(rewardTokens);
+
+        bool _isExpired = isExpired();
+        for (uint256 i = 0; i < rewardTokens.length; ++i) {
+            address token = rewardTokens[i];
+
+            uint256 currentRewardBalance = IERC20(token).balanceOf(address(this));
+            uint256 totalIncomeReward = currentRewardBalance - globalReward[token].lastBalance;
+
+            if (_isExpired) {
+                totalRewardsPostExpiry[token] += totalIncomeReward;
+            } else if (totalSupply != 0) {
+                globalReward[token].index += totalIncomeReward.divDown(totalSupply);
+            }
+
+            globalReward[token].lastBalance = currentRewardBalance;
+        }
+    }
+
+    function _redeemExternalReward() internal virtual override {
+        ISuperComposableYield(SCY).redeemReward(address(this), address(this));
+    }
+
+    function getRewardTokens()
+        public
+        view
+        virtual
+        override(RewardManager)
+        returns (address[] memory)
+    {
+        return ISuperComposableYield(SCY).getRewardTokens();
+    }
+
+    function getScyIndexBeforeExpiry() public returns (uint256 res) {
+        if (isExpired()) return res = lastScyIndexBeforeExpiry;
+        res = ISuperComposableYield(SCY).scyIndexCurrent();
+        lastScyIndexBeforeExpiry = res;
+    }
+
+    function withdrawFeeToTreasury() public {
+        address[] memory rewardTokens = ISuperComposableYield(SCY).getRewardTokens();
+        uint256 length = rewardTokens.length;
+        address treasury = IPYieldContractFactory(factory).treasury();
+
+        for (uint256 i = 0; i < length; i++) {
+            address token = rewardTokens[i];
+            uint256 outAmount = totalRewardsPostExpiry[token];
+            if (outAmount > 0) IERC20(rewardTokens[i]).safeTransfer(treasury, outAmount);
+            totalRewardsPostExpiry[token] = 0;
+        }
+
+        if (totalProtocolFee > 0) {
+            IERC20(SCY).safeTransfer(treasury, totalProtocolFee);
+            _afterTransferOutSCY();
+            totalProtocolFee = 0;
+        }
+    }
+
+    function _updateDueInterest(address user) internal {
+        uint256 prevIndex = data[user].lastScyIndex;
+
+        uint256 currentIndex = getScyIndexBeforeExpiry();
+
+        if (prevIndex == currentIndex) return;
+        if (prevIndex == 0) {
+            data[user].lastScyIndex = currentIndex;
+            return;
+        }
+
+        uint256 principal = balanceOf(user);
+
+        uint256 interestFromYT = (principal * (currentIndex - prevIndex)).divDown(
+            prevIndex * currentIndex
+        );
+
+        data[user].dueInterest += interestFromYT;
+        data[user].lastScyIndex = currentIndex;
+    }
+
+    function _calcAmountToMint(uint256 amount) internal returns (uint256) {
+        return SCYUtils.scyToAsset(getScyIndexBeforeExpiry(), amount);
+    }
+
+    function _calcAmountRedeemable(uint256 amount) internal returns (uint256) {
+        return SCYUtils.assetToScy(getScyIndexBeforeExpiry(), amount);
+    }
+
+    function _receiveSCY() internal returns (uint256 amount) {
+        uint256 balanceScy = IERC20(SCY).balanceOf(address(this));
+        amount = balanceScy - lastScyBalance;
+        require(amount > 0, "RECEIVE_ZERO");
+        lastScyBalance = balanceScy;
+    }
+
+    function _afterTransferOutSCY() internal {
+        lastScyBalance = IERC20(SCY).balanceOf(address(this));
+    }
+
+    function _beforeTokenTransfer(
+        address from,
+        address to,
+        uint256
+    ) internal override {
+        address[] memory rewardTokens = getRewardTokens();
+        _updateGlobalReward(rewardTokens, totalSupply());
+        if (from != address(0) && from != address(this)) {
+            _updateDueInterest(from);
+            _updateUserRewardSkipGlobal(rewardTokens, from, balanceOf(from));
+        }
+        if (to != address(0) && to != address(this)) {
+            _updateDueInterest(to);
+            _updateUserRewardSkipGlobal(rewardTokens, to, balanceOf(to));
+        }
+    }
+}
+/*INVARIANTS TO CHECK
+- supply OT == supply YT
+- reentrancy check
+*/

package/contracts/core/misc/BoringOwnable.sol

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.9;
+
+// Audit on 5-Jan-2021 by Keno and BoringCrypto
+// Source: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/Ownable.sol + Claimable.sol
+// Edited by BoringCrypto
+
+contract BoringOwnableData {
+    address public owner;
+    address public pendingOwner;
+}
+
+contract BoringOwnable is BoringOwnableData {
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+    /// @notice Only allows the `owner` to execute the function.
+    modifier onlyOwner() {
+        require(msg.sender == owner, "Ownable: caller is not the owner");
+        _;
+    }
+
+    constructor(address _owner) {
+        owner = _owner;
+    }
+
+    /// @notice Transfers ownership to `newOwner`. Either directly or claimable by the new pending owner.
+    /// Can only be invoked by the current `owner`.
+    /// @param newOwner Address of the new owner.
+    /// @param direct True if `newOwner` should be set immediately. False if `newOwner` needs to use `claimOwnership`.
+    /// @param renounce Allows the `newOwner` to be `address(0)` if `direct` and `renounce` is True. Has no effect otherwise.
+    function transferOwnership(
+        address newOwner,
+        bool direct,
+        bool renounce
+    ) public onlyOwner {
+        if (direct) {
+            // Checks
+            require(newOwner != address(0) || renounce, "Ownable: zero address");
+
+            // Effects
+            emit OwnershipTransferred(owner, newOwner);
+            owner = newOwner;
+            pendingOwner = address(0);
+        } else {
+            // Effects
+            pendingOwner = newOwner;
+        }
+    }
+
+    /// @notice Needs to be called by `pendingOwner` to claim ownership.
+    function claimOwnership() public {
+        address _pendingOwner = pendingOwner;
+
+        // Checks
+        require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
+
+        // Effects
+        emit OwnershipTransferred(owner, _pendingOwner);
+        owner = _pendingOwner;
+        pendingOwner = address(0);
+    }
+}

package/contracts/core/misc/BoringOwnableUpg.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.9;
+
+import "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol";
+
+/// Modified by the Pendle team, needs to audit
+
+contract BoringOwnableUpgData {
+    address public owner;
+    address public pendingOwner;
+}
+
+contract BoringOwnableUpg is BoringOwnableUpgData, Initializable {
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+    function __BoringOwnable_init() internal onlyInitializing {
+        owner = msg.sender;
+    }
+
+    /// @notice Transfers ownership to `newOwner`. Either directly or claimable by the new pending owner.
+    /// Can only be invoked by the current `owner`.
+    /// @param newOwner Address of the new owner.
+    /// @param direct True if `newOwner` should be set immediately. False if `newOwner` needs to use `claimOwnership`.
+    /// @param renounce Allows the `newOwner` to be `address(0)` if `direct` and `renounce` is True. Has no effect otherwise.
+    function transferOwnership(
+        address newOwner,
+        bool direct,
+        bool renounce
+    ) public onlyOwner {
+        if (direct) {
+            // Checks
+            require(newOwner != address(0) || renounce, "Ownable: zero address");
+
+            // Effects
+            emit OwnershipTransferred(owner, newOwner);
+            owner = newOwner;
+            pendingOwner = address(0);
+        } else {
+            // Effects
+            pendingOwner = newOwner;
+        }
+    }
+
+    /// @notice Needs to be called by `pendingOwner` to claim ownership.
+    function claimOwnership() public {
+        address _pendingOwner = pendingOwner;
+
+        // Checks
+        require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
+
+        // Effects
+        emit OwnershipTransferred(owner, _pendingOwner);
+        owner = _pendingOwner;
+        pendingOwner = address(0);
+    }
+
+    /// @notice Only allows the `owner` to execute the function.
+    modifier onlyOwner() {
+        require(msg.sender == owner, "Ownable: caller is not the owner");
+        _;
+    }
+
+    uint256[48] private __gap;
+}

package/contracts/core/misc/PendleJoeSwapHelperUpg.sol

@@ -0,0 +1,82 @@
+// 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.9;
+import "../../interfaces/IJoeRouter01.sol";
+import "../../libraries/JoeLibrary.sol";
+import "openzeppelin-solidity/contracts/token/ERC20/IERC20.sol";
+import "openzeppelin-solidity/contracts/token/ERC20/utils/SafeERC20.sol";
+
+abstract contract PendleJoeSwapHelperUpg {
+    using SafeERC20 for IERC20;
+    address public immutable joeRouter;
+    address public immutable joeFactory;
+
+    /// @dev since this contract will be proxied, it must not contains non-immutable variables
+    constructor(address _joeRouter, address _joeFactory) {
+        joeRouter = _joeRouter;
+        joeFactory = _joeFactory;
+    }
+
+    function _getFirstPair(address[] memory path) internal view returns (address pair) {
+        return JoeLibrary.pairFor(joeFactory, path[0], path[1]);
+    }
+
+    /**
+     * @notice swap tokens with no limit on amountOut. Tokens must have been transferred to the first pair
+     */
+    function _swapExactIn(
+        address[] memory path,
+        uint256 amountIn,
+        address receiver
+    ) internal virtual returns (uint256 amountOut) {
+        uint256[] memory amounts = JoeLibrary.getAmountsOut(joeFactory, amountIn, path);
+        _low_level_swap(amounts, path, receiver);
+        amountOut = amounts[amounts.length - 1];
+    }
+
+    /// function from TraderJoe
+    function _low_level_swap(
+        uint256[] memory amounts,
+        address[] memory path,
+        address _to
+    ) internal virtual {
+        for (uint256 i; i < path.length - 1; i++) {
+            (address input, address output) = (path[i], path[i + 1]);
+            (address token0, ) = JoeLibrary.sortTokens(input, output);
+            uint256 amountOut = amounts[i + 1];
+            (uint256 amount0Out, uint256 amount1Out) = input == token0
+                ? (uint256(0), amountOut)
+                : (amountOut, uint256(0));
+            address to = i < path.length - 2
+                ? JoeLibrary.pairFor(joeFactory, output, path[i + 2])
+                : _to;
+            IJoePair(JoeLibrary.pairFor(joeFactory, input, output)).swap(
+                amount0Out,
+                amount1Out,
+                to,
+                new bytes(0)
+            );
+        }
+    }
+}

package/contracts/core/router/PendleRouterCoreUpg.sol

@@ -0,0 +1,219 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+
+import "./base/PendleRouterSCYAndForgeBaseUpg.sol";
+import "./base/PendleRouterOTBaseUpg.sol";
+import "../../interfaces/IPOwnershipToken.sol";
+import "../../interfaces/IPYieldToken.sol";
+import "../../interfaces/IPRouterCore.sol";
+
+contract PendleRouterCoreUpg is
+    IPRouterCore,
+    PendleRouterSCYAndForgeBaseUpg,
+    PendleRouterOTBaseUpg
+{
+    using MarketMathLib for MarketParameters;
+    using FixedPoint for uint256;
+    using FixedPoint for int256;
+
+    /// @dev since this contract will be proxied, it must not contains non-immutable variabless
+    constructor(
+        address _joeRouter,
+        address _joeFactory,
+        address _marketFactory
+    )
+        PendleRouterSCYAndForgeBaseUpg(_joeRouter, _joeFactory)
+        PendleRouterOTBaseUpg()
+    //solhint-disable-next-line no-empty-blocks
+    {
+
+    }
+
+    /// @dev docs can be found in the internal function
+    function addLiquidity(
+        address receiver,
+        address market,
+        uint256 scyDesired,
+        uint256 otDesired,
+        uint256 minLpOut
+    )
+        external
+        returns (
+            uint256,
+            uint256,
+            uint256
+        )
+    {
+        return _addLiquidity(receiver, market, scyDesired, otDesired, minLpOut, true);
+    }
+
+    /// @dev docs can be found in the internal function
+    function removeLiquidity(
+        address receiver,
+        address market,
+        uint256 lpToRemove,
+        uint256 scyOutMin,
+        uint256 otOutMin
+    ) external returns (uint256, uint256) {
+        return _removeLiquidity(receiver, market, lpToRemove, scyOutMin, otOutMin, true);
+    }
+
+    /// @dev docs can be found in the internal function
+    function swapExactOtForScy(
+        address receiver,
+        address market,
+        uint256 exactOtIn,
+        uint256 minScyOut
+    ) external returns (uint256) {
+        return _swapExactOtForScy(receiver, market, exactOtIn, minScyOut, true);
+    }
+
+    /// @dev docs can be found in the internal function
+    function swapOtForExactScy(
+        address receiver,
+        address market,
+        uint256 maxOtIn,
+        uint256 exactScyOut,
+        uint256 netOtInGuessMin,
+        uint256 netOtInGuessMax
+    ) external returns (uint256) {
+        return
+            _swapOtForExactScy(
+                receiver,
+                market,
+                maxOtIn,
+                exactScyOut,
+                netOtInGuessMin,
+                netOtInGuessMax,
+                true
+            );
+    }
+
+    /// @dev docs can be found in the internal function
+    function swapScyForExactOt(
+        address receiver,
+        address market,
+        uint256 exactOtOut,
+        uint256 maxScyIn
+    ) external returns (uint256) {
+        return _swapScyForExactOt(receiver, market, exactOtOut, maxScyIn, true);
+    }
+
+    /// @dev docs can be found in the internal function
+    function swapExactScyForOt(
+        address receiver,
+        address market,
+        uint256 exactScyIn,
+        uint256 minOtOut,
+        uint256 netOtOutGuessMin,
+        uint256 netOtOutGuessMax
+    ) external returns (uint256) {
+        return
+            _swapExactScyForOt(
+                receiver,
+                market,
+                exactScyIn,
+                minOtOut,
+                netOtOutGuessMin,
+                netOtOutGuessMax,
+                true
+            );
+    }
+
+    /// @dev docs can be found in the internal function
+    function mintScyFromRawToken(
+        uint256 netRawTokenIn,
+        address SCY,
+        uint256 minScyOut,
+        address receiver,
+        address[] calldata path
+    ) external returns (uint256) {
+        return _mintScyFromRawToken(netRawTokenIn, SCY, minScyOut, receiver, path, true);
+    }
+
+    /// @dev docs can be found in the internal function
+    function redeemScyToRawToken(
+        address SCY,
+        uint256 netScyIn,
+        uint256 minRawTokenOut,
+        address receiver,
+        address[] memory path
+    ) external returns (uint256) {
+        return _redeemScyToRawToken(SCY, netScyIn, minRawTokenOut, receiver, path, true);
+    }
+
+    /// @dev docs can be found in the internal function
+    function mintYoFromRawToken(
+        uint256 netRawTokenIn,
+        address YT,
+        uint256 minYoOut,
+        address receiver,
+        address[] calldata path
+    ) external returns (uint256) {
+        return _mintYoFromRawToken(netRawTokenIn, YT, minYoOut, receiver, path, true);
+    }
+
+    /// @dev docs can be found in the internal function
+    function redeemYoToRawToken(
+        address YT,
+        uint256 netYoIn,
+        uint256 minRawTokenOut,
+        address receiver,
+        address[] memory path
+    ) external returns (uint256) {
+        return _redeemYoToRawToken(YT, netYoIn, minRawTokenOut, receiver, path, true);
+    }
+
+    /**
+    * @dev netOtOutGuessMin & netOtOutGuessMax the minimum & maximum possible guess for the netOtOut
+    the correct otOut must lie between this range, else the function will revert.
+    * @dev the smaller the range, the fewer iterations it will take (hence less gas). The expected way
+    to create the guess is to run this function with min = 0, max = type(uint256.max) to trigger the widest
+    guess range. After getting the result, min = result * (100-slippage) & max = result * (100+slippage)
+    * @param path the path to swap from rawToken to baseToken. path = [baseToken] if no swap is needed
+    */
+    function swapExactRawTokenForOt(
+        uint256 exactRawTokenIn,
+        address receiver,
+        address[] calldata path,
+        address market,
+        uint256 minOtOut,
+        uint256 netOtOutGuessMin,
+        uint256 netOtOutGuessMax
+    ) external returns (uint256 netOtOut) {
+        address SCY = IPMarket(market).SCY();
+        uint256 netScyUseToBuyOt = _mintScyFromRawToken(
+            exactRawTokenIn,
+            SCY,
+            1,
+            market,
+            path,
+            true
+        );
+        netOtOut = _swapExactScyForOt(
+            receiver,
+            market,
+            netScyUseToBuyOt,
+            minOtOut,
+            netOtOutGuessMin,
+            netOtOutGuessMax,
+            false
+        );
+    }
+
+    /**
+     * @notice sell all Ot for RawToken
+     * @param path the path to swap from rawToken to baseToken. path = [baseToken] if no swap is needed
+     */
+    function swapExactOtForRawToken(
+        uint256 exactOtIn,
+        address receiver,
+        address[] calldata path,
+        address market,
+        uint256 minRawTokenOut
+    ) external returns (uint256 netRawTokenOut) {
+        address SCY = IPMarket(market).SCY();
+        _swapExactOtForScy(SCY, market, exactOtIn, 1, true);
+        netRawTokenOut = _redeemScyToRawToken(SCY, 0, minRawTokenOut, receiver, path, false);
+    }
+}