@pendle/core-v2 0.6.8 → 0.7.0

package/contracts/core/PendleSCYImpl/PendleStETHSCY.sol

@@ -1,107 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
-import "../../SuperComposableYield/implementations/SCYBase.sol";
-import "../../interfaces/IWstETH.sol";
-
-contract PendleStEthSCY is SCYBase {
-    using SafeERC20 for IERC20;
-
-    address public immutable stETH;
-    address public immutable wstETH;
-
-    uint256 public override scyIndexStored;
-
-    constructor(
-        string memory _name,
-        string memory _symbol,
-        uint8 __scydecimals,
-        uint8 __assetDecimals,
-        address _stETH,
-        address _wstETH,
-        bytes32 __assetId
-    ) SCYBase(_name, _symbol, __scydecimals, __assetDecimals, __assetId) {
-        require(_wstETH != address(0), "zero address");
-        stETH = _stETH;
-        wstETH = _wstETH;
-        IERC20(stETH).safeIncreaseAllowance(wstETH, type(uint256).max);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                    DEPOSIT/REDEEM USING BASE TOKENS
-    //////////////////////////////////////////////////////////////*/
-    function _deposit(address token, uint256 amountBase)
-        internal
-        virtual
-        override
-        returns (uint256 amountScyOut)
-    {
-        if (token == stETH) {
-            amountScyOut = IWstETH(wstETH).wrap(amountBase);
-            _afterSendToken(stETH);
-            _afterReceiveToken(wstETH);
-        } else {
-            // 1 wstETH = 1 SCY
-            amountScyOut = amountBase;
-        }
-    }
-
-    function _redeem(address token, uint256 amountScy)
-        internal
-        virtual
-        override
-        returns (uint256 amountBaseOut)
-    {
-        if (token == stETH) {
-            amountBaseOut = IWstETH(wstETH).unwrap(amountScy);
-            _afterSendToken(wstETH);
-            _afterReceiveToken(stETH);
-        } else {
-            // 1 wstETH = 1 SCY
-            amountBaseOut = amountScy;
-        }
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                               SCY-INDEX
-    //////////////////////////////////////////////////////////////*/
-
-    function scyIndexCurrent() public virtual override returns (uint256) {
-        scyIndexStored = IWstETH(wstETH).stEthPerToken();
-        emit UpdateScyIndex(scyIndexStored);
-        return scyIndexStored;
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                MISC FUNCTIONS FOR METADATA
-    //////////////////////////////////////////////////////////////*/
-
-    function getBaseTokens() public view virtual override returns (address[] memory res) {
-        res = new address[](2);
-        res[0] = stETH;
-        res[1] = wstETH;
-    }
-
-    function isValidBaseToken(address token) public view virtual override returns (bool) {
-        return token == stETH || token == wstETH;
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                               REWARDS-RELATED
-    //////////////////////////////////////////////////////////////*/
-
-    //solhint-disable-next-line no-empty-blocks
-    function redeemReward(address user) public virtual override returns (uint256[] memory) {}
-
-    //solhint-disable-next-line no-empty-blocks
-    function updateGlobalReward() public virtual override {}
-
-    //solhint-disable-next-line no-empty-blocks
-    function updateUserReward(address user) public virtual override {}
-
-    function getRewardTokens() public view virtual returns (address[] memory res) {
-        res = new address[](0);
-    }
-
-    //solhint-disable-next-line no-empty-blocks
-    function _redeemExternalReward() internal virtual {}
-}

package/contracts/core/PendleSCYImpl/PendleYearnVaultSCY.sol

@@ -1,109 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
-
-import "../../SuperComposableYield/implementations/SCYBase.sol";
-import "../../interfaces/IYearnVault.sol";
-
-contract PendleYearnVaultScy is SCYBase {
-    using SafeERC20 for IERC20;
-
-    address public immutable underlying;
-    address public immutable yvToken;
-
-    uint256 public override scyIndexStored;
-
-    constructor(
-        string memory _name,
-        string memory _symbol,
-        uint8 __scydecimals,
-        uint8 __assetDecimals,
-        bytes32 __assetId,
-        address _underlying,
-        address _yvToken
-    ) SCYBase(_name, _symbol, __scydecimals, __assetDecimals, __assetId) {
-        require(_yvToken != address(0), "zero address");
-        yvToken = _yvToken;
-        underlying = _underlying;
-        IERC20(underlying).safeIncreaseAllowance(yvToken, type(uint256).max);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                    DEPOSIT/REDEEM USING BASE TOKENS
-    //////////////////////////////////////////////////////////////*/
-
-    function _deposit(address token, uint256 amountBase)
-        internal
-        virtual
-        override
-        returns (uint256 amountScyOut)
-    {
-        if (token == yvToken) {
-            amountScyOut = amountBase;
-        } else {
-            // must be underlying
-            IYearnVault(yvToken).deposit(amountBase); // ignore return
-            _afterSendToken(underlying);
-            amountScyOut = _afterReceiveToken(yvToken);
-        }
-    }
-
-    function _redeem(address token, uint256 amountScy)
-        internal
-        virtual
-        override
-        returns (uint256 amountBaseOut)
-    {
-        if (token == yvToken) {
-            amountBaseOut = amountScy;
-        } else {
-            // must be underlying
-            IYearnVault(yvToken).withdraw(amountScy); // ignore return
-            _afterSendToken(yvToken);
-            amountBaseOut = _afterReceiveToken(underlying);
-        }
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                               SCY-INDEX
-    //////////////////////////////////////////////////////////////*/
-
-    function scyIndexCurrent() public virtual override returns (uint256 res) {
-        scyIndexStored = IYearnVault(yvToken).pricePerShare();
-        emit UpdateScyIndex(scyIndexStored);
-        return scyIndexStored;
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                MISC FUNCTIONS FOR METADATA
-    //////////////////////////////////////////////////////////////*/
-
-    function getBaseTokens() public view virtual override returns (address[] memory res) {
-        res = new address[](2);
-        res[0] = underlying;
-        res[1] = yvToken;
-    }
-
-    function isValidBaseToken(address token) public view virtual override returns (bool) {
-        return token == underlying || token == yvToken;
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                               REWARDS-RELATED
-    //////////////////////////////////////////////////////////////*/
-
-    //solhint-disable-next-line no-empty-blocks
-    function redeemReward(address user) public virtual override returns (uint256[] memory) {}
-
-    //solhint-disable-next-line no-empty-blocks
-    function updateGlobalReward() public virtual override {}
-
-    //solhint-disable-next-line no-empty-blocks
-    function updateUserReward(address user) public virtual override {}
-
-    function getRewardTokens() public view virtual returns (address[] memory res) {
-        res = new address[](0);
-    }
-
-    //solhint-disable-next-line no-empty-blocks
-    function _redeemExternalReward() internal virtual {}
-}

package/contracts/core/PendleYieldToken.sol

@@ -1,340 +0,0 @@
-// 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/IPPrincipalToken.sol";
-import "../libraries/math/Math.sol";
-import "../interfaces/IPYieldContractFactory.sol";
-import "../SuperComposableYield/SCYUtils.sol";
-import "../SuperComposableYield/implementations/RewardManager.sol";
-import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-
-/*
-With YT yielding more SCYs overtime, which is allowed to be redeemed by users, the reward distribution should
-be based on the amount of SCYs that their YT currently represent, plus with their dueInterest.
-
-It has been proven and tested that impliedScyBalance will not change over time, unless users redeem their interest or redeemPY.
-
-Due to this, it is required to update users' accruedReward STRICTLY BEFORE redeeming their interest.
-*/
-contract PendleYieldToken is PendleBaseToken, RewardManager, IPYieldToken, ReentrancyGuard {
-    using Math for uint256;
-    using SafeERC20 for IERC20;
-
-    struct InterestData {
-        uint256 lastScyIndex;
-        uint256 dueInterest;
-    }
-
-    address public immutable SCY;
-    address public immutable PT;
-
-    /// params to do interests & rewards accounting
-    uint256 public lastScyBalance;
-    uint256 public lastScyIndexBeforeExpiry;
-
-    /// params to do fee accounting
-    mapping(address => uint256) public totalRewardsPostExpiry;
-    uint256 public totalInterestPostExpiry;
-    uint256 public totalProtocolFee;
-
-    mapping(address => InterestData) internal interestData;
-
-    constructor(
-        address _SCY,
-        address _PT,
-        string memory _name,
-        string memory _symbol,
-        uint8 __decimals,
-        uint256 _expiry
-    ) PendleBaseToken(_name, _symbol, __decimals, _expiry) {
-        require(_SCY != address(0) && _PT != address(0), "zero address");
-        SCY = _SCY;
-        PT = _PT;
-    }
-
-    /**
-     * @notice this function splits scy into PT + YT of equal qty
-     * @dev the scy to tokenize has to be pre-transferred to this contract prior to the function call
-     */
-    function mintPY(address receiverPT, address receiverYT)
-        external
-        nonReentrant
-        returns (uint256 amountPYOut)
-    {
-        uint256 amountToTokenize = _receiveSCY();
-
-        amountPYOut = _calcAmountToMint(amountToTokenize);
-
-        _mint(receiverYT, amountPYOut);
-
-        IPPrincipalToken(PT).mintByYT(receiverPT, amountPYOut);
-    }
-
-    /// @dev this function converts PY tokens into scy, but interests & rewards are not redeemed at the same time
-    function redeemPY(address receiver) external nonReentrant returns (uint256 amountScyOut) {
-        // minimum of PT & YT balance
-        uint256 amountPYToRedeem = IERC20(PT).balanceOf(address(this));
-        if (!isExpired()) {
-            amountPYToRedeem = Math.min(amountPYToRedeem, balanceOf(address(this)));
-            _burn(address(this), amountPYToRedeem);
-        }
-
-        IPPrincipalToken(PT).burnByYT(address(this), amountPYToRedeem);
-
-        uint256 amountScyToTreasury;
-        (amountScyOut, amountScyToTreasury) = _calcAmountToRedeem(amountPYToRedeem);
-
-        totalInterestPostExpiry += amountScyToTreasury;
-
-        IERC20(SCY).safeTransfer(receiver, amountScyOut);
-        _afterTransferOutSCY();
-    }
-
-    /**
-     * @dev as mentioned in doc, updateDueReward should be placed strictly before every redeemDueInterest
-     */
-    function redeemDueInterestAndRewards(address user)
-        external
-        nonReentrant
-        returns (uint256 interestOut, uint256[] memory rewardsOut)
-    {
-        // redeemDueRewards before redeemDueInterest
-        _updateUserReward(user);
-        _updateUserInterest(user);
-        rewardsOut = _doTransferOutRewardsForUser(user, user);
-        interestOut = _doTransferOutDueInterest(user);
-
-        emit RedeemReward(user, rewardsOut);
-        emit RedeemInterest(user, interestOut);
-    }
-
-    /**
-     * @dev as mentioned in doc, updateDueReward should be placed strictly before every redeemDueInterest
-     */
-    function redeemDueInterest(address user) external nonReentrant returns (uint256 interestOut) {
-        _updateUserReward(user); /// strictly required, see above for explanation
-
-        _updateUserInterest(user);
-        interestOut = _doTransferOutDueInterest(user);
-        emit RedeemInterest(user, interestOut);
-    }
-
-    function redeemDueRewards(address user)
-        external
-        nonReentrant
-        returns (uint256[] memory rewardsOut)
-    {
-        _updateUserReward(user);
-
-        rewardsOut = _doTransferOutRewardsForUser(user, user);
-        emit RedeemReward(user, rewardsOut);
-    }
-
-    /**
-     * @dev updateGlobalReward does not need reentrancy modifier since the rewards
-     * will be transfered directly from SCY to YT, without triggering any callbacks
-     */
-    function updateGlobalReward() external nonReentrant {
-        _updateGlobalReward();
-    }
-
-    function updateUserReward(address user) external nonReentrant {
-        _updateUserReward(user);
-    }
-
-    function updateUserInterest(address user) external nonReentrant {
-        _updateUserInterest(user);
-    }
-
-    function _updateUserInterest(address user) internal {
-        uint256 prevIndex = interestData[user].lastScyIndex;
-
-        (, uint256 currentIndexBeforeExpiry) = getScyIndex();
-
-        if (prevIndex == currentIndexBeforeExpiry) return;
-        if (prevIndex == 0) {
-            interestData[user].lastScyIndex = currentIndexBeforeExpiry;
-            return;
-        }
-
-        uint256 principal = balanceOf(user);
-
-        uint256 interestFromYT = (principal * (currentIndexBeforeExpiry - prevIndex)).divDown(
-            prevIndex * currentIndexBeforeExpiry
-        );
-
-        interestData[user].dueInterest += interestFromYT;
-        interestData[user].lastScyIndex = currentIndexBeforeExpiry;
-    }
-
-    function getInterestData(address user)
-        external
-        view
-        returns (uint256 lastScyIndex, uint256 dueInterest)
-    {
-        return (interestData[user].lastScyIndex, interestData[user].dueInterest);
-    }
-
-    /// @dev override the default updateGlobalReward to avoid distributing the rewards after
-    /// YT has expired. Instead, these funds will go to the treasury
-    function _updateGlobalReward() internal virtual override {
-        if (!_shouldUpdateGlobalReward()) return;
-        _redeemExternalReward();
-
-        uint256 totalShares = _rewardSharesTotal();
-
-        address[] memory rewardTokens = getRewardTokens();
-        _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 (totalShares != 0) {
-                globalReward[token].index += totalIncomeReward.divDown(totalShares);
-            }
-
-            globalReward[token].lastBalance = currentRewardBalance;
-        }
-    }
-
-    function _doTransferOutDueInterest(address user) internal returns (uint256 interestOut) {
-        uint256 interestPreFee = interestData[user].dueInterest;
-        interestData[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 _redeemExternalReward() internal virtual override {
-        ISuperComposableYield(SCY).redeemReward(address(this)); // ignore return
-    }
-
-    /// @dev to be overriden if there is rewards
-    function _rewardSharesTotal() internal virtual override returns (uint256) {
-        return IERC20(SCY).balanceOf(address(this));
-    }
-
-    /// @dev to be overriden if there is rewards
-    function _rewardSharesUser(address user) internal virtual override returns (uint256) {
-        return getImpliedScyBalance(user);
-    }
-
-    function getRewardTokens()
-        public
-        view
-        virtual
-        override(RewardManager, IRewardManager)
-        returns (address[] memory)
-    {
-        return ISuperComposableYield(SCY).getRewardTokens();
-    }
-
-    function getScyIndex() public returns (uint256 currentIndex, uint256 lastIndexBeforeExpiry) {
-        currentIndex = ISuperComposableYield(SCY).scyIndexCurrent();
-        if (isExpired()) {
-            lastIndexBeforeExpiry = lastScyIndexBeforeExpiry;
-        } else {
-            lastScyIndexBeforeExpiry = lastIndexBeforeExpiry = currentIndex;
-        }
-    }
-
-    /**
-     * @dev In case the pool is expired and there is left some SCY not yet redeemed from the contract, the rewards should
-     * be claimed before withdrawing to treasury.
-     *
-     * @dev And since the reward distribution (which based on users' dueInterest) stopped at the scyIndexBeforeExpiry, it is not
-     * necessary to updateUserInterest along with reward here.
-     */
-    function withdrawFeeToTreasury() public {
-        address[] memory rewardTokens = getRewardTokens();
-        if (isExpired()) {
-            _updateGlobalReward(); // as refered to the doc above
-        }
-
-        uint256 length = rewardTokens.length;
-        address treasury = IPYieldContractFactory(factory).treasury();
-        uint256[] memory amountRewardsOut = new uint256[](length);
-
-        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;
-            amountRewardsOut[i] = outAmount;
-        }
-
-        uint256 totalScyFee = totalProtocolFee + totalInterestPostExpiry;
-        totalProtocolFee = totalInterestPostExpiry = 0;
-
-        if (totalScyFee > 0) {
-            IERC20(SCY).safeTransfer(treasury, totalScyFee);
-            _afterTransferOutSCY();
-        }
-        emit WithdrawFeeToTreasury(amountRewardsOut, totalScyFee);
-    }
-
-    function _calcAmountToMint(uint256 amount) internal returns (uint256) {
-        (, uint256 lastIndexBeforeExpiry) = getScyIndex();
-        return SCYUtils.scyToAsset(lastIndexBeforeExpiry, amount);
-    }
-
-    function _calcAmountToRedeem(uint256 amount)
-        internal
-        returns (uint256 amountToUser, uint256 amountToTreasury)
-    {
-        (uint256 currentIndex, uint256 lastIndexBeforeExpiry) = getScyIndex();
-        uint256 totalRedeemable = SCYUtils.assetToScy(lastIndexBeforeExpiry, amount);
-        amountToUser = SCYUtils.assetToScy(currentIndex, amount);
-        amountToTreasury = totalRedeemable - amountToUser;
-    }
-
-    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 getImpliedScyBalance(address user) public view returns (uint256) {
-        uint256 scyIndex = interestData[user].lastScyIndex;
-        return SCYUtils.assetToScy(scyIndex, balanceOf(user)) + interestData[user].dueInterest;
-    }
-
-    function _beforeTokenTransfer(
-        address from,
-        address to,
-        uint256
-    ) internal override {
-        _updateGlobalReward();
-
-        // Before the change in YT balance, users' impliedScyBalance is kept unchanged from last time
-        // Therefore, both updating due interest before or after due reward work the same.
-        if (from != address(0) && from != address(this)) {
-            _updateUserInterest(from);
-            _updateUserRewardSkipGlobal(from);
-        }
-        if (to != address(0) && to != address(this)) {
-            _updateUserInterest(to);
-            _updateUserRewardSkipGlobal(to);
-        }
-    }
-}

package/contracts/core/actions/ActionRedeem.sol

@@ -1,36 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
-
-import "../../interfaces/IPActionRedeem.sol";
-import "../../SuperComposableYield/ISuperComposableYield.sol";
-import "../../interfaces/IPYieldToken.sol";
-import "../../core/PendleMarket.sol";
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-
-contract ActionRedeem is IPActionRedeem {
-    function redeemDueIncome(
-        address user,
-        address[] calldata scys,
-        address[] calldata yieldTokens,
-        address[] calldata /*gauges*/
-    )
-        external
-        returns (
-            uint256[][] memory scyRewards,
-            uint256[] memory ytInterests,
-            uint256[][] memory ytRewards
-        )
-    {
-        scyRewards = new uint256[][](scys.length);
-        for (uint256 i = 0; i < scys.length; ++i) {
-            scyRewards[i] = ISuperComposableYield(scys[i]).redeemReward(user);
-        }
-
-        ytInterests = new uint256[](yieldTokens.length);
-        ytRewards = new uint256[][](yieldTokens.length);
-        for (uint256 i = 0; i < yieldTokens.length; ++i) {
-            (ytInterests[i], ytRewards[i]) = IPYieldToken(yieldTokens[i])
-                .redeemDueInterestAndRewards(user);
-        }
-    }
-}

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

@@ -1,11 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
-
-abstract contract ActionType {
-    enum ACTION_TYPE {
-        SwapExactYtForScy,
-        SwapSCYForExactYt,
-        SwapExactScyForYt,
-        SwapYtForExactScy
-    }
-}

package/contracts/interfaces/IPActionRedeem.sol

@@ -1,17 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
-
-interface IPActionRedeem {
-    function redeemDueIncome(
-        address user,
-        address[] calldata scys,
-        address[] calldata yieldTokens,
-        address[] calldata /*gauges*/
-    )
-        external
-        returns (
-            uint256[][] memory scyRewards,
-            uint256[] memory ytInterests,
-            uint256[][] memory ytRewards
-        );
-}

package/contracts/interfaces/IPBaseToken.sol

@@ -1,9 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
-import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
-
-interface IPBaseToken is IERC20Metadata {
-    function expiry() external view returns (uint256);
-
-    function isExpired() external view returns (bool);
-}

package/contracts/interfaces/IPGauge.sol

@@ -1,32 +0,0 @@
-pragma solidity 0.8.9;
-pragma abicoder v2;
-
-interface IPendleGauge {
-    // ============= ACTIONS =============
-
-    function stake(address receiver) external;
-
-    function withdraw(address receiver, uint256 amount) external;
-
-    function redeemReward(address receiver) external returns (uint256 redeemedReward);
-
-    // ============= USER INFO =============
-
-    function readUserInfo(address user)
-        external
-        returns (
-            uint256 lpStaked,
-            uint256 activeLpAmount,
-            uint256 accruedReward
-        );
-
-    // ============= META DATA =============
-
-    function readGlobalInfo()
-        external
-        returns (
-            uint256 totalLpStaked,
-            uint256 totalActiveLp,
-            uint256 pendlePerSec
-        );
-}

package/contracts/interfaces/IPVotingEscrowController.sol

@@ -1,14 +0,0 @@
-pragma solidity 0.8.9;
-pragma abicoder v2;
-
-interface VotingEscrowController {
-    function pendlePerSec() external returns (uint256);
-
-    function totalVote() external returns (uint256);
-
-    /**
-     * @return vote Amount of vePendle voted for pool
-     * @return pendleSpeed Amount of Pendle incentivized for pool per second
-     */
-    function readPoolRewardInfo(address pool) external returns (uint256 vote, uint256 pendleSpeed);
-}