@pendle/core-v2 0.9.3-beta → 0.10.1-beta

package/contracts/offchain-helpers/RouterStatic.sol

@@ -1,26 +1,49 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.15;
 
-import "../interfaces/ISuperComposableYield.sol";
-import "../interfaces/IRewardManager.sol";
-import "../interfaces/IPRouterStatic.sol";
-import "../interfaces/IPMarket.sol";
 import "../interfaces/IPYieldContractFactory.sol";
 import "../interfaces/IPMarketFactory.sol";
-import "../libraries/math/MarketApproxLib.sol";
+import "./MarketMathStatic.sol";
 import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
 import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
 
 /// EXCLUDED FROM ALL AUDITS, TO BE CALLED ONLY BY PENDLE's SDK
-contract RouterStatic is IPRouterStatic {
-    using MarketMathCore for MarketState;
-    using MarketApproxLib for MarketState;
+contract RouterStatic is OwnableUpgradeable, UUPSUpgradeable {
     using Math for uint256;
-    using Math for int256;
-    using LogExpMath for int256;
-    using PYIndexLib for PYIndex;
-    using PYIndexLib for IPYieldToken;
+
+    struct TokenAmount {
+        address token;
+        uint256 amount;
+    }
+
+    struct AssetAmount {
+        ISuperComposableYield.AssetType assetType;
+        address assetAddress;
+        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;
+        AssetAmount assetBalance;
+    }
 
     IPYieldContractFactory internal immutable yieldContractFactory;
     IPMarketFactory internal immutable marketFactory;
@@ -33,11 +56,19 @@ contract RouterStatic is IPRouterStatic {
             eps: 1e15
         });
 
-    constructor(IPYieldContractFactory _yieldContractFactory, IPMarketFactory _marketFactory) {
+    constructor(IPYieldContractFactory _yieldContractFactory, IPMarketFactory _marketFactory)
+        initializer
+    {
         yieldContractFactory = _yieldContractFactory;
         marketFactory = _marketFactory;
     }
 
+    function initialize() external initializer {
+        __Ownable_init();
+    }
+
+    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
+
     // ============= SYSTEM INFO =============
 
     function getPYInfo(address py)
@@ -77,6 +108,16 @@ contract RouterStatic is IPRouterStatic {
         else if (marketFactory.isValidMarket(token)) isMarket = true;
     }
 
+    function getPY(address py) public view returns (address pt, address yt) {
+        if (yieldContractFactory.isYT(py)) {
+            pt = IPYieldToken(py).PT();
+            yt = py;
+        } else {
+            pt = py;
+            yt = IPPrincipalToken(py).YT();
+        }
+    }
+
     function getMarketInfo(address market)
         external
         returns (
@@ -92,9 +133,9 @@ contract RouterStatic is IPRouterStatic {
 
         pt = address(PT);
         scy = address(SCY);
-        state = _market.readState(true);
+        state = _market.readState();
         impliedYield = getPtImpliedYield(market);
-        exchangeRate = getExchangeRate(market);
+        exchangeRate = MarketMathStatic.getExchangeRate(market);
     }
 
     // ============= USER INFO =============
@@ -137,6 +178,72 @@ contract RouterStatic is IPRouterStatic {
         }
     }
 
+    function getUserPYInfo(address py, address user)
+        public
+        view
+        returns (UserPYInfo memory userPYInfo)
+    {
+        (userPYInfo.pt, userPYInfo.yt) = 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.userInterest(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.userReward(rewardToken, user);
+            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 getUserMarketInfo(address market, address user)
+        public
+        view
+        returns (UserMarketInfo memory userMarketInfo)
+    {
+        IPMarket _market = IPMarket(market);
+        uint256 userLp = _market.balanceOf(user);
+
+        userMarketInfo.market = market;
+        userMarketInfo.lpBalance = userLp;
+
+        (ISuperComposableYield SCY, IPPrincipalToken PT, ) = _market.readTokens();
+        (userMarketInfo.assetBalance.assetType, userMarketInfo.assetBalance.assetAddress, ) = SCY
+            .assetInfo();
+
+        MarketState memory state = _market.readState();
+        uint256 totalLp = uint256(state.totalLp);
+
+        if (totalLp == 0) {
+            return userMarketInfo;
+        }
+
+        uint256 userPt = (userLp * uint256(state.totalPt)) / totalLp;
+        uint256 userScy = (userLp * uint256(state.totalScy)) / totalLp;
+
+        userMarketInfo.ptBalance = TokenAmount(address(PT), userPt);
+        userMarketInfo.scyBalance = TokenAmount(address(SCY), userScy);
+        userMarketInfo.assetBalance.amount = (userScy * SCY.exchangeRate()) / Math.ONE;
+    }
+
+    function hasPYPosition(UserPYInfo calldata userPYInfo) public pure returns (bool hasPosition) {
+        hasPosition = (userPYInfo.ytBalance > 0 ||
+            userPYInfo.ptBalance > 0 ||
+            userPYInfo.unclaimedInterest.amount > 0 ||
+            userPYInfo.unclaimedRewards.length > 0);
+    }
+
     // ============= MARKET ACTIONS =============
 
     function addLiquidityDualScyAndPtStatic(
@@ -151,42 +258,29 @@ contract RouterStatic is IPRouterStatic {
             uint256 ptUsed
         )
     {
-        MarketState memory state = IPMarket(market).readState(false);
-        (, netLpOut, scyUsed, ptUsed) = state.addLiquidity(
-            pyIndex(market),
-            scyDesired,
-            ptDesired,
-            block.timestamp
-        );
+        return MarketMathStatic.addLiquidityDualScyAndPtStatic(market, scyDesired, ptDesired);
     }
 
-    function addLiquidityDualIbTokenAndPtStatic(
+    function addLiquidityDualTokenAndPtStatic(
         address market,
-        uint256 ibTokenDesired,
+        address tokenIn,
+        uint256 tokenDesired,
         uint256 ptDesired
     )
         external
         returns (
             uint256 netLpOut,
-            uint256 ibTokenUsed,
+            uint256 tokenUsed,
             uint256 ptUsed
         )
     {
-        (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
-
-        address ibToken = SCY.yieldToken();
-        uint256 scyDesired = SCY.previewDeposit(ibToken, ibTokenDesired);
-        uint256 scyUsed;
-
-        MarketState memory state = IPMarket(market).readState(false);
-        (, netLpOut, scyUsed, ptUsed) = state.addLiquidity(
-            pyIndex(market),
-            scyDesired,
-            ptDesired,
-            block.timestamp
-        );
-
-        ibTokenUsed = (ibTokenDesired * scyUsed).rawDivUp(scyDesired);
+        return
+            MarketMathStatic.addLiquidityDualTokenAndPtStatic(
+                market,
+                tokenIn,
+                tokenDesired,
+                ptDesired
+            );
     }
 
     function addLiquiditySinglePtStatic(address market, uint256 netPtIn)
@@ -197,18 +291,18 @@ contract RouterStatic is IPRouterStatic {
             uint256 priceImpact
         )
     {
-        require(false, "NOT IMPLEMENTED");
+        return MarketMathStatic.addLiquiditySinglePtStatic(market, netPtIn, approxParams);
     }
 
     function addLiquiditySingleScyStatic(address market, uint256 netScyIn)
-        external
+        public
         returns (
             uint256 netLpOut,
             uint256 netScyFee,
             uint256 priceImpact
         )
     {
-        require(false, "NOT IMPLEMENTED");
+        return MarketMathStatic.addLiquiditySingleScyStatic(market, netScyIn, approxParams);
     }
 
     function addLiquiditySingleBaseTokenStatic(
@@ -223,7 +317,13 @@ contract RouterStatic is IPRouterStatic {
             uint256 priceImpact
         )
     {
-        require(false, "NOT IMPLEMENTED");
+        return
+            MarketMathStatic.addLiquiditySingleBaseTokenStatic(
+                market,
+                baseToken,
+                netBaseTokenIn,
+                approxParams
+            );
     }
 
     function removeLiquidityDualScyAndPtStatic(address market, uint256 lpToRemove)
@@ -231,24 +331,15 @@ contract RouterStatic is IPRouterStatic {
         view
         returns (uint256 netScyOut, uint256 netPtOut)
     {
-        MarketState memory state = IPMarket(market).readState(false);
-        (netScyOut, netPtOut) = state.removeLiquidity(lpToRemove);
+        return MarketMathStatic.removeLiquidityDualScyAndPtStatic(market, lpToRemove);
     }
 
-    function removeLiquidityDualIbTokenAndPtStatic(address market, uint256 lpToRemove)
-        external
-        view
-        returns (uint256 netIbTokenOut, uint256 netPtOut)
-    {
-        (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
-
-        address ibToken = SCY.yieldToken();
-
-        uint256 netScyOut;
-        MarketState memory state = IPMarket(market).readState(false);
-        (netScyOut, netPtOut) = state.removeLiquidity(lpToRemove);
-
-        netIbTokenOut = SCY.previewRedeem(ibToken, netScyOut);
+    function removeLiquidityDualTokenAndPtStatic(
+        address market,
+        uint256 lpToRemove,
+        address tokenOut
+    ) external view returns (uint256 netTokenOut, uint256 netPtOut) {
+        return MarketMathStatic.removeLiquidityDualTokenAndPtStatic(market, lpToRemove, tokenOut);
     }
 
     function removeLiquiditySinglePtStatic(address market, uint256 lpToRemove)
@@ -259,18 +350,18 @@ contract RouterStatic is IPRouterStatic {
             uint256 priceImpact
         )
     {
-        require(false, "NOT IMPLEMENTED");
+        return MarketMathStatic.removeLiquiditySinglePtStatic(market, lpToRemove, approxParams);
     }
 
     function removeLiquiditySingleScyStatic(address market, uint256 lpToRemove)
-        external
+        public
         returns (
             uint256 netScyOut,
             uint256 netScyFee,
             uint256 priceImpact
         )
     {
-        require(false, "NOT IMPLEMENTED");
+        return MarketMathStatic.removeLiquiditySingleScyStatic(market, lpToRemove);
     }
 
     function removeLiquiditySingleBaseTokenStatic(
@@ -285,7 +376,8 @@ contract RouterStatic is IPRouterStatic {
             uint256 priceImpact
         )
     {
-        require(false, "NOT IMPLEMENTED");
+        return
+            MarketMathStatic.removeLiquiditySingleBaseTokenStatic(market, lpToRemove, baseToken);
     }
 
     function swapExactPtForScyStatic(address market, uint256 exactPtIn)
@@ -296,13 +388,7 @@ contract RouterStatic is IPRouterStatic {
             uint256 priceImpact
         )
     {
-        MarketState memory state = IPMarket(market).readState(false);
-        (netScyOut, netScyFee) = state.swapExactPtForScy(
-            pyIndex(market),
-            exactPtIn,
-            block.timestamp
-        );
-        priceImpact = calcPriceImpact(market, exactPtIn.neg());
+        return MarketMathStatic.swapExactPtForScyStatic(market, exactPtIn);
     }
 
     function swapScyForExactPtStatic(address market, uint256 exactPtOut)
@@ -313,13 +399,7 @@ contract RouterStatic is IPRouterStatic {
             uint256 priceImpact
         )
     {
-        MarketState memory state = IPMarket(market).readState(false);
-        (netScyIn, netScyFee) = state.swapScyForExactPt(
-            pyIndex(market),
-            exactPtOut,
-            block.timestamp
-        );
-        priceImpact = calcPriceImpact(market, exactPtOut.Int());
+        return MarketMathStatic.swapScyForExactPtStatic(market, exactPtOut);
     }
 
     function swapExactScyForPtStatic(address market, uint256 exactScyIn)
@@ -330,14 +410,7 @@ contract RouterStatic is IPRouterStatic {
             uint256 priceImpact
         )
     {
-        MarketState memory state = IPMarket(market).readState(false);
-        (netPtOut, , netScyFee) = state.approxSwapExactScyForPt(
-            pyIndex(market),
-            exactScyIn,
-            block.timestamp,
-            approxParams
-        );
-        priceImpact = calcPriceImpact(market, netPtOut.Int());
+        return MarketMathStatic.swapExactScyForPtStatic(market, exactScyIn, approxParams);
     }
 
     function swapPtForExactScyStatic(address market, uint256 exactScyOut)
@@ -348,15 +421,7 @@ contract RouterStatic is IPRouterStatic {
             uint256 priceImpact
         )
     {
-        MarketState memory state = IPMarket(market).readState(false);
-
-        (netPtIn, , netScyFee) = state.approxSwapPtForExactScy(
-            pyIndex(market),
-            exactScyOut,
-            block.timestamp,
-            approxParams
-        );
-        priceImpact = calcPriceImpact(market, netPtIn.neg());
+        return MarketMathStatic.swapPtForExactScyStatic(market, exactScyOut, approxParams);
     }
 
     function swapExactBaseTokenForPtStatic(
@@ -371,9 +436,13 @@ contract RouterStatic is IPRouterStatic {
             uint256 priceImpact
         )
     {
-        (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
-
-        return swapExactScyForPtStatic(market, SCY.previewDeposit(baseToken, amountBaseToken));
+        return
+            MarketMathStatic.swapExactBaseTokenForPtStatic(
+                market,
+                baseToken,
+                amountBaseToken,
+                approxParams
+            );
     }
 
     function swapExactPtForBaseTokenStatic(
@@ -388,11 +457,7 @@ contract RouterStatic is IPRouterStatic {
             uint256 priceImpact
         )
     {
-        uint256 netScyOut;
-        (netScyOut, netScyFee, priceImpact) = swapExactPtForScyStatic(market, exactYtIn);
-
-        (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
-        netBaseTokenOut = SCY.previewRedeem(baseToken, netScyOut);
+        return MarketMathStatic.swapExactPtForBaseTokenStatic(market, exactYtIn, baseToken);
     }
 
     function swapScyForExactYtStatic(address market, uint256 exactYtOut)
@@ -403,21 +468,7 @@ contract RouterStatic is IPRouterStatic {
             uint256 priceImpact
         )
     {
-        MarketState memory state = IPMarket(market).readState(false);
-
-        PYIndex index = pyIndex(market);
-
-        uint256 scyReceived;
-        (scyReceived, netScyFee) = state.swapExactPtForScy(
-            pyIndex(market),
-            exactYtOut,
-            block.timestamp
-        );
-
-        uint256 totalScyNeed = index.assetToScyUp(exactYtOut);
-        netScyIn = totalScyNeed.subMax0(scyReceived);
-
-        priceImpact = calcPriceImpact(market, exactYtOut.neg());
+        return MarketMathStatic.swapScyForExactYtStatic(market, exactYtOut);
     }
 
     function swapExactScyForYtStatic(address market, uint256 exactScyIn)
@@ -428,17 +479,7 @@ contract RouterStatic is IPRouterStatic {
             uint256 priceImpact
         )
     {
-        MarketState memory state = IPMarket(market).readState(false);
-        PYIndex index = pyIndex(market);
-
-        (netYtOut, , netScyFee) = state.approxSwapExactScyForYt(
-            index,
-            exactScyIn,
-            block.timestamp,
-            approxParams
-        );
-
-        priceImpact = calcPriceImpact(market, netYtOut.neg());
+        return MarketMathStatic.swapExactScyForYtStatic(market, exactScyIn, approxParams);
     }
 
     function swapExactYtForScyStatic(address market, uint256 exactYtIn)
@@ -449,18 +490,7 @@ contract RouterStatic is IPRouterStatic {
             uint256 priceImpact
         )
     {
-        MarketState memory state = IPMarket(market).readState(false);
-
-        PYIndex index = pyIndex(market);
-
-        uint256 scyOwed;
-        (scyOwed, netScyFee) = state.swapScyForExactPt(index, exactYtIn, block.timestamp);
-
-        uint256 amountPYToRepayScyOwed = index.scyToAssetUp(scyOwed);
-        uint256 amountPYToRedeemScyOut = exactYtIn - amountPYToRepayScyOwed;
-
-        netScyOut = index.assetToScy(amountPYToRedeemScyOut);
-        priceImpact = calcPriceImpact(market, exactYtIn.Int());
+        return MarketMathStatic.swapExactYtForScyStatic(market, exactYtIn);
     }
 
     function swapYtForExactScyStatic(address market, uint256 exactScyOut)
@@ -471,17 +501,7 @@ contract RouterStatic is IPRouterStatic {
             uint256 priceImpact
         )
     {
-        MarketState memory state = IPMarket(market).readState(false);
-
-        PYIndex index = pyIndex(market);
-
-        (netYtIn, , netScyFee) = state.approxSwapYtForExactScy(
-            index,
-            exactScyOut,
-            block.timestamp,
-            approxParams
-        );
-        priceImpact = calcPriceImpact(market, netYtIn.Int());
+        return MarketMathStatic.swapYtForExactScyStatic(market, exactScyOut, approxParams);
     }
 
     function swapExactYtForBaseTokenStatic(
@@ -496,11 +516,7 @@ contract RouterStatic is IPRouterStatic {
             uint256 priceImpact
         )
     {
-        uint256 netScyOut;
-        (netScyOut, netScyFee, priceImpact) = swapExactYtForScyStatic(market, exactYtIn);
-
-        (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
-        netBaseTokenOut = SCY.previewRedeem(baseToken, netScyOut);
+        return MarketMathStatic.swapExactYtForBaseTokenStatic(market, exactYtIn, baseToken);
     }
 
     function swapExactBaseTokenForYtStatic(
@@ -515,9 +531,13 @@ contract RouterStatic is IPRouterStatic {
             uint256 priceImpact
         )
     {
-        (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
-
-        return swapExactScyForYtStatic(market, SCY.previewDeposit(baseToken, amountBaseToken));
+        return
+            MarketMathStatic.swapExactBaseTokenForYtStatic(
+                market,
+                baseToken,
+                amountBaseToken,
+                approxParams
+            );
     }
 
     // ============= OTHER HELPERS =============
@@ -557,27 +577,12 @@ contract RouterStatic is IPRouterStatic {
         return SCY.previewRedeem(baseToken, redeemPYToScyStatic(YT, amountPYToRedeem));
     }
 
-    function pyIndex(address market) public returns (PYIndex index) {
-        (, , IPYieldToken YT) = IPMarket(market).readTokens();
-
-        return YT.newIndex();
-    }
-
-    function getPY(address py) public view returns (address pt, address yt) {
-        if (yieldContractFactory.isYT(py)) {
-            pt = IPYieldToken(py).PT();
-            yt = py;
-        } else {
-            pt = py;
-            yt = IPPrincipalToken(py).YT();
-        }
+    function getPtImpliedYield(address market) public view returns (int256) {
+        return MarketMathStatic.getPtImpliedYield(market);
     }
 
-    function getPtImpliedYield(address market) public returns (int256) {
-        MarketState memory state = IPMarket(market).readState(false);
-
-        int256 lnImpliedRate = (state.lastLnImpliedRate).Int();
-        return lnImpliedRate.exp();
+    function pyIndex(address market) public returns (PYIndex index) {
+        return MarketMathStatic.pyIndex(market);
     }
 
     function getExchangeRate(address market) public returns (uint256) {
@@ -588,100 +593,29 @@ contract RouterStatic is IPRouterStatic {
         public
         returns (uint256)
     {
-        int256 netPtToAccount = netPtOut;
-        MarketState memory state = IPMarket(market).readState(false);
-        MarketPreCompute memory comp = state.getMarketPreCompute(pyIndex(market), block.timestamp);
-
-        int256 preFeeExchangeRate = MarketMathCore._getExchangeRate(
-            state.totalPt,
-            comp.totalAsset,
-            comp.rateScalar,
-            comp.rateAnchor,
-            netPtToAccount
-        );
-
-        if (netPtToAccount > 0) {
-            int256 postFeeExchangeRate = preFeeExchangeRate.divDown(comp.feeRate);
-            require(postFeeExchangeRate >= Math.IONE, "exchange rate below 1");
-            return postFeeExchangeRate.Uint();
-        } else {
-            return preFeeExchangeRate.mulDown(comp.feeRate).Uint();
-        }
+        return MarketMathStatic.getTradeExchangeRateIncludeFee(market, netPtOut);
     }
 
     function calcPriceImpact(address market, int256 netPtOut)
         public
         returns (uint256 priceImpact)
     {
-        uint256 preTradeRate = getExchangeRate(market);
-        uint256 tradedRate = getTradeExchangeRateIncludeFee(market, netPtOut);
-
-        priceImpact = (tradedRate.Int() - preTradeRate.Int()).abs().divDown(preTradeRate);
+        return MarketMathStatic.calcPriceImpact(market, netPtOut);
     }
 
-    function getUserPYInfo(address py, address user)
+    // either but not both pyToken or market must be != 0
+    function getTokensInOut(address pyToken, address market)
         public
         view
-        returns (UserPYInfo memory userPYInfo)
+        returns (address[] memory tokensIn, address[] memory tokensOut)
     {
-        (userPYInfo.pt, userPYInfo.yt) = 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.userInterest(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.userReward(rewardToken, user);
-            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 getUserMarketInfo(address market, address user)
-        public
-        view
-        returns (UserMarketInfo memory userMarketInfo)
-    {
-        IPMarket _market = IPMarket(market);
-        uint256 userLp = _market.balanceOf(user);
-
-        userMarketInfo.market = market;
-        userMarketInfo.lpBalance = userLp;
-
-        (ISuperComposableYield SCY, IPPrincipalToken PT, ) = _market.readTokens();
-        (userMarketInfo.assetBalance.assetType, userMarketInfo.assetBalance.assetAddress, ) = SCY
-            .assetInfo();
-
-        MarketState memory state = _market.readState(false);
-        uint256 totalLp = uint256(state.totalLp);
-
-        if (totalLp == 0) {
-            return userMarketInfo;
+        if (pyToken != address(0)) {
+            // SCY interface is shared between pt & yt
+            ISuperComposableYield SCY = ISuperComposableYield(IPPrincipalToken(pyToken).SCY());
+            return (SCY.getTokensIn(), SCY.getTokensOut());
+        } else {
+            (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
+            return (SCY.getTokensIn(), SCY.getTokensOut());
         }
-
-        uint256 userPt = (userLp * uint256(state.totalPt)) / totalLp;
-        uint256 userScy = (userLp * uint256(state.totalScy)) / totalLp;
-
-        userMarketInfo.ptBalance = TokenAmount(address(PT), userPt);
-        userMarketInfo.scyBalance = TokenAmount(address(SCY), userScy);
-        userMarketInfo.assetBalance.amount = (userScy * SCY.exchangeRate()) / Math.ONE;
-    }
-
-    function hasPYPosition(UserPYInfo calldata userPYInfo) public pure returns (bool hasPosition) {
-        hasPosition = (userPYInfo.ytBalance > 0 ||
-            userPYInfo.ptBalance > 0 ||
-            userPYInfo.unclaimedInterest.amount > 0 ||
-            userPYInfo.unclaimedRewards.length > 0);
     }
 }