@pendle/core-v2 3.0.0 → 4.0.1

package/contracts/limit/Mock.sol

@@ -1,429 +0,0 @@
-// import "../pendle/contracts/limit/PendleLimitRouter.sol";
-import "./PendleLimitRouter.sol";
-import "hardhat/console.sol";
-
-contract PendleLimitRouterMock is PendleLimitRouter {
-    using PYIndexLib for PYIndex;
-    using PYIndexLib for IPYieldToken;
-    using PMath for uint256;
-    using PMath for int256;
-
-    uint256 public constant MAKE_SY = 1e18;
-    uint256 public constant MAKE_PT = 1e18;
-    uint256 public constant MAKE_YT = 1e18;
-    uint256 public constant R = 1021525557649751706;
-    uint256 public constant INDEX = 1034898125855333936;
-    uint256 public constant FEE_RATE = 1000524863070060643;
-    uint256 public constant IMPLIED_RATE = 40566962068769599;
-
-    constructor(address _WNATIVE) PendleLimitRouter(_WNATIVE) {}
-
-    function flashFill(FillOrderParams[] memory params, address receiver, uint256 maxInput, bytes memory callback)
-        external
-        returns (uint256 netOutputToTaker, uint256 netInputFromTaker, uint256 totalFee)
-    {
-        _validateOrdersSkipSig(params);
-        OrderType orderType = params[0].order.orderType;
-        if (orderType == OrderType.SY_FOR_PT || orderType == OrderType.SY_FOR_YT) {
-            return flashFillTokenForPY(Args(orderType, params, receiver, maxInput, callback));
-        } else {
-            return flashFillPYForToken(Args(orderType, params, receiver, maxInput, callback));
-        }
-    }
-
-    function flashFillTokenForPY(Args memory a)
-        internal
-        returns (uint256 totalPYToTaker, uint256 totalSyFromTaker, uint256 totalFee)
-    {
-        (address SY, address PT, address YT, bytes32[] memory orderHashes) = _checkSig_updMakingAndRemaining(a.params);
-
-        // Token => This
-        uint256[] memory fromMakers = _transferFromMakers_mintSy_updMakings(SY, a.params);
-
-        NormalResults memory out;
-        (totalSyFromTaker, totalPYToTaker, totalFee, out) = calcFlashBatch(a.params, YT, lnFeeRateRoot);
-
-        require(totalSyFromTaker <= a.maxTaking, "LOP: maxInput exceeded");
-
-        // Taker => This
-        _transferFrom(IERC20(SY), msg.sender, address(this), totalSyFromTaker);
-
-        // This => YT
-        _transferOut(SY, YT, totalSyFromTaker + out.totalMaking - out.totalFee);
-
-        bool isPtToMaker = (a.orderType == OrderType.SY_FOR_PT);
-        address pyToMaker = isPtToMaker ? PT : YT;
-        {
-            address receiverPt = isPtToMaker ? address(this) : a.receiver;
-            address receiverYt = isPtToMaker ? a.receiver : address(this);
-
-            // PT => receiverPt, YT => receiverYt
-            IPYieldToken(YT).mintPY(receiverPt, receiverYt);
-        }
-
-        // This => Makers
-        _transferToMakers(IERC20(pyToMaker), address(this), a.params, out.netTakings);
-
-        // This => Fee
-        _transferOut(SY, feeRecipient, totalFee);
-
-        // toMakers == netTakings
-        _checkSafety_emitEvents(a.params, orderHashes, fromMakers, out.netTakings, out.netFees, out.notionalVolumes);
-    }
-
-    function flashFillPYForToken(Args memory a)
-        internal
-        returns (uint256 totalSyToTaker, uint256 totalPYFromTaker, uint256 totalFee)
-    {
-        (address SY, address PT, address YT, bytes32[] memory orderHashes) = _checkSig_updMakingAndRemaining(a.params);
-
-        NormalResults memory out;
-        (totalPYFromTaker, totalSyToTaker, totalFee, out) = calcFlashBatch(a.params, YT, lnFeeRateRoot);
-
-        require(totalPYFromTaker <= a.maxTaking, "LOP: maxInput exceeded");
-
-        bool ptFromTaker = (a.orderType == OrderType.YT_FOR_SY);
-        address pyFromTaker = ptFromTaker ? PT : YT;
-        address pyFromMaker = ptFromTaker ? YT : PT;
-
-        // Taker => YT
-        _transferFrom(IERC20(pyFromTaker), msg.sender, YT, totalPYFromTaker);
-        // Maker => YT
-        _transferFromMakers(IERC20(pyFromMaker), a.params, YT, out.netMakings);
-
-        // YT => This
-        IPYieldToken(YT).redeemPY(address(this));
-
-        // This => Taker
-        _transferOut(SY, a.receiver, totalSyToTaker);
-
-        // This => Makers
-        uint256[] memory toMakers = _redeemSy_transferToMakers(SY, a.params, out.netTakings);
-
-        // This => Fee
-        _transferOut(SY, feeRecipient, totalFee);
-
-        // fromMakers == netMakings
-        _checkSafety_emitEvents(a.params, orderHashes, out.netMakings, toMakers, out.netFees, out.notionalVolumes);
-    }
-
-    function calcFlashBatch(FillOrderParams[] memory params, address YT, uint256 lnFeeRateRoot)
-        internal
-        returns (
-            uint256 netInputFromTaker,
-            uint256 netOutputToTaker,
-            uint256 netFee,
-            IPOrderMixinType.NormalResults memory out
-        )
-    {
-        function (uint256, uint256, uint256, PYIndex) internal pure returns (uint256, uint256) calcFlash =
-            getCalcFunctions2(params[0].order.orderType);
-
-        uint256 timeToExpiry = IPYieldToken(YT).expiry() - block.timestamp;
-        uint256 pyIndex = IPYieldToken(YT).pyIndexCurrent();
-
-        out = LimitMath.calcNormalBatch(params, timeToExpiry, pyIndex, lnFeeRateRoot);
-        (netInputFromTaker, netOutputToTaker) =
-            calcFlash(out.totalMaking, out.totalTaking, out.totalFee, PYIndex.wrap(pyIndex));
-        netFee = out.totalFee;
-    }
-
-    // Proof of index.syToAsset(index.assetToSyUp(takePt)) >= takePt at end of this file
-    function calcSyForPtFlash(uint256 makeSy, uint256 takePt, uint256 fee, PYIndex index)
-        internal
-        pure
-        returns (uint256 syFromTaker, uint256 ytToTaker)
-    {
-        uint256 syToMintPy = index.assetToSyUp(takePt);
-
-        syFromTaker = syToMintPy - (makeSy - fee);
-        ytToTaker = takePt;
-    }
-
-    function calcPtForSyFlash(uint256 makePt, uint256 takeSy, uint256 fee, PYIndex index)
-        internal
-        pure
-        returns (uint256 ytFromTaker, uint256 syToTaker)
-    {
-        uint256 syRedeemFromPy = index.assetToSy(makePt);
-        syToTaker = syRedeemFromPy - (takeSy + fee);
-
-        ytFromTaker = makePt;
-    }
-
-    function calcSyForYtFlash(uint256 makeSy, uint256 takeYt, uint256 fee, PYIndex index)
-        internal
-        pure
-        returns (uint256 syFromTaker, uint256 ptToTaker)
-    {
-        uint256 syToMintPy = index.assetToSyUp(takeYt);
-
-        syFromTaker = syToMintPy - (makeSy - fee);
-        ptToTaker = takeYt;
-    }
-
-    function calcYtForSyFlash(uint256 makeYt, uint256 takeSy, uint256 fee, PYIndex index)
-        internal
-        pure
-        returns (uint256 ptFromTaker, uint256 syToTaker)
-    {
-        uint256 syRedeemFromPy = index.assetToSy(makeYt);
-
-        syToTaker = syRedeemFromPy - (takeSy + fee);
-        ptFromTaker = makeYt;
-    }
-
-    /// @dev diff sig for calcNormal and calcFlash to avoid miscalling
-    function getCalcFunctions2(IPOrderMixinType.OrderType t)
-        internal
-        pure
-        returns (function (uint256, uint256, uint256, PYIndex) internal pure returns (uint256, uint256) calcFlash)
-    {
-        if (t == IPOrderMixinType.OrderType.SY_FOR_PT) {
-            return calcSyForPtFlash;
-        } else if (t == IPOrderMixinType.OrderType.PT_FOR_SY) {
-            return calcPtForSyFlash;
-        } else if (t == IPOrderMixinType.OrderType.SY_FOR_YT) {
-            return calcSyForYtFlash;
-        } else {
-            return calcYtForSyFlash;
-        }
-    }
-
-    function runAllTests(address YT) public {
-        testCalcSyForPtNormal();
-        testCalcPtForSyNormal();
-        testCalcSyForYtNormal();
-        testCalcYtForSyNormal();
-        testCalcSyForPtFlash();
-        testCalcPtForSyFlash();
-        testCalcSyForYtFlash();
-        testCalcYtForSyFlash();
-    }
-
-    function normalFillTokenForPYStatic(FillOrderParams[] memory params)
-        public
-        returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee)
-    {
-        address YT = params[0].order.YT;
-        _updMaking(params);
-        _mintSyStatic(params);
-        NormalResults memory out = LimitMath.calcNormalBatch(params, YT, lnFeeRateRoot);
-        (actualMaking, actualTaking, totalFee) = (out.totalMaking - out.totalFee, out.totalTaking, out.totalFee);
-    }
-
-    function normalFillPYForTokenStatic(FillOrderParams[] memory params)
-        public
-        returns (
-            uint256 actualMaking,
-            uint256 actualTaking,
-            uint256 totalFee,
-            uint256 actualTokenOut,
-            uint256[] memory tokensOut
-        )
-    {
-        address YT = params[0].order.YT;
-        _updMaking(params);
-        NormalResults memory out = LimitMath.calcNormalBatch(params, YT, lnFeeRateRoot);
-        (actualMaking, actualTaking, totalFee) = (out.totalMaking, out.totalTaking + out.totalFee, out.totalFee);
-
-        tokensOut = _redeemSyStatic(params, out.netTakings);
-
-        for (uint256 i = 0; i < params.length; i = _inc1(i)) {
-            actualTokenOut += tokensOut[i];
-        }
-    }
-
-    function flashFillTokenForPYStatic(FillOrderParams[] memory params)
-        public
-        returns (uint256 totalPYToTaker, uint256 totalSyFromTaker, uint256 totalFee)
-    {
-        address YT = params[0].order.YT;
-        _updMaking(params);
-        _mintSyStatic(params);
-        NormalResults memory out;
-        (totalSyFromTaker, totalPYToTaker, totalFee, out) = calcFlashBatch(params, YT, lnFeeRateRoot);
-    }
-
-    function flashFillPYForTokenStatic(FillOrderParams[] memory params)
-        public
-        returns (
-            uint256 totalSyToTaker,
-            uint256 totalPYFromTaker,
-            uint256 totalFee,
-            uint256 actualTokenOut,
-            uint256[] memory tokensOut
-        )
-    {
-        address YT = params[0].order.YT;
-        _updMaking(params);
-        NormalResults memory out;
-        (totalPYFromTaker, totalSyToTaker, totalFee, out) = calcFlashBatch(params, YT, lnFeeRateRoot);
-
-        tokensOut = _redeemSyStatic(params, out.netTakings);
-        for (uint256 i = 0; i < params.length; i = _inc1(i)) {
-            actualTokenOut += tokensOut[i];
-        }
-    }
-
-    function _updMaking(FillOrderParams[] memory params) internal {
-        uint256 len = params.length;
-
-        for (uint256 i = 0; i < len; i = _inc1(i)) {
-            FillOrderParams memory param = params[i];
-
-            uint256 remainingMakerAmount = _status[hashOrder(param.order)].remaining;
-            if (remainingMakerAmount == 0) remainingMakerAmount = param.order.makingAmount;
-            else remainingMakerAmount--;
-
-            uint256 netMaking = PMath.min(param.makingAmount, remainingMakerAmount);
-
-            param.makingAmount = netMaking;
-        }
-    }
-
-    function _mintSyStatic(FillOrderParams[] memory params) internal {
-        address YT = params[0].order.YT;
-        address SY = IPYieldToken(YT).SY();
-
-        uint256 len = params.length;
-
-        for (uint256 i = 0; i < len; i = _inc1(i)) {
-            params[i].makingAmount =
-                IStandardizedYield(SY).previewDeposit(params[i].order.token, params[i].makingAmount);
-        }
-    }
-
-    function _redeemSyStatic(FillOrderParams[] memory params, uint256[] memory netSyOuts)
-        internal
-        returns (uint256[] memory tokensOut)
-    {
-        uint256 len = params.length;
-        tokensOut = new uint256[](len);
-
-        for (uint256 i = 0; i < len; i = _inc1(i)) {
-            FillOrderParams memory param = params[i];
-            uint256 netSyOut = netSyOuts[i];
-
-            if (netSyOut == 0) continue;
-
-            tokensOut[i] =
-                IStandardizedYield(IPYieldToken(param.order.YT).SY()).previewRedeem(param.order.token, netSyOut);
-        }
-    }
-
-    function transferFromMakers_mintSy_updMakings(address SY, FillOrderParams[] memory params)
-        public
-        payable
-        returns (uint256[] memory newMakings)
-    {
-        newMakings = new uint256[](params.length);
-        _transferFromMakers_mintSy_updMakings(SY, params);
-
-        for (uint256 i = 0; i < params.length; i = _inc1(i)) {
-            newMakings[i] = params[i].makingAmount;
-        }
-    }
-
-    function redeemSy_transferToMakers(address SY, FillOrderParams[] memory params, uint256[] memory netSyOuts)
-        public
-        returns (uint256[] memory toMakers)
-    {
-        return _redeemSy_transferToMakers(SY, params, netSyOuts);
-    }
-
-    function testCalcSyForPtNormal() public returns (uint256 takePt, uint256 fee) {
-        console.log("testCalcSyForPtNormal");
-        (takePt, fee,) = LimitMath.calcSyForPtNormal(MAKE_SY, R, PYIndex.wrap(INDEX), FEE_RATE);
-        console.log("takePt: %s, fee: %s", takePt, fee);
-        require(takePt == 1057174885125052923 && fee == 524863070060643);
-
-        // trade 1 SY (1.0349 asset) -> 1.0572 PT, fee of 0.00052486 SY (0.00054318 asset) 0.052% fee
-    }
-
-    function testCalcPtForSyNormal() public returns (uint256 takeSy, uint256 fee) {
-        console.log("testCalcPtForSyNormal");
-        (takeSy, fee,) = LimitMath.calcPtForSyNormal(MAKE_PT, R, PYIndex.wrap(INDEX), FEE_RATE);
-        console.log("takeSy: %s, fee: %s", takeSy, fee);
-        require(takeSy == 945917287735898378 && fee == 496216605893315);
-
-        // trade 1 PT -> 0.94592 SY (0.97893 asset), fee of 0.00049622 SY (0.00051353 asset) 0.052459% fee
-    }
-
-    function testCalcSyForYtNormal() public returns (uint256 takeYt, uint256 fee) {
-        console.log("testCalcSyForYtNormal");
-        (takeYt, fee,) = LimitMath.calcSyForYtNormal(MAKE_SY, R, PYIndex.wrap(INDEX), FEE_RATE);
-        console.log("takeYt: %s, fee: %s", takeYt, fee);
-        require(takeYt == 49112543439135815980 && fee == 24370459612155973);
-
-        // trade 1 SY (1.0349 asset) -> 49.11254 YT, fee of 0.02437 SY (0.025221 asset) 2.437% fee
-        // PT / YT ratio = 46.45
-    }
-
-    function testCalcYtForSyNormal() public returns (uint256 takeSy, uint256 fee) {
-        console.log("testCalcYtForSyNormal");
-        (takeSy, fee,) = LimitMath.calcYtForSyNormal(MAKE_YT, R, PYIndex.wrap(INDEX), FEE_RATE);
-        console.log("takeSy: %s, fee: %s", takeSy, fee);
-        require(takeSy == 20361397109055853 && fee == 496477051664500);
-
-        // trade 1 YT -> 0.02036 SY (0.02107 asset), fee of 0.0004964770517 SY (0.0005138031711 asset) 2.438% fee
-        // PT / YT ratio = 46.45
-    }
-
-    function testCalcSyForPtFlash() public {
-        console.log("testCalcSyForPtFlash");
-
-        (uint256 takePt, uint256 fee) = testCalcSyForPtNormal();
-        (uint256 syFromTaker, uint256 ytToTaker) = calcSyForPtFlash(MAKE_SY, takePt, fee, PYIndex.wrap(INDEX));
-
-        console.log("syFromTaker: %s, ytToTaker: %s", syFromTaker, ytToTaker);
-        require(syFromTaker == 22050420719812349 && ytToTaker == 1057174885125052923);
-
-        // trade 1 SY (1.0349 asset) -> 1.0572 PT, fee of 0.00052486 SY (0.00054318 asset) 0.052% fee
-        // flash fill 0.02205 SY (0.02281 asset) to 1.0572 YT 2.38% fee
-
-        // rough formula syFromTaker = makeSy * (r-1) + makeSy * (f-1)
-    }
-
-    function testCalcPtForSyFlash() public {
-        console.log("testCalcPtForSyFlash");
-
-        (uint256 takeSy, uint256 fee) = testCalcPtForSyNormal();
-        (uint256 ytFromTaker, uint256 syToTaker) = calcPtForSyFlash(MAKE_PT, takeSy, fee, PYIndex.wrap(INDEX));
-
-        console.log("ytFromTaker: %s, syToTaker: %s", ytFromTaker, syToTaker);
-        require(ytFromTaker == 1e18 && syToTaker == 19865180503162537);
-        // trade 1 PT -> 0.94592 SY (0.97893 asset), fee of 0.00049622 SY (0.00051353 asset) 0.052459% fee
-        // flash fill 1 YT to 0.019865 SY (0.020558 asset) 2.498% fee
-
-        // rough formula syToTaker = takeSy * (r-1) - takeSy * (f-1)/f)
-    }
-
-    function testCalcSyForYtFlash() public {
-        console.log("testCalcSyForYtFlash");
-
-        (uint256 takeYt, uint256 fee) = testCalcSyForYtNormal();
-        (uint256 syFromTaker, uint256 ptToTaker) = calcSyForYtFlash(MAKE_SY, takeYt, fee, PYIndex.wrap(INDEX));
-
-        console.log("syFromTaker: %s, ptToTaker: %s", syFromTaker, ptToTaker);
-        require(syFromTaker == 46480774343370997703 && ptToTaker == 49112543439135815980);
-        // trade 1 SY (1.0349 asset) -> 49.11254 YT, fee of 0.02437 SY (0.025221 asset) 2.437% fee
-        // flash fill 46.48077 SY (48.07977 asset) to 49.11254 PT 0.052% fee
-
-        // rough formula syFromTaker = (makeSy + makeSy * (f-1)/f) / (r-1)
-    }
-
-    function testCalcYtForSyFlash() public {
-        console.log("testCalcYtForSyFlash");
-
-        (uint256 takeSy, uint256 fee) = testCalcYtForSyNormal();
-        (uint256 ptFromTaker, uint256 syToTaker) = calcYtForSyFlash(MAKE_YT, takeSy, fee, PYIndex.wrap(INDEX));
-
-        console.log("ptFromTaker: %s, syToTaker: %s", ptFromTaker, syToTaker);
-        require(ptFromTaker == 1e18 && syToTaker == 945420810684233877);
-        // trade 1 YT -> 0.02036 SY (0.02107 asset), fee of 0.0004968 SY (0.0005138 asset) 2.438% fee
-        // flash fill 1 PT to 0.94542 SY 0.0525% fee
-
-        // rough formula syToTaker = (takeSy - takeSy * (f-1)) / (r-1)
-    }
-}

package/contracts/offchain-helpers/BulkSellerOffchain.sol

@@ -1,57 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.17;
-
-import "../core/BulkSeller/BulkSellerMathCore.sol";
-import "../core/BulkSeller/BulkSeller.sol";
-
-contract BulkSellerOffchain {
-    using BulkSellerMathCore for BulkSellerState;
-    using PMath for uint256;
-
-    function calcCurrentRates(IPBulkSeller bulk) external view returns (uint256 rateTokenToSy, uint256 rateSyToToken) {
-        BulkSellerState memory state = bulk.readState();
-        address SY = bulk.SY();
-        address token = bulk.token();
-
-        {
-            uint256 hypoTotalToken = state.totalToken + state.totalSy.mulDown(state.rateSyToToken);
-            uint256 netSyFromToken = IStandardizedYield(SY).previewDeposit(token, hypoTotalToken);
-
-            rateTokenToSy = netSyFromToken.divDown(hypoTotalToken);
-        }
-
-        {
-            uint256 hypoTotalSy = state.totalSy + state.totalToken.mulDown(state.rateTokenToSy);
-            uint256 netTokenFromSy = IStandardizedYield(SY).previewRedeem(token, hypoTotalSy);
-            rateSyToToken = netTokenFromSy.divDown(hypoTotalSy);
-        }
-    }
-
-    function getCurrentState(
-        IPBulkSeller bulk
-    ) external view returns (BulkSellerState memory state, uint256 tokenProp, uint256 hypoTokenBal) {
-        state = bulk.readState();
-
-        tokenProp = state.getTokenProp();
-        hypoTokenBal = state.totalToken + IStandardizedYield(bulk.SY()).previewRedeem(bulk.token(), state.totalSy);
-    }
-
-    function calcCurrentRatesWithAmount(
-        IPBulkSeller bulk,
-        uint256 hypoTotalToken,
-        uint256 hypoTotalSy
-    ) external view returns (uint256 rateTokenToSy, uint256 rateSyToToken) {
-        address SY = bulk.SY();
-        address token = bulk.token();
-
-        {
-            uint256 netSyFromToken = IStandardizedYield(SY).previewDeposit(token, hypoTotalToken);
-            rateTokenToSy = netSyFromToken.divDown(hypoTotalToken);
-        }
-
-        {
-            uint256 netTokenFromSy = IStandardizedYield(SY).previewRedeem(token, hypoTotalSy);
-            rateSyToToken = netTokenFromSy.divDown(hypoTotalSy);
-        }
-    }
-}

package/contracts/offchain-helpers/router-static/PendleRouterStatic.sol

@@ -1,19 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.17;
-
-import "@openzeppelin/contracts/proxy/Proxy.sol";
-import "../../interfaces/IPRouterStatic.sol";
-import "./base/StorageLayout.sol";
-
-// solhint-disable no-empty-blocks
-contract PendleRouterStatic is Proxy, StorageLayout {
-    constructor(address actionStorage) {
-        owner = msg.sender;
-        selectorToFacet[IPMiniDiamond.setFacetForSelectors.selector] = actionStorage;
-    }
-
-    function _implementation() internal view override returns (address res) {
-        res = selectorToFacet[msg.sig];
-        require(res != address(0), "selector not found");
-    }
-}

package/contracts/offchain-helpers/router-static/base/ActionInfoStatic.sol

@@ -1,111 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.17;
-
-import "../../../interfaces/IPMarket.sol";
-import "../../../interfaces/IPRouterStatic.sol";
-import "../../../interfaces/IPYieldContractFactory.sol";
-import "../../../interfaces/IPMarketFactory.sol";
-import "../../../interfaces/IPBulkSellerFactory.sol";
-import "../../../interfaces/IPBulkSeller.sol";
-
-// solhint-disable no-empty-blocks
-contract ActionInfoStatic is IPActionInfoStatic {
-    function getPY(address py) public view returns (address pt, address yt) {
-        try IPYieldToken(py).PT() returns (address _pt) {
-            pt = _pt;
-            yt = py;
-        } catch {
-            pt = py;
-            yt = IPPrincipalToken(py).YT();
-        }
-    }
-
-    /// can be SY, PY or Market
-    function getTokensInOut(
-        address token
-    ) external view returns (address[] memory tokensIn, address[] memory tokensOut) {
-        try IStandardizedYield(token).getTokensIn() returns (address[] memory res) {
-            return (res, IStandardizedYield(token).getTokensOut());
-        } catch {}
-
-        try IPYieldToken(token).SY() returns (address SY) {
-            return (IStandardizedYield(SY).getTokensIn(), IStandardizedYield(SY).getTokensOut());
-        } catch {}
-
-        try IPMarket(token).readTokens() returns (IStandardizedYield SY, IPPrincipalToken, IPYieldToken) {
-            return (SY.getTokensIn(), SY.getTokensOut());
-        } catch {}
-
-        revert("invalid token");
-    }
-
-    function getUserSYInfo(address sy, address user) external returns (UserSYInfo memory res) {
-        IStandardizedYield SY = IStandardizedYield(sy);
-
-        // SY
-        res.syBalance = TokenAmount(sy, _balanceOf(sy, user));
-
-        // Rewards
-        uint256[] memory rewardsOut = SY.claimRewards(user);
-        address[] memory rewardTokens = SY.getRewardTokens();
-
-        res.unclaimedRewards = _zipTokenAmounts(rewardTokens, rewardsOut);
-    }
-
-    function getUserPYInfo(address py, address user) external returns (UserPYInfo memory res) {
-        (address _PT, address _YT) = getPY(py);
-        IPYieldToken YT = IPYieldToken(_YT);
-
-        // PT / YT
-        res.ytBalance = TokenAmount(_YT, _balanceOf(_YT, user));
-        res.ptBalance = TokenAmount(_PT, _balanceOf(_PT, user));
-
-        // interest
-        (uint256 interestOut, uint256[] memory rewardsOut) = YT.redeemDueInterestAndRewards(user, true, true);
-
-        res.unclaimedInterest = TokenAmount(YT.SY(), interestOut);
-
-        // Rewards
-        address[] memory rewardTokens = YT.getRewardTokens();
-        res.unclaimedRewards = _zipTokenAmounts(rewardTokens, rewardsOut);
-    }
-
-    function getUserMarketInfo(address market, address user) external returns (UserMarketInfo memory res) {
-        IPMarket _market = IPMarket(market);
-        MarketState memory state = _market.readState(address(this));
-
-        if (uint256(state.totalLp) == 0) return res; // market not initialized
-
-        // LP PT SY
-        (IStandardizedYield SY, IPPrincipalToken PT, ) = _market.readTokens();
-
-        uint256 userLp = _balanceOf(market, user);
-        uint256 userPt = (userLp * uint256(state.totalPt)) / uint256(state.totalLp);
-        uint256 userSy = (userLp * uint256(state.totalSy)) / uint256(state.totalLp);
-
-        res.lpBalance = TokenAmount(market, userLp);
-        res.ptBalance = TokenAmount(address(PT), userPt);
-        res.syBalance = TokenAmount(address(SY), userSy);
-
-        // Rewards
-        uint256[] memory rewardsOut = _market.redeemRewards(user);
-        address[] memory rewardTokens = _market.getRewardTokens();
-
-        res.unclaimedRewards = _zipTokenAmounts(rewardTokens, rewardsOut);
-    }
-
-    function _zipTokenAmounts(
-        address[] memory tokens,
-        uint256[] memory amounts
-    ) internal pure returns (TokenAmount[] memory res) {
-        res = new TokenAmount[](tokens.length);
-
-        for (uint256 i = 0; i < tokens.length; i++) {
-            res[i] = TokenAmount(tokens[i], amounts[i]);
-        }
-    }
-
-    function _balanceOf(address token, address user) internal view returns (uint256) {
-        return IERC20(token).balanceOf(user);
-    }
-}