@pendle/core-v2 0.4.0 → 0.5.1-beta

package/contracts/SuperComposableYield/implementations/IRewardManager.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+
+interface IRewardManager {
+    function getGlobalReward(address rewardToken)
+        external
+        view
+        returns (uint256 index, uint256 lastBalance);
+
+    function getUserReward(address user, address rewardToken)
+        external
+        view
+        returns (uint256 lastIndex, uint256 accruedReward);
+
+    function getRewardTokens() external view returns (address[] memory);
+}

package/contracts/SuperComposableYield/implementations/RewardManager.sol

@@ -1,10 +1,11 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.9;
 import "../ISuperComposableYield.sol";
+import "./IRewardManager.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import "../../libraries/math/Math.sol";
 
-abstract contract RewardManager {
+abstract contract RewardManager is IRewardManager {
     using SafeERC20 for IERC20;
     using Math for uint256;
 
@@ -20,8 +21,28 @@ abstract contract RewardManager {
 
     uint256 internal constant INITIAL_REWARD_INDEX = 1;
 
-    mapping(address => GlobalReward) public globalReward;
-    mapping(address => mapping(address => UserReward)) public userReward;
+    mapping(address => GlobalReward) internal globalReward;
+    mapping(address => mapping(address => UserReward)) internal userReward;
+
+    function getGlobalReward(address rewardToken)
+        external
+        view
+        returns (uint256 index, uint256 lastBalance)
+    {
+        GlobalReward memory reward = globalReward[rewardToken];
+        return (reward.index, reward.lastBalance);
+    }
+
+    function getUserReward(address user, address rewardToken)
+        external
+        view
+        returns (uint256 lastIndex, uint256 accruedReward)
+    {
+        UserReward memory reward = userReward[user][rewardToken];
+        return (reward.lastIndex, reward.accruedReward);
+    }
+
+    function getRewardTokens() public view virtual override returns (address[] memory);
 
     function _doTransferOutRewardsForUser(address user, address receiver)
         internal
@@ -111,7 +132,5 @@ abstract contract RewardManager {
         }
     }
 
-    function getRewardTokens() public view virtual returns (address[] memory);
-
     function _redeemExternalReward() internal virtual;
 }

package/contracts/core/PendleMarket.sol

@@ -34,31 +34,19 @@ contract PendleMarket is PendleBaseToken, IPMarket, ReentrancyGuard {
     address public immutable YT;
 
     int256 public immutable scalarRoot;
-    uint256 public immutable feeRateRoot; // allow fee to be changable?
     int256 public immutable initialAnchor;
 
-    uint256 public immutable rateOracleTimeWindow;
-    int8 public immutable reserveFeePercent;
-
     MarketStorage public marketStorage;
 
     constructor(
         address _OT,
-        uint256 _rateOracleTimeWindow,
-        uint256 _feeRateRoot,
         int256 _scalarRoot,
-        int256 _initialAnchor,
-        uint8 _reserveFeePercent
+        int256 _initialAnchor
     ) PendleBaseToken(NAME, SYMBOL, 18, IPOwnershipToken(_OT).expiry()) {
         OT = _OT;
         SCY = IPOwnershipToken(_OT).SCY();
         YT = IPOwnershipToken(_OT).YT();
-        feeRateRoot = _feeRateRoot;
         scalarRoot = _scalarRoot;
-        rateOracleTimeWindow = _rateOracleTimeWindow;
-
-        require(_reserveFeePercent <= 100, "invalid fee rate");
-        reserveFeePercent = int8(_reserveFeePercent);
         initialAnchor = _initialAnchor;
     }
 
@@ -154,7 +142,7 @@ contract PendleMarket is PendleBaseToken, IPMarket, ReentrancyGuard {
         );
         require(netScyOut >= minScyOut, "insufficient scy out");
         IERC20(SCY).safeTransfer(receiver, netScyOut);
-        IERC20(SCY).safeTransfer(IPMarketFactory(factory).treasury(), netScyToReserve);
+        IERC20(SCY).safeTransfer(market.treasury, netScyToReserve);
 
         if (data.length > 0) {
             IPMarketSwapCallback(msg.sender).swapCallback(exactOtIn.neg(), netScyOut.Int(), data);
@@ -183,7 +171,7 @@ contract PendleMarket is PendleBaseToken, IPMarket, ReentrancyGuard {
         );
         require(netScyIn <= maxScyIn, "scy in exceed limit");
         IERC20(OT).safeTransfer(receiver, exactOtOut);
-        IERC20(SCY).safeTransfer(IPMarketFactory(factory).treasury(), netScyToReserve);
+        IERC20(SCY).safeTransfer(market.treasury, netScyToReserve);
 
         if (data.length > 0) {
             IPMarketSwapCallback(msg.sender).swapCallback(exactOtOut.Int(), netScyIn.neg(), data);
@@ -206,11 +194,15 @@ contract PendleMarket is PendleBaseToken, IPMarket, ReentrancyGuard {
         market.totalScy = store.totalScy;
         market.totalLp = totalSupply().Int();
         market.oracleRate = store.oracleRate;
-        market.reserveFeePercent = reserveFeePercent;
+
+        (
+            market.treasury,
+            market.feeRateRoot,
+            market.rateOracleTimeWindow,
+            market.reserveFeePercent
+        ) = IPMarketFactory(factory).marketConfig();
 
         market.scalarRoot = scalarRoot;
-        market.feeRateRoot = feeRateRoot;
-        market.rateOracleTimeWindow = rateOracleTimeWindow;
         market.expiry = expiry;
 
         market.lastImpliedRate = store.lastImpliedRate;

package/contracts/core/PendleMarketFactory.sol

@@ -10,24 +10,40 @@ import "./PendleMarket.sol";
 contract PendleMarketFactory is PermissionsV2Upg, IPMarketFactory {
     using EnumerableSet for EnumerableSet.AddressSet;
 
+    struct MarketConfig {
+        address treasury; // 160 bit
+        uint96 feeRateRoot; // 96 bit
+        // 1 SLOT
+        uint32 rateOracleTimeWindow;
+        uint8 reserveFeePercent;
+    }
+
     mapping(address => EnumerableSet.AddressSet) internal markets;
 
     address public immutable yieldContractFactory;
-    address public treasury;
 
-    constructor(address _governanceManager, address _yieldContractFactory)
-        PermissionsV2Upg(_governanceManager)
-    {
+    MarketConfig public marketConfig;
+
+    constructor(
+        address _governanceManager,
+        address _yieldContractFactory,
+        address _treasury,
+        uint96 _feeRateRoot,
+        uint32 _rateOracleTimeWindow,
+        uint8 _reserveFeePercent
+    ) PermissionsV2Upg(_governanceManager) {
         yieldContractFactory = _yieldContractFactory;
+
+        setTreasury(_treasury);
+        setFeeRateRoot(_feeRateRoot);
+        setRateOracleTimeWindow(_rateOracleTimeWindow);
+        setReserveFeePercent(_reserveFeePercent);
     }
 
     function createNewMarket(
         address OT,
-        uint256 feeRateRoot,
         int256 scalarRoot,
-        int256 initialAnchor,
-        uint8 reserveFeePercent,
-        uint256 rateOracleTimeWindow
+        int256 initialAnchor
     ) external returns (address market) {
         address SCY = IPOwnershipToken(OT).SCY();
         uint256 expiry = IPOwnershipToken(OT).expiry();
@@ -37,25 +53,36 @@ contract PendleMarketFactory is PermissionsV2Upg, IPMarketFactory {
             "INVALID_OT"
         );
 
-        market = address(
-            new PendleMarket(
-                OT,
-                rateOracleTimeWindow,
-                feeRateRoot,
-                scalarRoot,
-                initialAnchor,
-                reserveFeePercent
-            )
-        );
+        market = address(new PendleMarket(OT, scalarRoot, initialAnchor));
         markets[OT].add(market);
     }
 
-    function setTreasury(address newTreasury) external onlyGovernance {
-        treasury = newTreasury;
-    }
-
     function isValidMarket(address market) external view returns (bool) {
         address OT = IPMarket(market).OT();
         return markets[OT].contains(market);
     }
+
+    function treasury() external view returns (address) {
+        return marketConfig.treasury;
+    }
+
+    function setTreasury(address newTreasury) public onlyGovernance {
+        require(newTreasury != address(0), "zero address");
+        marketConfig.treasury = newTreasury;
+    }
+
+    function setFeeRateRoot(uint96 newFeeRateRoot) public onlyGovernance {
+        // TODO: hard cap on the fee
+        marketConfig.feeRateRoot = newFeeRateRoot;
+    }
+
+    function setRateOracleTimeWindow(uint32 newRateOracleTimeWindow) public onlyGovernance {
+        // TODO: hard min for the time window
+        marketConfig.rateOracleTimeWindow = newRateOracleTimeWindow;
+    }
+
+    function setReserveFeePercent(uint8 newReserveFeePercent) public onlyGovernance {
+        require(newReserveFeePercent <= 100, "invalid fee rate");
+        marketConfig.reserveFeePercent = newReserveFeePercent;
+    }
 }

package/contracts/core/PendleRouter.sol

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts/proxy/Proxy.sol";
+import "../interfaces/IPActionCore.sol";
+import "../interfaces/IPActionYT.sol";
+import "../interfaces/IPRouterStatic.sol";
+import "../interfaces/IPMarketSwapCallback.sol";
+import "../periphery/PermissionsV2Upg.sol";
+
+/// @dev this contract will be deployed behind an ERC1967 proxy
+/// calls to the ERC1967 proxy will be resolved at this contract, and proxied again to the
+/// corresponding implementation contracts
+
+// solhint-disable no-empty-blocks
+contract PendleRouter is Proxy, Initializable, UUPSUpgradeable, PermissionsV2Upg {
+    address public immutable ACTION_CORE;
+    address public immutable ACTION_YT;
+    address public immutable ACTION_CALLBACK;
+
+    constructor(
+        address _ACTION_CORE,
+        address _ACTION_YT,
+        address _ACTION_CALLBACK,
+        address _governanceManager
+    ) PermissionsV2Upg(_governanceManager) initializer {
+        ACTION_CORE = _ACTION_CORE;
+        ACTION_YT = _ACTION_YT;
+        ACTION_CALLBACK = _ACTION_CALLBACK;
+    }
+
+    function initialize() external initializer {
+        __UUPSUpgradeable_init();
+        // no need to initialize PermissionsV2Upg
+    }
+
+    function getRouterImplementation(bytes4 sig) public view returns (address) {
+        if (
+            sig == IPActionCore.mintScyFromRawToken.selector ||
+            sig == IPActionCore.redeemScyToRawToken.selector ||
+            sig == IPActionCore.mintYoFromRawToken.selector ||
+            sig == IPActionCore.redeemYoToRawToken.selector ||
+            sig == IPActionCore.addLiquidity.selector ||
+            sig == IPActionCore.removeLiquidity.selector ||
+            sig == IPActionCore.swapExactOtForScy.selector ||
+            sig == IPActionCore.swapOtForExactScy.selector ||
+            sig == IPActionCore.swapScyForExactOt.selector ||
+            sig == IPActionCore.swapExactScyForOt.selector ||
+            sig == IPActionCore.swapExactRawTokenForOt.selector ||
+            sig == IPActionCore.swapExactOtForRawToken.selector
+        ) {
+            return ACTION_CORE;
+        } else if (
+            sig == IPActionYT.swapExactYtForScy.selector ||
+            sig == IPActionYT.swapScyForExactYt.selector ||
+            sig == IPActionYT.swapExactScyForYt.selector ||
+            sig == IPActionYT.swapExactRawTokenForYt.selector ||
+            sig == IPActionYT.swapExactYtForRawToken.selector
+        ) {
+            return ACTION_YT;
+        } else if (sig == IPMarketSwapCallback.swapCallback.selector) {
+            return ACTION_CALLBACK;
+        }
+        require(false, "invalid market sig");
+    }
+
+    function _implementation() internal view override returns (address) {
+        return getRouterImplementation(msg.sig);
+    }
+
+    function _authorizeUpgrade(address newImplementation) internal override onlyGovernance {}
+}

package/contracts/core/PendleYieldToken.sol

@@ -19,11 +19,11 @@ It has been proven and tested that impliedScyBalance will not change over time,
 
 Due to this, it is required to update users' accruedReward STRICTLY BEFORE redeeming their interest.
 */
-contract PendleYieldToken is PendleBaseToken, IPYieldToken, RewardManager {
+contract PendleYieldToken is PendleBaseToken, RewardManager, IPYieldToken {
     using Math for uint256;
     using SafeERC20 for IERC20;
 
-    struct UserData {
+    struct InterestData {
         uint256 lastScyIndex;
         uint256 dueInterest;
     }
@@ -40,7 +40,7 @@ contract PendleYieldToken is PendleBaseToken, IPYieldToken, RewardManager {
     mapping(address => uint256) public totalRewardsPostExpiry;
     uint256 public totalProtocolFee;
 
-    mapping(address => UserData) public data;
+    mapping(address => InterestData) internal interestData;
 
     constructor(
         address _SCY,
@@ -118,13 +118,13 @@ contract PendleYieldToken is PendleBaseToken, IPYieldToken, RewardManager {
     }
 
     function updateUserInterest(address user) public {
-        uint256 prevIndex = data[user].lastScyIndex;
+        uint256 prevIndex = interestData[user].lastScyIndex;
 
         uint256 currentIndex = getScyIndexBeforeExpiry();
 
         if (prevIndex == currentIndex) return;
         if (prevIndex == 0) {
-            data[user].lastScyIndex = currentIndex;
+            interestData[user].lastScyIndex = currentIndex;
             return;
         }
 
@@ -134,8 +134,16 @@ contract PendleYieldToken is PendleBaseToken, IPYieldToken, RewardManager {
             prevIndex * currentIndex
         );
 
-        data[user].dueInterest += interestFromYT;
-        data[user].lastScyIndex = currentIndex;
+        interestData[user].dueInterest += interestFromYT;
+        interestData[user].lastScyIndex = currentIndex;
+    }
+
+    function getInterestData(address user)
+        external
+        view
+        returns (uint256 lastScyIndex, uint256 dueInterest)
+    {
+        return (interestData[user].lastScyIndex, interestData[user].dueInterest);
     }
 
     function _updateGlobalReward(address[] memory rewardTokens, uint256 totalSupply)
@@ -165,8 +173,8 @@ contract PendleYieldToken is PendleBaseToken, IPYieldToken, RewardManager {
     }
 
     function _doTransferOutDueInterest(address user) internal returns (uint256 interestOut) {
-        uint256 interestPreFee = data[user].dueInterest;
-        data[user].dueInterest = 0;
+        uint256 interestPreFee = interestData[user].dueInterest;
+        interestData[user].dueInterest = 0;
 
         uint256 feeRate = IPYieldContractFactory(factory).interestFeeRate();
         uint256 feeAmount = interestPreFee.mulDown(feeRate);
@@ -185,7 +193,7 @@ contract PendleYieldToken is PendleBaseToken, IPYieldToken, RewardManager {
         public
         view
         virtual
-        override(RewardManager)
+        override(RewardManager, IRewardManager)
         returns (address[] memory)
     {
         return ISuperComposableYield(SCY).getRewardTokens();
@@ -247,9 +255,9 @@ contract PendleYieldToken is PendleBaseToken, IPYieldToken, RewardManager {
     }
 
     function getImpliedScyBalance(address user) public view returns (uint256) {
-        uint256 scyIndex = data[user].lastScyIndex;
+        uint256 scyIndex = interestData[user].lastScyIndex;
         if (scyIndex == 0) return 0;
-        return SCYUtils.assetToScy(scyIndex, balanceOf(user)) + data[user].dueInterest;
+        return SCYUtils.assetToScy(scyIndex, balanceOf(user)) + interestData[user].dueInterest;
     }
 
     function _beforeTokenTransfer(

package/contracts/core/RouterStatic.sol

@@ -0,0 +1,234 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+
+import "../interfaces/IPRouterStatic.sol";
+import "../interfaces/IPMarket.sol";
+import "../interfaces/IPYieldContractFactory.sol";
+import "../interfaces/IPMarketFactory.sol";
+import "../libraries/math/MarketMathAux.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+
+contract RouterStatic is IPRouterStatic {
+    using MarketMathCore for MarketState;
+    using MarketMathAux for MarketState;
+    using Math for uint256;
+    using Math for int256;
+    using LogExpMath for int256;
+
+    IPYieldContractFactory public immutable yieldContractFactory;
+    IPMarketFactory public immutable marketFactory;
+
+    constructor(IPYieldContractFactory _yieldContractFactory, IPMarketFactory _marketFactory) {
+        yieldContractFactory = _yieldContractFactory;
+        marketFactory = _marketFactory;
+    }
+
+    function addLiquidityStatic(
+        address market,
+        uint256 scyDesired,
+        uint256 otDesired
+    )
+        external
+        returns (
+            uint256 netLpOut,
+            uint256 scyUsed,
+            uint256 otUsed
+        )
+    {
+        MarketState memory state = IPMarket(market).readState(false);
+        (, netLpOut, scyUsed, otUsed) = state.addLiquidity(
+            scyIndex(market),
+            scyDesired,
+            otDesired,
+            false
+        );
+    }
+
+    function removeLiquidityStatic(address market, uint256 lpToRemove)
+        external
+        view
+        returns (uint256 netScyOut, uint256 netOtOut)
+    {
+        MarketState memory state = IPMarket(market).readState(false);
+        (netScyOut, netOtOut) = state.removeLiquidity(lpToRemove, false);
+    }
+
+    function swapOtForScyStatic(address market, uint256 exactOtIn)
+        external
+        returns (uint256 netScyOut, uint256 netScyFee)
+    {
+        MarketState memory state = IPMarket(market).readState(false);
+        (netScyOut, netScyFee) = state.swapExactOtForScy(
+            scyIndex(market),
+            exactOtIn,
+            block.timestamp,
+            false
+        );
+    }
+
+    function swapScyForOtStatic(address market, uint256 exactOtOut)
+        external
+        returns (uint256 netScyIn, uint256 netScyFee)
+    {
+        MarketState memory state = IPMarket(market).readState(false);
+        (netScyIn, netScyFee) = state.swapScyForExactOt(
+            scyIndex(market),
+            exactOtOut,
+            block.timestamp,
+            false
+        );
+    }
+
+    function scyIndex(address market) public returns (SCYIndex index) {
+        return SCYIndexLib.newIndex(IPMarket(market).SCY());
+    }
+
+    function getOtImpliedYield(address market) public view returns (int256) {
+        MarketState memory state = IPMarket(market).readState(false);
+
+        int256 lnImpliedRate = (state.lastImpliedRate).Int();
+        return lnImpliedRate.exp();
+    }
+
+    function getPendleTokenType(address token)
+        external
+        view
+        returns (
+            bool isOT,
+            bool isYT,
+            bool isMarket
+        )
+    {
+        if (yieldContractFactory.isOT(token)) isOT = true;
+        else if (yieldContractFactory.isYT(token)) isYT = true;
+        else if (marketFactory.isValidMarket(token)) isMarket = true;
+    }
+
+    function getUserYOInfo(address token, address user)
+        public
+        view
+        returns (UserYOInfo memory userYOInfo)
+    {
+        (userYOInfo.yt, userYOInfo.ot) = getYO(token);
+        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 token)
+        external
+        returns (
+            uint256 exchangeRate,
+            uint256 totalSupply,
+            RewardIndex[] memory rewardIndexes
+        )
+    {
+        (address yt, ) = getYO(token);
+        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 token) public view returns (address ot, address yt) {
+        if (yieldContractFactory.isOT(token)) {
+            yt = IPOwnershipToken(token).YT();
+            ot = token;
+        } else if (yieldContractFactory.isYT(token)) {
+            yt = token;
+            ot = IPYieldToken(token).OT();
+        } else if (marketFactory.isValidMarket(token)) {
+            yt = IPMarket(token).YT();
+            ot = IPMarket(token).OT();
+        }
+    }
+
+    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;
+        // TODO: What will this return if the user's balance is staked?
+        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 getUserYOPositionsByTokens(address user, address[] calldata tokens)
+        external
+        view
+        returns (UserYOInfo[] memory userYOPositions)
+    {
+        userYOPositions = new UserYOInfo[](tokens.length);
+        for (uint256 i = 0; i < tokens.length; ++i) {
+            userYOPositions[i] = getUserYOInfo(tokens[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);
+    }
+}