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

package/contracts/SuperComposableYield/ISuperComposableYield.sol

@@ -75,4 +75,6 @@ interface ISuperComposableYield is IERC20Metadata {
     function getRewardTokens() external view returns (address[] memory);
 
     function assetDecimals() external view returns (uint8);
+
+    function assetId() external view returns (bytes32);
 }

package/contracts/SuperComposableYield/implementations/RewardManager.sol

@@ -19,6 +19,8 @@ abstract contract RewardManager is IRewardManager {
         uint256 accruedReward;
     }
 
+    uint256 public lastRewardUpdateBlock;
+
     uint256 internal constant INITIAL_REWARD_INDEX = 1;
 
     mapping(address => GlobalReward) internal globalReward;
@@ -66,22 +68,18 @@ abstract contract RewardManager is IRewardManager {
         }
     }
 
-    function _updateUserReward(
-        address user,
-        uint256 balanceOfUser,
-        uint256 totalSupply
-    ) internal virtual {
-        address[] memory rewardTokens = getRewardTokens();
-        _updateGlobalReward(rewardTokens, totalSupply);
-        _updateUserRewardSkipGlobal(rewardTokens, user, balanceOfUser);
+    function _updateUserReward(address user) internal virtual {
+        _updateGlobalReward();
+        _updateUserRewardSkipGlobal(user);
     }
 
-    function _updateGlobalReward(address[] memory rewardTokens, uint256 totalSupply)
-        internal
-        virtual
-    {
+    function _updateGlobalReward() internal virtual {
+        if (!_shouldUpdateGlobalReward()) return;
         _redeemExternalReward();
 
+        uint256 totalShares = _rewardSharesTotal();
+
+        address[] memory rewardTokens = getRewardTokens();
         _initGlobalReward(rewardTokens);
 
         for (uint256 i = 0; i < rewardTokens.length; ++i) {
@@ -89,20 +87,20 @@ abstract contract RewardManager is IRewardManager {
 
             uint256 currentRewardBalance = IERC20(token).balanceOf(address(this));
 
-            if (totalSupply != 0) {
+            if (totalShares != 0) {
                 globalReward[token].index += (currentRewardBalance -
-                    globalReward[token].lastBalance).divDown(totalSupply);
+                    globalReward[token].lastBalance).divDown(totalShares);
             }
 
             globalReward[token].lastBalance = currentRewardBalance;
         }
     }
 
-    function _updateUserRewardSkipGlobal(
-        address[] memory rewardTokens,
-        address user,
-        uint256 balanceOfUser
-    ) internal virtual {
+    function _updateUserRewardSkipGlobal(address user) internal virtual {
+        address[] memory rewardTokens = getRewardTokens();
+
+        uint256 userShares = _rewardSharesUser(user);
+
         for (uint256 i = 0; i < rewardTokens.length; ++i) {
             address token = rewardTokens[i];
 
@@ -117,7 +115,7 @@ abstract contract RewardManager is IRewardManager {
             }
 
             uint256 rewardAmountPerUnit = globalReward[token].index - userLastIndex;
-            uint256 rewardFromUnit = balanceOfUser.mulDown(rewardAmountPerUnit);
+            uint256 rewardFromUnit = userShares.mulDown(rewardAmountPerUnit);
 
             userReward[user][token].accruedReward += rewardFromUnit;
             userReward[user][token].lastIndex = globalReward[token].index;
@@ -132,5 +130,22 @@ abstract contract RewardManager is IRewardManager {
         }
     }
 
+    function _shouldUpdateGlobalReward() internal virtual returns (bool) {
+        if (lastRewardUpdateBlock == block.number) {
+            return false;
+        }
+        lastRewardUpdateBlock = block.number;
+        return true;
+    }
+
+    /// @dev to be overriden if there is rewards
     function _redeemExternalReward() internal virtual;
+
+    /// @dev to be overriden if there is rewards
+    function _rewardSharesTotal() internal virtual returns (uint256);
+
+    /// @dev to be overriden if there is rewards
+    function _rewardSharesUser(
+        address /*user*/
+    ) internal virtual returns (uint256);
 }

package/contracts/SuperComposableYield/implementations/SCYBase.sol

@@ -4,21 +4,19 @@ import "../ISuperComposableYield.sol";
 import "./RewardManager.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
 import "../../libraries/math/Math.sol";
 import "../SCYUtils.sol";
 
-/**
-# CONDITIONS TO USE THIS PRESET:
-- the token's balance must be static (i.e not increase on its own). Some examples of tokens don't
-satisfy this restriction is AaveV2's aToken
-
-*/
-abstract contract SCYBase is ERC20, ISuperComposableYield {
+abstract contract SCYBase is ERC20, ISuperComposableYield, ReentrancyGuard {
     using SafeERC20 for IERC20;
     using Math for uint256;
 
+    event UpdateScyIndex(uint256 scyIndex);
+
     uint8 private immutable _scyDecimals;
     uint8 private immutable _assetDecimals;
+    bytes32 private immutable _assetId;
 
     mapping(address => uint256) internal lastBalanceOf;
 
@@ -26,10 +24,12 @@ abstract contract SCYBase is ERC20, ISuperComposableYield {
         string memory _name,
         string memory _symbol,
         uint8 __scyDecimals,
-        uint8 __assetDecimals
+        uint8 __assetDecimals,
+        bytes32 __assetId
     ) ERC20(_name, _symbol) {
         _scyDecimals = __scyDecimals;
         _assetDecimals = __assetDecimals;
+        _assetId = __assetId;
     }
 
     /*///////////////////////////////////////////////////////////////
@@ -41,9 +41,9 @@ abstract contract SCYBase is ERC20, ISuperComposableYield {
         address baseTokenIn,
         uint256 amountBaseToPull,
         uint256 minAmountScyOut
-    ) external returns (uint256 amountScyOut) {
+    ) external nonReentrant returns (uint256 amountScyOut) {
         IERC20(baseTokenIn).safeTransferFrom(msg.sender, address(this), amountBaseToPull);
-        amountScyOut = mintNoPull(receiver, baseTokenIn, minAmountScyOut);
+        amountScyOut = _mintFresh(receiver, baseTokenIn, minAmountScyOut);
     }
 
     function redeem(
@@ -51,16 +51,32 @@ abstract contract SCYBase is ERC20, ISuperComposableYield {
         address baseTokenOut,
         uint256 amountScyToPull,
         uint256 minAmountBaseOut
-    ) external returns (uint256 amountBaseOut) {
+    ) external nonReentrant returns (uint256 amountBaseOut) {
         transferFrom(msg.sender, address(this), amountScyToPull);
-        amountBaseOut = redeemNoPull(receiver, baseTokenOut, minAmountBaseOut);
+        amountBaseOut = _redeemFresh(receiver, baseTokenOut, minAmountBaseOut);
     }
 
     function mintNoPull(
         address receiver,
         address baseTokenIn,
         uint256 minAmountScyOut
-    ) public virtual override returns (uint256 amountScyOut) {
+    ) external virtual override nonReentrant returns (uint256) {
+        return _mintFresh(receiver, baseTokenIn, minAmountScyOut);
+    }
+
+    function redeemNoPull(
+        address receiver,
+        address baseTokenOut,
+        uint256 minAmountBaseOut
+    ) external virtual override nonReentrant returns (uint256) {
+        return _redeemFresh(receiver, baseTokenOut, minAmountBaseOut);
+    }
+
+    function _mintFresh(
+        address receiver,
+        address baseTokenIn,
+        uint256 minAmountScyOut
+    ) internal virtual returns (uint256 amountScyOut) {
         require(isValidBaseToken(baseTokenIn), "invalid base token");
 
         uint256 amountBaseIn = _afterReceiveToken(baseTokenIn);
@@ -72,11 +88,11 @@ abstract contract SCYBase is ERC20, ISuperComposableYield {
         _mint(receiver, amountScyOut);
     }
 
-    function redeemNoPull(
+    function _redeemFresh(
         address receiver,
         address baseTokenOut,
         uint256 minAmountBaseOut
-    ) public virtual override returns (uint256 amountBaseOut) {
+    ) internal virtual returns (uint256 amountBaseOut) {
         require(isValidBaseToken(baseTokenOut), "invalid base token");
 
         uint256 amountScyRedeem = balanceOf(address(this));
@@ -105,9 +121,9 @@ abstract contract SCYBase is ERC20, ISuperComposableYield {
                                SCY-INDEX
     //////////////////////////////////////////////////////////////*/
 
-    function scyIndexCurrent() public virtual override returns (uint256 res);
+    function scyIndexCurrent() external virtual override returns (uint256 res);
 
-    function scyIndexStored() public view virtual override returns (uint256 res);
+    function scyIndexStored() external view virtual override returns (uint256 res);
 
     /*///////////////////////////////////////////////////////////////
                 MISC METADATA FUNCTIONS
@@ -117,11 +133,15 @@ abstract contract SCYBase is ERC20, ISuperComposableYield {
         return _scyDecimals;
     }
 
-    function assetDecimals() public view virtual returns (uint8) {
+    function assetDecimals() external view virtual returns (uint8) {
         return _assetDecimals;
     }
 
-    function getBaseTokens() public view virtual override returns (address[] memory res);
+    function assetId() external view returns (bytes32) {
+        return _assetId;
+    }
+
+    function getBaseTokens() external view virtual override returns (address[] memory res);
 
     function isValidBaseToken(address token) public view virtual override returns (bool);
 

package/contracts/SuperComposableYield/implementations/SCYBaseWithRewards.sol

@@ -17,14 +17,16 @@ abstract contract SCYBaseWithRewards is SCYBase, RewardManager {
     using SafeERC20 for IERC20;
     using Math for uint256;
 
+    event RedeemReward(address indexed user, uint256[] rewardsOut);
+
     constructor(
         string memory _name,
         string memory _symbol,
         uint8 __scydecimals,
-        uint8 __assetDecimals
+        uint8 __assetDecimals,
+        bytes32 __assetId
     )
-        SCYBase(_name, _symbol, __scydecimals, __assetDecimals)
-        RewardManager()
+        SCYBase(_name, _symbol, __scydecimals, __assetDecimals, __assetId)
     // solhint-disable-next-line no-empty-blocks
     {
 
@@ -35,22 +37,23 @@ abstract contract SCYBaseWithRewards is SCYBase, RewardManager {
     //////////////////////////////////////////////////////////////*/
 
     function redeemReward(address user)
-        public
+        external
         virtual
         override
+        nonReentrant
         returns (uint256[] memory outAmounts)
     {
-        _updateUserReward(user, balanceOf(user), totalSupply());
+        _updateUserReward(user);
         outAmounts = _doTransferOutRewardsForUser(user, user);
+        emit RedeemReward(user, outAmounts);
     }
 
-    function updateGlobalReward() public virtual override {
-        address[] memory rewardTokens = getRewardTokens();
-        _updateGlobalReward(rewardTokens, totalSupply());
+    function updateGlobalReward() external virtual override nonReentrant {
+        _updateGlobalReward();
     }
 
-    function updateUserReward(address user) public virtual override {
-        _updateUserReward(user, balanceOf(user), totalSupply());
+    function updateUserReward(address user) external virtual override nonReentrant {
+        _updateUserReward(user);
     }
 
     function getRewardTokens()
@@ -68,9 +71,18 @@ abstract contract SCYBaseWithRewards is SCYBase, RewardManager {
         address to,
         uint256 /*amount*/
     ) internal virtual override {
-        address[] memory rewardTokens = getRewardTokens();
-        _updateGlobalReward(rewardTokens, totalSupply());
-        if (from != address(0)) _updateUserRewardSkipGlobal(rewardTokens, from, balanceOf(from));
-        if (to != address(0)) _updateUserRewardSkipGlobal(rewardTokens, to, balanceOf(to));
+        _updateGlobalReward();
+        if (from != address(0)) _updateUserRewardSkipGlobal(from);
+        if (to != address(0)) _updateUserRewardSkipGlobal(to);
+    }
+
+    /// @dev to be overriden if there is rewards
+    function _rewardSharesTotal() internal virtual override returns (uint256) {
+        return totalSupply();
+    }
+
+    /// @dev to be overriden if there is rewards
+    function _rewardSharesUser(address user) internal virtual override returns (uint256) {
+        return balanceOf(user);
     }
 }

package/contracts/core/PendleBaseToken.sol

@@ -29,7 +29,7 @@ abstract contract PendleBaseToken is ERC20, IPBaseToken {
         return _decimals;
     }
 
-    function isExpired() public view virtual returns (bool res) {
-        res = (block.timestamp >= expiry);
+    function isExpired() public view virtual returns (bool) {
+        return block.timestamp >= expiry;
     }
 }