@pendle/core-v2 0.5.1-beta-5 → 0.6.2

package/contracts/core/PendleSCYImpl/AaveV3/PendleAaveV3SCY.sol

@@ -1,6 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.9;
-pragma abicoder v2;
 import "../../../SuperComposableYield/implementations/SCYBaseWithRewards.sol";
 import "../../../interfaces/IAToken.sol";
 import "../../../interfaces/IAavePool.sol";
@@ -8,6 +7,7 @@ import "../../../interfaces/IAaveRewardsController.sol";
 import "./WadRayMath.sol";
 
 contract PendleAaveV3SCY is SCYBaseWithRewards {
+    using Math for uint256;
     using WadRayMath for uint256;
     using SafeERC20 for IERC20;
 
@@ -17,24 +17,24 @@ contract PendleAaveV3SCY is SCYBaseWithRewards {
     address public immutable aToken;
 
     uint256 public lastScyIndex;
+    uint256 public constant PRECISION_INDEX = 1e9;
 
-    // WIP: Aave reward controller can config to have more rewardsToken,
-    // hence rewardsLength should not be immutable
     constructor(
         string memory _name,
         string memory _symbol,
         uint8 __scydecimals,
         uint8 __assetDecimals,
+        bytes32 __assetId,
         address _aavePool,
         address _underlying,
         address _aToken,
         address _rewardsController
-    ) SCYBaseWithRewards(_name, _symbol, __scydecimals, __assetDecimals) {
+    ) SCYBaseWithRewards(_name, _symbol, __scydecimals, __assetDecimals, __assetId) {
         aToken = _aToken;
         pool = _aavePool;
         underlying = _underlying;
         rewardsController = _rewardsController;
-        IERC20(underlying).safeIncreaseAllowance(aToken, type(uint256).max);
+        IERC20(underlying).safeIncreaseAllowance(pool, type(uint256).max);
     }
 
     /*///////////////////////////////////////////////////////////////
@@ -49,7 +49,7 @@ contract PendleAaveV3SCY is SCYBaseWithRewards {
     {
         // aTokenScaled -> scy is 1:1
         if (token == aToken) {
-            amountScyOut = amountBase.rayDiv(scyIndexCurrent());
+            amountScyOut = amountBase;
         } else {
             IAavePool(pool).supply(underlying, amountBase, address(this), 0);
             _afterSendToken(underlying);
@@ -64,9 +64,9 @@ contract PendleAaveV3SCY is SCYBaseWithRewards {
         returns (uint256 amountBaseOut)
     {
         if (token == aToken) {
-            amountBaseOut = amountScy.rayMul(scyIndexCurrent());
+            amountBaseOut = amountScy.rayMul(aaveIndexCurrent());
         } else {
-            uint256 amountBaseExpected = amountScy.rayMul(scyIndexCurrent());
+            uint256 amountBaseExpected = amountScy.rayMul(aaveIndexCurrent());
             IAavePool(pool).withdraw(underlying, amountBaseExpected, address(this));
             _afterSendToken(aToken);
             amountBaseOut = _afterReceiveToken(token);
@@ -78,9 +78,14 @@ contract PendleAaveV3SCY is SCYBaseWithRewards {
     //////////////////////////////////////////////////////////////*/
 
     function scyIndexCurrent() public virtual override returns (uint256 res) {
+        aaveIndexCurrent();
+        res = lastScyIndex;
+        emit UpdateScyIndex(lastScyIndex);
+    }
+
+    function aaveIndexCurrent() public returns (uint256 res) {
         res = IAavePool(pool).getReserveNormalizedIncome(underlying);
-        lastScyIndex = res;
-        return res;
+        lastScyIndex = res / PRECISION_INDEX;
     }
 
     function scyIndexStored() public view override returns (uint256 res) {
@@ -88,7 +93,7 @@ contract PendleAaveV3SCY is SCYBaseWithRewards {
     }
 
     function getRewardTokens() public view override returns (address[] memory res) {
-        return IAaveRewardsController(rewardsController).getRewardsByAsset(aToken);
+        res = IAaveRewardsController(rewardsController).getRewardsByAsset(aToken);
     }
 
     /*///////////////////////////////////////////////////////////////
@@ -118,15 +123,11 @@ contract PendleAaveV3SCY is SCYBaseWithRewards {
 
     /// @dev balance of aToken is saved by scaledBalanceOf instead
     function _afterReceiveToken(address token) internal virtual override returns (uint256 res) {
-        if (token == aToken) {
-            uint256 curBalance = IAToken(aToken).scaledBalanceOf(address(this));
-            res = (curBalance - lastBalanceOf[token]).rayMul(scyIndexCurrent());
-            lastBalanceOf[token] = curBalance;
-        } else {
-            uint256 curBalance = IERC20(token).balanceOf(address(this));
-            res = curBalance - lastBalanceOf[token];
-            lastBalanceOf[token] = curBalance;
-        }
+        uint256 curBalance = (token == aToken)
+            ? IAToken(aToken).scaledBalanceOf(address(this))
+            : IERC20(token).balanceOf(address(this));
+        res = curBalance - lastBalanceOf[token];
+        lastBalanceOf[token] = curBalance;
     }
 
     function _afterSendToken(address token) internal virtual override {

package/contracts/core/PendleSCYImpl/PendleBenQiErc20SCY.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.9;
-pragma abicoder v2;
+
 import "../../SuperComposableYield/implementations/SCYBaseWithRewards.sol";
 import "../../interfaces/IQiErc20.sol";
 import "../../interfaces/IBenQiComptroller.sol";
@@ -15,24 +15,32 @@ contract PendleBenQiErc20SCY is SCYBaseWithRewards {
     address public immutable comptroller;
     address public immutable qiToken;
 
-    uint256 public lastScyIndex;
+    uint256 public override scyIndexStored;
 
     constructor(
         string memory _name,
         string memory _symbol,
         uint8 __scydecimals,
         uint8 __assetDecimals,
+        bytes32 __assetId,
         address _underlying,
         address _qiToken,
         address _comptroller,
         address _QI,
         address _WAVAX
-    ) SCYBaseWithRewards(_name, _symbol, __scydecimals, __assetDecimals) {
-        underlying = _underlying;
+    ) SCYBaseWithRewards(_name, _symbol, __scydecimals, __assetDecimals, __assetId) {
+        require(
+            _qiToken != address(0) &&
+                _QI != address(0) &&
+                _WAVAX != address(0) &&
+                _comptroller != address(0),
+            "zero address"
+        );
         qiToken = _qiToken;
         QI = _QI;
         WAVAX = _WAVAX;
         comptroller = _comptroller;
+        underlying = _underlying;
         IERC20(underlying).safeIncreaseAllowance(qiToken, type(uint256).max);
     }
 
@@ -53,7 +61,8 @@ contract PendleBenQiErc20SCY is SCYBaseWithRewards {
         if (token == qiToken) {
             amountScyOut = amountBase;
         } else {
-            IQiErc20(qiToken).mint(amountBase);
+            uint256 errCode = IQiErc20(qiToken).mint(amountBase);
+            require(errCode == 0, "mint failed");
             _afterSendToken(underlying);
             amountScyOut = _afterReceiveToken(qiToken);
         }
@@ -69,7 +78,8 @@ contract PendleBenQiErc20SCY is SCYBaseWithRewards {
             amountBaseOut = amountScy;
         } else {
             // must be underlying
-            IQiErc20(qiToken).redeem(amountScy);
+            uint256 errCode = IQiErc20(qiToken).redeem(amountScy);
+            require(errCode == 0, "redeem failed");
             _afterSendToken(qiToken);
             amountBaseOut = _afterReceiveToken(underlying);
         }
@@ -79,14 +89,10 @@ contract PendleBenQiErc20SCY is SCYBaseWithRewards {
                                SCY-INDEX
     //////////////////////////////////////////////////////////////*/
 
-    function scyIndexCurrent() public virtual override returns (uint256 res) {
-        res = Math.max(lastScyIndex, IQiToken(qiToken).exchangeRateCurrent());
-        lastScyIndex = res;
-        return res;
-    }
-
-    function scyIndexStored() public view override returns (uint256 res) {
-        res = lastScyIndex;
+    function scyIndexCurrent() public virtual override returns (uint256) {
+        scyIndexStored = IQiToken(qiToken).exchangeRateCurrent();
+        emit UpdateScyIndex(scyIndexStored);
+        return scyIndexStored;
     }
 
     function getRewardTokens() public view override returns (address[] memory res) {
@@ -105,8 +111,8 @@ contract PendleBenQiErc20SCY is SCYBaseWithRewards {
         res[1] = underlying;
     }
 
-    function isValidBaseToken(address token) public view virtual override returns (bool res) {
-        res = (token == underlying || token == qiToken);
+    function isValidBaseToken(address token) public view virtual override returns (bool) {
+        return token == underlying || token == qiToken;
     }
 
     /*///////////////////////////////////////////////////////////////

package/contracts/core/PendleSCYImpl/PendleBtrflySCY.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.9;
-pragma abicoder v2;
+
 import "../../SuperComposableYield/implementations/SCYBase.sol";
 import "../../interfaces/IWXBTRFLY.sol";
 import "../../interfaces/IREDACTEDStaking.sol";
@@ -12,17 +12,19 @@ contract PendleBtrflyScy is SCYBase {
     address public immutable xBTRFLY;
     address public immutable wxBTRFLY;
 
-    uint256 public lastScyIndex;
+    uint256 public override scyIndexStored;
 
     constructor(
         string memory _name,
         string memory _symbol,
         uint8 __scydecimals,
         uint8 __assetDecimals,
+        bytes32 __assetId,
         address _BTRFLY,
         address _xBTRFLY,
         address _wxBTRFLY
-    ) SCYBase(_name, _symbol, __scydecimals, __assetDecimals) {
+    ) SCYBase(_name, _symbol, __scydecimals, __assetDecimals, __assetId) {
+        require(_wxBTRFLY != address(0), "zero address");
         BTRFLY = _BTRFLY;
         xBTRFLY = _xBTRFLY;
         wxBTRFLY = _wxBTRFLY;
@@ -42,9 +44,11 @@ contract PendleBtrflyScy is SCYBase {
         if (token == BTRFLY) {
             amountScyOut = IWXBTRFLY(wxBTRFLY).wrapFromBTRFLY(amountBase);
             _afterSendToken(BTRFLY);
+            _afterReceiveToken(wxBTRFLY);
         } else if (token == xBTRFLY) {
             amountScyOut = IWXBTRFLY(wxBTRFLY).wrapFromxBTRFLY(amountBase);
             _afterSendToken(xBTRFLY);
+            _afterReceiveToken(wxBTRFLY);
         } else {
             // 1 wxBTRFLY = 1 SCY
             amountScyOut = amountBase;
@@ -73,14 +77,10 @@ contract PendleBtrflyScy is SCYBase {
                                SCY-INDEX
     //////////////////////////////////////////////////////////////*/
 
-    function scyIndexCurrent() public virtual override returns (uint256 res) {
-        res = Math.max(lastScyIndex, IWXBTRFLY(wxBTRFLY).xBTRFLYValue(Math.ONE));
-        lastScyIndex = res;
-        return res;
-    }
-
-    function scyIndexStored() public view override returns (uint256 res) {
-        res = lastScyIndex;
+    function scyIndexCurrent() public virtual override returns (uint256) {
+        scyIndexStored = IWXBTRFLY(wxBTRFLY).xBTRFLYValue(Math.ONE);
+        emit UpdateScyIndex(scyIndexStored);
+        return scyIndexStored;
     }
 
     /*///////////////////////////////////////////////////////////////
@@ -94,8 +94,8 @@ contract PendleBtrflyScy is SCYBase {
         res[2] = wxBTRFLY;
     }
 
-    function isValidBaseToken(address token) public view virtual override returns (bool res) {
-        res = (token == BTRFLY || token == xBTRFLY || token == wxBTRFLY);
+    function isValidBaseToken(address token) public view virtual override returns (bool) {
+        return token == BTRFLY || token == xBTRFLY || token == wxBTRFLY;
     }
 
     /*///////////////////////////////////////////////////////////////

package/contracts/core/PendleSCYImpl/PendleStETHSCY.sol

@@ -0,0 +1,107 @@
+// 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,6 +1,6 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.9;
-pragma abicoder v2;
+
 import "../../SuperComposableYield/implementations/SCYBase.sol";
 import "../../interfaces/IYearnVault.sol";
 
@@ -10,16 +10,18 @@ contract PendleYearnVaultScy is SCYBase {
     address public immutable underlying;
     address public immutable yvToken;
 
-    uint256 public lastScyIndex;
+    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) {
+    ) SCYBase(_name, _symbol, __scydecimals, __assetDecimals, __assetId) {
+        require(_yvToken != address(0), "zero address");
         yvToken = _yvToken;
         underlying = _underlying;
         IERC20(underlying).safeIncreaseAllowance(yvToken, type(uint256).max);
@@ -39,7 +41,7 @@ contract PendleYearnVaultScy is SCYBase {
             amountScyOut = amountBase;
         } else {
             // must be underlying
-            IYearnVault(yvToken).deposit(amountBase);
+            IYearnVault(yvToken).deposit(amountBase); // ignore return
             _afterSendToken(underlying);
             amountScyOut = _afterReceiveToken(yvToken);
         }
@@ -55,7 +57,7 @@ contract PendleYearnVaultScy is SCYBase {
             amountBaseOut = amountScy;
         } else {
             // must be underlying
-            IYearnVault(yvToken).withdraw(amountScy);
+            IYearnVault(yvToken).withdraw(amountScy); // ignore return
             _afterSendToken(yvToken);
             amountBaseOut = _afterReceiveToken(underlying);
         }
@@ -66,13 +68,9 @@ contract PendleYearnVaultScy is SCYBase {
     //////////////////////////////////////////////////////////////*/
 
     function scyIndexCurrent() public virtual override returns (uint256 res) {
-        res = Math.max(lastScyIndex, IYearnVault(yvToken).pricePerShare());
-        lastScyIndex = res;
-        return res;
-    }
-
-    function scyIndexStored() public view override returns (uint256 res) {
-        res = lastScyIndex;
+        scyIndexStored = IYearnVault(yvToken).pricePerShare();
+        emit UpdateScyIndex(scyIndexStored);
+        return scyIndexStored;
     }
 
     /*///////////////////////////////////////////////////////////////
@@ -80,12 +78,13 @@ contract PendleYearnVaultScy is SCYBase {
     //////////////////////////////////////////////////////////////*/
 
     function getBaseTokens() public view virtual override returns (address[] memory res) {
-        res = new address[](1);
+        res = new address[](2);
         res[0] = underlying;
+        res[1] = yvToken;
     }
 
-    function isValidBaseToken(address token) public view virtual override returns (bool res) {
-        res = (token == underlying);
+    function isValidBaseToken(address token) public view virtual override returns (bool) {
+        return token == underlying || token == yvToken;
     }
 
     /*///////////////////////////////////////////////////////////////

package/contracts/core/PendleYieldContractFactory.sol

@@ -29,13 +29,13 @@ import "../libraries/helpers/ExpiryUtilsLib.sol";
 import "../periphery/PermissionsV2Upg.sol";
 import "../interfaces/IPYieldContractFactory.sol";
 
-import "./PendleOwnershipToken.sol";
+import "./PendlePrincipalToken.sol";
 import "./PendleYieldToken.sol";
 
 contract PendleYieldContractFactory is PermissionsV2Upg, IPYieldContractFactory {
     using ExpiryUtils for string;
 
-    string public constant OT_PREFIX = "OT";
+    string public constant PT_PREFIX = "PT";
     string public constant YT_PREFIX = "YT";
 
     uint256 public expiryDivisor;
@@ -43,9 +43,9 @@ contract PendleYieldContractFactory is PermissionsV2Upg, IPYieldContractFactory
     address public treasury;
 
     // SCY => expiry => address
-    mapping(address => mapping(uint256 => address)) public getOT;
+    mapping(address => mapping(uint256 => address)) public getPT;
     mapping(address => mapping(uint256 => address)) public getYT;
-    mapping(address => bool) public isOT;
+    mapping(address => bool) public isPT;
     mapping(address => bool) public isYT;
 
     constructor(
@@ -54,28 +54,36 @@ contract PendleYieldContractFactory is PermissionsV2Upg, IPYieldContractFactory
         address _treasury,
         address _governanceManager
     ) PermissionsV2Upg(_governanceManager) {
+        require(_expiryDivisor != 0, "zero value");
+        require(_treasury != address(0), "zero address");
+
         expiryDivisor = _expiryDivisor;
         interestFeeRate = _interestFeeRate;
         treasury = _treasury;
     }
 
+    /**
+     * @notice Create a pair of (PT, YT) from any SCY and valid expiry. Anyone can create a yield contract
+     */
     function createYieldContract(address SCY, uint256 expiry)
         external
-        returns (address OT, address YT)
+        returns (address PT, address YT)
     {
+        require(expiry > block.timestamp, "invalid expiry");
+
         require(expiry % expiryDivisor == 0, "must be multiple of divisor");
 
-        require(getOT[SCY][expiry] == address(0), "OT_EXISTED");
+        require(getPT[SCY][expiry] == address(0), "PT_EXISTED");
 
         ISuperComposableYield _SCY = ISuperComposableYield(SCY);
 
         uint8 assetDecimals = _SCY.assetDecimals();
 
-        OT = address(
-            new PendleOwnershipToken(
+        PT = address(
+            new PendlePrincipalToken(
                 SCY,
-                OT_PREFIX.concat(_SCY.name(), expiry, " "),
-                OT_PREFIX.concat(_SCY.symbol(), expiry, "-"),
+                PT_PREFIX.concat(_SCY.name(), expiry, " "),
+                PT_PREFIX.concat(_SCY.symbol(), expiry, "-"),
                 assetDecimals,
                 expiry
             )
@@ -84,7 +92,7 @@ contract PendleYieldContractFactory is PermissionsV2Upg, IPYieldContractFactory
         YT = address(
             new PendleYieldToken(
                 SCY,
-                OT,
+                PT,
                 YT_PREFIX.concat(_SCY.name(), expiry, " "),
                 YT_PREFIX.concat(_SCY.symbol(), expiry, "-"),
                 assetDecimals,
@@ -92,23 +100,30 @@ contract PendleYieldContractFactory is PermissionsV2Upg, IPYieldContractFactory
             )
         );
 
-        IPOwnershipToken(OT).initialize(YT);
+        IPPrincipalToken(PT).initialize(YT);
 
-        getOT[SCY][expiry] = OT;
+        getPT[SCY][expiry] = PT;
         getYT[SCY][expiry] = YT;
-        isOT[OT] = true;
+        isPT[PT] = true;
         isYT[YT] = true;
+
+        emit CreateYieldContract(SCY, PT, YT, expiry);
     }
 
     function setExpiryDivisor(uint256 newExpiryDivisor) external onlyGovernance {
+        require(newExpiryDivisor != 0, "zero value");
         expiryDivisor = newExpiryDivisor;
+        emit SetExpiryDivisor(newExpiryDivisor);
     }
 
     function setInterestFeeRate(uint256 newInterestFeeRate) external onlyGovernance {
         interestFeeRate = newInterestFeeRate;
+        emit SetInterestFeeRate(newInterestFeeRate);
     }
 
     function setTreasury(address newTreasury) external onlyGovernance {
+        require(newTreasury != address(0), "zero address");
         treasury = newTreasury;
+        emit SetTreasury(treasury);
     }
 }