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

package/contracts/core/PendleYieldToken.sol

@@ -4,22 +4,23 @@ pragma solidity 0.8.9;
 import "./PendleBaseToken.sol";
 import "../SuperComposableYield/ISuperComposableYield.sol";
 import "../interfaces/IPYieldToken.sol";
-import "../interfaces/IPOwnershipToken.sol";
+import "../interfaces/IPPrincipalToken.sol";
 import "../libraries/math/Math.sol";
 import "../interfaces/IPYieldContractFactory.sol";
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.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 redeemYO.
+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 {
+contract PendleYieldToken is PendleBaseToken, RewardManager, IPYieldToken, ReentrancyGuard {
     using Math for uint256;
     using SafeERC20 for IERC20;
 
@@ -29,113 +30,145 @@ contract PendleYieldToken is PendleBaseToken, RewardManager, IPYieldToken {
     }
 
     address public immutable SCY;
-    address public immutable OT;
+    address public immutable PT;
 
     /// 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 totalInterestPostExpiry;
     uint256 public totalProtocolFee;
 
     mapping(address => InterestData) internal interestData;
 
     constructor(
         address _SCY,
-        address _OT,
+        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;
-        OT = _OT;
+        PT = _PT;
     }
 
     /**
-     * @notice this function splits scy into OT + YT of equal qty
+     * @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 mintYO(address receiverOT, address receiverYT) public returns (uint256 amountYOOut) {
+    function mintPY(address receiverPT, address receiverYT)
+        external
+        nonReentrant
+        returns (uint256 amountPYOut)
+    {
         uint256 amountToTokenize = _receiveSCY();
 
-        amountYOOut = _calcAmountToMint(amountToTokenize);
+        amountPYOut = _calcAmountToMint(amountToTokenize);
 
-        _mint(receiverYT, amountYOOut);
+        _mint(receiverYT, amountPYOut);
 
-        IPOwnershipToken(OT).mintByYT(receiverOT, amountYOOut);
+        IPPrincipalToken(PT).mintByYT(receiverPT, amountPYOut);
     }
 
-    /// 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));
+    /// @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()) {
-            amountYOToRedeem = Math.min(amountYOToRedeem, balanceOf(address(this)));
-            _burn(address(this), amountYOToRedeem);
+            amountPYToRedeem = Math.min(amountPYToRedeem, balanceOf(address(this)));
+            _burn(address(this), amountPYToRedeem);
         }
-        IPOwnershipToken(OT).burnByYT(address(this), amountYOToRedeem);
 
-        amountScyOut = _calcAmountRedeemable(amountYOToRedeem);
+        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)
-        public
+        external
+        nonReentrant
         returns (uint256 interestOut, uint256[] memory rewardsOut)
     {
         // redeemDueRewards before redeemDueInterest
-        updateUserReward(user);
-        updateUserInterest(user);
+        _updateUserReward(user);
+        _updateUserInterest(user);
         rewardsOut = _doTransferOutRewardsForUser(user, user);
         interestOut = _doTransferOutDueInterest(user);
+
+        emit RedeemReward(user, rewardsOut);
+        emit RedeemInterest(user, interestOut);
     }
 
-    function redeemDueInterest(address user) public returns (uint256 interestOut) {
-        updateUserReward(user); /// strictly required, see above for explanation
-        updateUserInterest(user);
+    /**
+     * @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) public returns (uint256[] memory rewardsOut) {
-        updateUserReward(user);
+    function redeemDueRewards(address user)
+        external
+        nonReentrant
+        returns (uint256[] memory rewardsOut)
+    {
+        _updateUserReward(user);
+
         rewardsOut = _doTransferOutRewardsForUser(user, user);
+        emit RedeemReward(user, rewardsOut);
     }
 
-    function updateGlobalReward() external {
-        address[] memory rewardTokens = getRewardTokens();
-        _updateGlobalReward(rewardTokens, IERC20(SCY).balanceOf(address(this)));
+    /**
+     * @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 updateUserReward(address user) public {
-        uint256 impliedScyBalance = getImpliedScyBalance(user);
-        uint256 totalScy = IERC20(SCY).balanceOf(address(this));
-        _updateUserReward(user, impliedScyBalance, totalScy);
+    function updateUserInterest(address user) external nonReentrant {
+        _updateUserInterest(user);
     }
 
-    function updateUserInterest(address user) public {
+    function _updateUserInterest(address user) internal {
         uint256 prevIndex = interestData[user].lastScyIndex;
 
-        uint256 currentIndex = getScyIndexBeforeExpiry();
+        (, uint256 currentIndexBeforeExpiry) = getScyIndex();
 
-        if (prevIndex == currentIndex) return;
+        if (prevIndex == currentIndexBeforeExpiry) return;
         if (prevIndex == 0) {
-            interestData[user].lastScyIndex = currentIndex;
+            interestData[user].lastScyIndex = currentIndexBeforeExpiry;
             return;
         }
 
         uint256 principal = balanceOf(user);
 
-        uint256 interestFromYT = (principal * (currentIndex - prevIndex)).divDown(
-            prevIndex * currentIndex
+        uint256 interestFromYT = (principal * (currentIndexBeforeExpiry - prevIndex)).divDown(
+            prevIndex * currentIndexBeforeExpiry
         );
 
         interestData[user].dueInterest += interestFromYT;
-        interestData[user].lastScyIndex = currentIndex;
+        interestData[user].lastScyIndex = currentIndexBeforeExpiry;
     }
 
     function getInterestData(address user)
@@ -146,13 +179,15 @@ contract PendleYieldToken is PendleBaseToken, RewardManager, IPYieldToken {
         return (interestData[user].lastScyIndex, interestData[user].dueInterest);
     }
 
-    function _updateGlobalReward(address[] memory rewardTokens, uint256 totalSupply)
-        internal
-        virtual
-        override
-    {
+    /// @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();
@@ -164,8 +199,8 @@ contract PendleYieldToken is PendleBaseToken, RewardManager, IPYieldToken {
 
             if (_isExpired) {
                 totalRewardsPostExpiry[token] += totalIncomeReward;
-            } else if (totalSupply != 0) {
-                globalReward[token].index += totalIncomeReward.divDown(totalSupply);
+            } else if (totalShares != 0) {
+                globalReward[token].index += totalIncomeReward.divDown(totalShares);
             }
 
             globalReward[token].lastBalance = currentRewardBalance;
@@ -186,7 +221,17 @@ contract PendleYieldToken is PendleBaseToken, RewardManager, IPYieldToken {
     }
 
     function _redeemExternalReward() internal virtual override {
-        ISuperComposableYield(SCY).redeemReward(address(this));
+        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()
@@ -199,48 +244,63 @@ contract PendleYieldToken is PendleBaseToken, RewardManager, IPYieldToken {
         return ISuperComposableYield(SCY).getRewardTokens();
     }
 
-    function getScyIndexBeforeExpiry() public returns (uint256 res) {
-        if (isExpired()) return res = lastScyIndexBeforeExpiry;
-        res = ISuperComposableYield(SCY).scyIndexCurrent();
-        lastScyIndexBeforeExpiry = res;
+    function getScyIndex() public returns (uint256 currentIndex, uint256 lastIndexBeforeExpiry) {
+        currentIndex = ISuperComposableYield(SCY).scyIndexCurrent();
+        if (isExpired()) {
+            lastIndexBeforeExpiry = lastScyIndexBeforeExpiry;
+        } else {
+            lastScyIndexBeforeExpiry = lastIndexBeforeExpiry = currentIndex;
+        }
     }
 
     /**
-     * In case the pool is expired and there is left some SCY not yet redeemed from the contract, the rewards should
+     * @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.
      *
-     * And since the reward distribution (which based on users' dueInterest) stopped at the scyIndexBeforeExpiry, it is not
-     * necessary to updateDueInterest along with reward here.
+     * @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(rewardTokens, IERC20(SCY).balanceOf(address(this))); // as refered to the doc above
+            _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;
         }
 
-        if (totalProtocolFee > 0) {
-            IERC20(SCY).safeTransfer(treasury, totalProtocolFee);
+        uint256 totalScyFee = totalProtocolFee + totalInterestPostExpiry;
+        totalProtocolFee = totalInterestPostExpiry = 0;
+
+        if (totalScyFee > 0) {
+            IERC20(SCY).safeTransfer(treasury, totalScyFee);
             _afterTransferOutSCY();
-            totalProtocolFee = 0;
         }
+        emit WithdrawFeeToTreasury(amountRewardsOut, totalScyFee);
     }
 
     function _calcAmountToMint(uint256 amount) internal returns (uint256) {
-        return SCYUtils.scyToAsset(getScyIndexBeforeExpiry(), amount);
+        (, uint256 lastIndexBeforeExpiry) = getScyIndex();
+        return SCYUtils.scyToAsset(lastIndexBeforeExpiry, amount);
     }
 
-    function _calcAmountRedeemable(uint256 amount) internal returns (uint256) {
-        return SCYUtils.assetToScy(getScyIndexBeforeExpiry(), 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) {
@@ -256,7 +316,6 @@ contract PendleYieldToken is PendleBaseToken, RewardManager, IPYieldToken {
 
     function getImpliedScyBalance(address user) public view returns (uint256) {
         uint256 scyIndex = interestData[user].lastScyIndex;
-        if (scyIndex == 0) return 0;
         return SCYUtils.assetToScy(scyIndex, balanceOf(user)) + interestData[user].dueInterest;
     }
 
@@ -265,22 +324,17 @@ contract PendleYieldToken is PendleBaseToken, RewardManager, IPYieldToken {
         address to,
         uint256
     ) internal override {
-        address[] memory rewardTokens = getRewardTokens();
-        _updateGlobalReward(rewardTokens, IERC20(SCY).balanceOf(address(this)));
+        _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(rewardTokens, from, getImpliedScyBalance(from));
+            _updateUserInterest(from);
+            _updateUserRewardSkipGlobal(from);
         }
         if (to != address(0) && to != address(this)) {
-            updateUserInterest(to);
-            _updateUserRewardSkipGlobal(rewardTokens, to, getImpliedScyBalance(to));
+            _updateUserInterest(to);
+            _updateUserRewardSkipGlobal(to);
         }
     }
 }
-/*INVARIANTS TO CHECK
-- supply OT == supply YT
-- reentrancy check
-*/

package/contracts/core/RouterStatic.sol

@@ -1,8 +1,6 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.9;
 
-import "../SuperComposableYield/ISuperComposableYield.sol";
-import "../SuperComposableYield/implementations/IRewardManager.sol";
 import "../interfaces/IPRouterStatic.sol";
 import "../interfaces/IPMarket.sol";
 import "../interfaces/IPYieldContractFactory.sol";
@@ -29,20 +27,20 @@ contract RouterStatic is IPRouterStatic {
     function addLiquidityStatic(
         address market,
         uint256 scyDesired,
-        uint256 otDesired
+        uint256 ptDesired
     )
         external
         returns (
             uint256 netLpOut,
             uint256 scyUsed,
-            uint256 otUsed
+            uint256 ptUsed
         )
     {
         MarketState memory state = IPMarket(market).readState(false);
-        (, netLpOut, scyUsed, otUsed) = state.addLiquidity(
+        (, netLpOut, scyUsed, ptUsed) = state.addLiquidity(
             scyIndex(market),
             scyDesired,
-            otDesired,
+            ptDesired,
             false
         );
     }
@@ -50,33 +48,33 @@ contract RouterStatic is IPRouterStatic {
     function removeLiquidityStatic(address market, uint256 lpToRemove)
         external
         view
-        returns (uint256 netScyOut, uint256 netOtOut)
+        returns (uint256 netScyOut, uint256 netPtOut)
     {
         MarketState memory state = IPMarket(market).readState(false);
-        (netScyOut, netOtOut) = state.removeLiquidity(lpToRemove, false);
+        (netScyOut, netPtOut) = state.removeLiquidity(lpToRemove, false);
     }
 
-    function swapOtForScyStatic(address market, uint256 exactOtIn)
+    function swapPtForScyStatic(address market, uint256 exactPtIn)
         external
         returns (uint256 netScyOut, uint256 netScyFee)
     {
         MarketState memory state = IPMarket(market).readState(false);
-        (netScyOut, netScyFee) = state.swapExactOtForScy(
+        (netScyOut, netScyFee) = state.swapExactPtForScy(
             scyIndex(market),
-            exactOtIn,
+            exactPtIn,
             block.timestamp,
             false
         );
     }
 
-    function swapScyForOtStatic(address market, uint256 exactOtOut)
+    function swapScyForPtStatic(address market, uint256 exactPtOut)
         external
         returns (uint256 netScyIn, uint256 netScyFee)
     {
         MarketState memory state = IPMarket(market).readState(false);
-        (netScyIn, netScyFee) = state.swapScyForExactOt(
+        (netScyIn, netScyFee) = state.swapScyForExactPt(
             scyIndex(market),
-            exactOtOut,
+            exactPtOut,
             block.timestamp,
             false
         );
@@ -86,10 +84,10 @@ contract RouterStatic is IPRouterStatic {
         return SCYIndexLib.newIndex(IPMarket(market).SCY());
     }
 
-    function getOtImpliedYield(address market) public view returns (int256) {
+    function getPtImpliedYield(address market) external view returns (int256) {
         MarketState memory state = IPMarket(market).readState(false);
 
-        int256 lnImpliedRate = (state.lastImpliedRate).Int();
+        int256 lnImpliedRate = (state.lastLnImpliedRate).Int();
         return lnImpliedRate.exp();
     }
 
@@ -97,152 +95,13 @@ contract RouterStatic is IPRouterStatic {
         external
         view
         returns (
-            bool isOT,
+            bool isPT,
             bool isYT,
             bool isMarket
         )
     {
-        if (yieldContractFactory.isOT(token)) isOT = true;
+        if (yieldContractFactory.isPT(token)) isPT = true;
         else if (yieldContractFactory.isYT(token)) isYT = true;
         else if (marketFactory.isValidMarket(token)) isMarket = true;
     }
-
-    function getUserYOInfo(address yo, address user)
-        public
-        view
-        returns (UserYOInfo memory userYOInfo)
-    {
-        (userYOInfo.yt, userYOInfo.ot) = getYO(yo);
-        IPYieldToken YT = IPYieldToken(userYOInfo.yt);
-        userYOInfo.ytBalance = YT.balanceOf(user);
-        userYOInfo.otBalance = IPOwnershipToken(userYOInfo.ot).balanceOf(user);
-        userYOInfo.unclaimedInterest.token = YT.SCY();
-        (, userYOInfo.unclaimedInterest.amount) = YT.getInterestData(user);
-        address[] memory rewardTokens = YT.getRewardTokens();
-        TokenAmount[] memory unclaimedRewards = new TokenAmount[](rewardTokens.length);
-        uint256 length = 0;
-        for (uint256 i = 0; i < rewardTokens.length; ++i) {
-            address rewardToken = rewardTokens[i];
-            (, uint256 amount) = YT.getUserReward(user, rewardToken);
-            if (amount > 0) {
-                unclaimedRewards[length].token = rewardToken;
-                unclaimedRewards[length].amount = amount;
-                ++length;
-            }
-        }
-        userYOInfo.unclaimedRewards = new TokenAmount[](length);
-        for (uint256 i = 0; i < length; ++i) {
-            userYOInfo.unclaimedRewards[i] = unclaimedRewards[i];
-        }
-    }
-
-    function getYOInfo(address yo)
-        external
-        returns (
-            uint256 exchangeRate,
-            uint256 totalSupply,
-            RewardIndex[] memory rewardIndexes
-        )
-    {
-        (address yt, ) = getYO(yo);
-        IPYieldToken YT = IPYieldToken(yt);
-        exchangeRate = YT.getScyIndexBeforeExpiry();
-        totalSupply = YT.totalSupply();
-        address[] memory rewardTokens = YT.getRewardTokens();
-        rewardIndexes = new RewardIndex[](rewardTokens.length);
-        for (uint256 i = 0; i < rewardTokens.length; ++i) {
-            address rewardToken = rewardTokens[i];
-            rewardIndexes[i].rewardToken = rewardToken;
-            (, rewardIndexes[i].index) = YT.getGlobalReward(rewardToken);
-        }
-    }
-
-    function getYO(address yo) public view returns (address ot, address yt) {
-        if (yieldContractFactory.isYT(yo)) {
-            yt = yo;
-            ot = IPYieldToken(yo).OT();
-        } else {
-            yt = IPOwnershipToken(yo).YT();
-            ot = yo;
-        }
-    }
-
-    function getMarketInfo(address market)
-        external
-        view
-        returns (
-            address ot,
-            address scy,
-            MarketState memory state,
-            int256 impliedYield,
-            uint256 exchangeRate
-        )
-    {
-        IPMarket _market = IPMarket(market);
-        ot = _market.OT();
-        scy = _market.SCY();
-        state = _market.readState(true);
-        impliedYield = getOtImpliedYield(market);
-        exchangeRate = 0; // TODO: get the actual exchange rate
-    }
-
-    function getUserMarketInfo(address market, address user)
-        public
-        view
-        returns (UserMarketInfo memory userMarketInfo)
-    {
-        IPMarket _market = IPMarket(market);
-        userMarketInfo.market = market;
-        userMarketInfo.lpBalance = _market.balanceOf(user);
-        // TODO: Is there a way to convert LP to OT and SCY?
-        userMarketInfo.otBalance = TokenAmount(_market.OT(), 0);
-        userMarketInfo.scyBalance = TokenAmount(_market.SCY(), 0);
-        // TODO: Get this from SCY once it is in the interface
-        userMarketInfo.assetBalance = TokenAmount(address(0), 0);
-    }
-
-    function getUserYOPositionsByYOs(address user, address[] calldata yos)
-        external
-        view
-        returns (UserYOInfo[] memory userYOPositions)
-    {
-        userYOPositions = new UserYOInfo[](yos.length);
-        for (uint256 i = 0; i < yos.length; ++i) {
-            userYOPositions[i] = getUserYOInfo(yos[i], user);
-        }
-    }
-
-    function getUserMarketPositions(address user, address[] calldata markets)
-        external
-        view
-        returns (UserMarketInfo[] memory userMarketPositions)
-    {
-        userMarketPositions = new UserMarketInfo[](markets.length);
-        for (uint256 i = 0; i < markets.length; ++i) {
-            userMarketPositions[i] = getUserMarketInfo(markets[i], user);
-        }
-    }
-
-    function hasYOPosition(UserYOInfo memory userYOInfo) public pure returns (bool hasPosition) {
-        hasPosition = (userYOInfo.ytBalance > 0 ||
-            userYOInfo.otBalance > 0 ||
-            userYOInfo.unclaimedInterest.amount > 0 ||
-            userYOInfo.unclaimedRewards.length > 0);
-    }
-
-    function getUserSCYInfo(address scy, address user)
-        external
-        view
-        returns (uint256 balance, TokenAmount[] memory rewards)
-    {
-        ISuperComposableYield SCY = ISuperComposableYield(scy);
-        balance = SCY.balanceOf(scy);
-        address[] memory rewardTokens = SCY.getRewardTokens();
-        rewards = new TokenAmount[](rewardTokens.length);
-        for (uint256 i = 0; i < rewardTokens.length; ++i) {
-            address rewardToken = rewardTokens[i];
-            rewards[i].token = rewardToken;
-            (, rewards[i].amount) = IRewardManager(scy).getUserReward(user, rewardToken);
-        }
-    }
 }