@pendle/core-v2 0.6.0 → 0.6.2

package/contracts/core/RouterStatic.sol

@@ -1,6 +1,8 @@
 // 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";
@@ -48,18 +50,18 @@ contract RouterStatic is IPRouterStatic {
     function removeLiquidityStatic(address market, uint256 lpToRemove)
         external
         view
-        returns (uint256 netScyOut, uint256 netPtOut)
+        returns (uint256 netScpyut, uint256 netPtOut)
     {
         MarketState memory state = IPMarket(market).readState(false);
-        (netScyOut, netPtOut) = state.removeLiquidity(lpToRemove, false);
+        (netScpyut, netPtOut) = state.removeLiquidity(lpToRemove, false);
     }
 
     function swapPtForScyStatic(address market, uint256 exactPtIn)
         external
-        returns (uint256 netScyOut, uint256 netScyFee)
+        returns (uint256 netScpyut, uint256 netScyFee)
     {
         MarketState memory state = IPMarket(market).readState(false);
-        (netScyOut, netScyFee) = state.swapExactPtForScy(
+        (netScpyut, netScyFee) = state.swapExactPtForScy(
             scyIndex(market),
             exactPtIn,
             block.timestamp,
@@ -84,7 +86,7 @@ contract RouterStatic is IPRouterStatic {
         return SCYIndexLib.newIndex(IPMarket(market).SCY());
     }
 
-    function getPtImpliedYield(address market) external view returns (int256) {
+    function getPtImpliedYield(address market) public view returns (int256) {
         MarketState memory state = IPMarket(market).readState(false);
 
         int256 lnImpliedRate = (state.lastLnImpliedRate).Int();
@@ -104,4 +106,143 @@ contract RouterStatic is IPRouterStatic {
         else if (yieldContractFactory.isYT(token)) isYT = true;
         else if (marketFactory.isValidMarket(token)) isMarket = true;
     }
+
+    function getUserPYInfo(address py, address user)
+        public
+        view
+        returns (UserPYInfo memory userPYInfo)
+    {
+        (userPYInfo.yt, userPYInfo.pt) = getPY(py);
+        IPYieldToken YT = IPYieldToken(userPYInfo.yt);
+        userPYInfo.ytBalance = YT.balanceOf(user);
+        userPYInfo.ptBalance = IPPrincipalToken(userPYInfo.pt).balanceOf(user);
+        userPYInfo.unclaimedInterest.token = YT.SCY();
+        (, userPYInfo.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;
+            }
+        }
+        userPYInfo.unclaimedRewards = new TokenAmount[](length);
+        for (uint256 i = 0; i < length; ++i) {
+            userPYInfo.unclaimedRewards[i] = unclaimedRewards[i];
+        }
+    }
+
+    function getPYInfo(address py)
+        external
+        returns (
+            uint256 exchangeRate,
+            uint256 totalSupply,
+            RewardIndex[] memory rewardIndexes
+        )
+    {
+        (address yt, ) = getPY(py);
+        IPYieldToken YT = IPYieldToken(yt);
+        (, exchangeRate) = YT.getScyIndex();
+        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 getPY(address py) public view returns (address pt, address yt) {
+        if (yieldContractFactory.isYT(py)) {
+            yt = py;
+            pt = IPYieldToken(py).PT();
+        } else {
+            yt = IPPrincipalToken(py).YT();
+            pt = py;
+        }
+    }
+
+    function getMarketInfo(address market)
+        external
+        view
+        returns (
+            address pt,
+            address scy,
+            MarketState memory state,
+            int256 impliedYield,
+            uint256 exchangeRate
+        )
+    {
+        IPMarket _market = IPMarket(market);
+        pt = _market.PT();
+        scy = _market.SCY();
+        state = _market.readState(true);
+        impliedYield = getPtImpliedYield(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 PT and SCY?
+        userMarketInfo.ptBalance = TokenAmount(_market.PT(), 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 getUserPYPositionsByPYs(address user, address[] calldata pys)
+        external
+        view
+        returns (UserPYInfo[] memory userPYPositions)
+    {
+        userPYPositions = new UserPYInfo[](pys.length);
+        for (uint256 i = 0; i < pys.length; ++i) {
+            userPYPositions[i] = getUserPYInfo(pys[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 hasPYPosition(UserPYInfo memory userPYInfo) public pure returns (bool hasPosition) {
+        hasPosition = (userPYInfo.ytBalance > 0 ||
+            userPYInfo.ptBalance > 0 ||
+            userPYInfo.unclaimedInterest.amount > 0 ||
+            userPYInfo.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);
+        }
+    }
 }

package/contracts/interfaces/IPRouterStatic.sol

@@ -4,6 +4,33 @@ pragma solidity 0.8.9;
 import "../libraries/math/MarketMathCore.sol";
 
 interface IPRouterStatic {
+    struct TokenAmount {
+        address token;
+        uint256 amount;
+    }
+
+    struct RewardIndex {
+        address rewardToken;
+        uint256 index;
+    }
+
+    struct UserPYInfo {
+        address yt;
+        address pt;
+        uint256 ytBalance;
+        uint256 ptBalance;
+        TokenAmount unclaimedInterest;
+        TokenAmount[] unclaimedRewards;
+    }
+
+    struct UserMarketInfo {
+        address market;
+        uint256 lpBalance;
+        TokenAmount ptBalance;
+        TokenAmount scyBalance;
+        TokenAmount assetBalance;
+    }
+
     function addLiquidityStatic(
         address market,
         uint256 scyDesired,
@@ -41,4 +68,52 @@ interface IPRouterStatic {
             bool isYT,
             bool isMarket
         );
+
+    function getUserPYInfo(address py, address user)
+        external
+        view
+        returns (UserPYInfo memory userPYInfo);
+
+    function getPYInfo(address py)
+        external
+        returns (
+            uint256 exchangeRate,
+            uint256 totalSupply,
+            RewardIndex[] memory rewardIndexes
+        );
+
+    function getPY(address py) external view returns (address yt, address pt);
+
+    function getMarketInfo(address market)
+        external
+        view
+        returns (
+            address pt,
+            address scy,
+            MarketState memory state,
+            int256 impliedYield,
+            uint256 exchangeRate
+        );
+
+    function getUserMarketInfo(address market, address user)
+        external
+        view
+        returns (UserMarketInfo memory userMarketInfo);
+
+    function getUserPYPositionsByPYs(address user, address[] calldata pys)
+        external
+        view
+        returns (UserPYInfo[] memory userPYPositions);
+
+    function getUserMarketPositions(address user, address[] calldata markets)
+        external
+        view
+        returns (UserMarketInfo[] memory userMarketPositions);
+
+    function hasPYPosition(UserPYInfo memory userPYInfo) external pure returns (bool hasPosition);
+
+    function getUserSCYInfo(address scy, address user)
+        external
+        view
+        returns (uint256 balance, TokenAmount[] memory rewards);
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",