@pendle/core-v2 3.0.0-beta-10 → 3.0.0-beta-12

package/contracts/limit/helpers/RevertReasonParser.sol

@@ -1,75 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity ^0.8.0;
-
-/// @title Library that allows to parse unsuccessful arbitrary calls revert reasons.
-/// See https://solidity.readthedocs.io/en/latest/control-structures.html#revert for details.
-/// Note that we assume revert reason being abi-encoded as Error(string) so it may fail to parse reason
-/// if structured reverts appear in the future.
-///
-/// All unsuccessful parsings get encoded as Unknown(data) string
-
-library RevertReasonParser {
-    bytes4 private constant _PANIC_SELECTOR = bytes4(keccak256("Panic(uint256)"));
-    bytes4 private constant _ERROR_SELECTOR = bytes4(keccak256("Error(string)"));
-
-    function parse(bytes memory data, string memory prefix) internal pure returns (string memory) {
-        if (data.length >= 4) {
-            bytes4 selector;
-
-            assembly {
-                // solhint-disable-line no-inline-assembly
-                selector := mload(add(data, 0x20))
-            }
-
-            // 68 = 4-byte selector + 32 bytes offset + 32 bytes length
-            if (selector == _ERROR_SELECTOR && data.length >= 68) {
-                uint256 offset;
-                bytes memory reason;
-                assembly {
-                    // solhint-disable-line no-inline-assembly
-                    // 36 = 32 bytes data length + 4-byte selector
-                    offset := mload(add(data, 36))
-                    reason := add(data, add(36, offset))
-                }
-                /*
-                    revert reason is padded up to 32 bytes with ABI encoder: Error(string)
-                    also sometimes there is extra 32 bytes of zeros padded in the end:
-                    https://github.com/ethereum/solidity/issues/10170
-                    because of that we can't check for equality and instead check
-                    that offset + string length + extra 36 bytes is less than overall data length
-                */
-                require(data.length >= 36 + offset + reason.length, "Invalid revert reason");
-                return string(abi.encodePacked(prefix, "Error(", reason, ")"));
-            }
-            // 36 = 4-byte selector + 32 bytes integer
-            else if (selector == _PANIC_SELECTOR && data.length == 36) {
-                uint256 code;
-                assembly {
-                    // solhint-disable-line no-inline-assembly
-                    // 36 = 32 bytes data length + 4-byte selector
-                    code := mload(add(data, 36))
-                }
-                return string(abi.encodePacked(prefix, "Panic(", _toHex(code), ")"));
-            }
-        }
-
-        return string(abi.encodePacked(prefix, "Unknown(", _toHex(data), ")"));
-    }
-
-    function _toHex(uint256 value) private pure returns (string memory) {
-        return _toHex(abi.encodePacked(value));
-    }
-
-    function _toHex(bytes memory data) private pure returns (string memory) {
-        bytes16 alphabet = 0x30313233343536373839616263646566;
-        bytes memory str = new bytes(2 + data.length * 2);
-        str[0] = "0";
-        str[1] = "x";
-        for (uint256 i = 0; i < data.length; i++) {
-            str[2 * i + 2] = alphabet[uint8(data[i] >> 4)];
-            str[2 * i + 3] = alphabet[uint8(data[i] & 0x0f)];
-        }
-        return string(str);
-    }
-}

package/contracts/offchain-helpers/ChainlinkRelayerGelato.sol

@@ -1,37 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.17;
-
-import "./AutomateReady.sol";
-import "../core/libraries/BoringOwnableUpgradeable.sol";
-import "../core/StandardizedYield/implementations/ChainlinkRelayer/PendleChainlinkRelayer.sol";
-
-contract ChainlinkRelayerGelato is AutomateReady, BoringOwnableUpgradeable {
-    PendleChainlinkRelayer public immutable relayer;
-
-    int256 public lastSentAnswer;
-
-    constructor(address _automate, address _taskCreator, PendleChainlinkRelayer _relayer)
-        initializer
-        AutomateReady(_automate, _taskCreator)
-    {
-        __BoringOwnable_init();
-        relayer = _relayer;
-    }
-
-    receive() external payable {}
-
-    function withdraw() external onlyOwner {
-        payable(owner).transfer(address(this).balance);
-    }
-
-    function run() external {
-        int256 latestAnswer = IChainlinkAggregator(relayer.chainlinkFeed()).latestAnswer();
-        require(lastSentAnswer != latestAnswer, "answer not new");
-
-        (uint256 fee, address feeToken) = _getFeeDetails();
-        _transfer(fee, feeToken);
-
-        relayer.run{value: address(this).balance}();
-        lastSentAnswer = latestAnswer;
-    }
-}

package/contracts/offchain-helpers/PtAndLpToAsset.sol

@@ -1,62 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.0;
-
-import "../interfaces/IPMarket.sol";
-import "../core/libraries/math/PMath.sol";
-import "../core/Market/MarketMathCore.sol";
-
-contract PtAndLpToAsset {
-    using PMath for int256;
-    using PMath for uint256;
-    using MarketMathCore for MarketState;
-
-    function getLpToAssetRate(IPMarket market) public view returns (uint256 lpToAssetRate) {
-        MarketState memory state = market.readState(address(0));
-        uint256 pyIndexCurrent = _getPYIndexCurrent(market);
-        MarketPreCompute memory comp = state.getMarketPreCompute(
-            PYIndex.wrap(pyIndexCurrent),
-            block.timestamp
-        );
-
-        int256 totalHypotheticalAsset = comp.totalAsset +
-            state.totalPt.mulDown(int256(_getPtToAssetRate(market, state, pyIndexCurrent)));
-
-        lpToAssetRate = uint256(totalHypotheticalAsset.divDown(state.totalLp));
-    }
-
-    function getPtToAssetRate(IPMarket market) public view returns (uint256 ptToAssetRate) {
-        MarketState memory state = market.readState(address(0));
-        return _getPtToAssetRate(market, state, _getPYIndexCurrent(market));
-    }
-
-    function _getPtToAssetRate(
-        IPMarket market,
-        MarketState memory state,
-        uint256 pyIndexCurrent
-    ) internal view returns (uint256 ptToAssetRate) {
-        if (state.expiry <= block.timestamp) {
-            (IStandardizedYield SY, , ) = market.readTokens();
-            return (SY.exchangeRate().divDown(pyIndexCurrent));
-        }
-        uint256 timeToExpiry = state.expiry - block.timestamp;
-        int256 assetToPtRate = MarketMathCore._getExchangeRateFromImpliedRate(
-            state.lastLnImpliedRate,
-            timeToExpiry
-        );
-
-        ptToAssetRate = uint256(PMath.IONE.divDown(assetToPtRate));
-    }
-
-    function _getPYIndexCurrent(IPMarket market) private view returns (uint256) {
-        (IStandardizedYield SY, , IPYieldToken YT) = market.readTokens();
-
-        uint256 syIndex = SY.exchangeRate();
-        uint256 pyIndexStored = YT.pyIndexStored();
-
-        if (YT.doCacheIndexSameBlock() && YT.pyIndexLastUpdatedBlock() == block.number) {
-            return pyIndexStored;
-        } else {
-            return PMath.max(syIndex, pyIndexStored);
-        }
-    }
-}

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,112 +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";
-
-// 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);
-    }
-}

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

@@ -1,145 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.17;
-
-import "../../../interfaces/IPMarket.sol";
-import "../../../interfaces/IPRouterStatic.sol";
-import "./StorageLayout.sol";
-import {LimitMathCore as LimitMath} from "../../../limit/LimitMathCore.sol";
-
-// contract ActionLimitOrdersStatic is StorageLayout, IPOrderMixinType {
-//     using PMath for uint256;
-//     using PMath for int256;
-
-//     using LogExpMath for int256;
-//     using PYIndexLib for PYIndex;
-//     using PYIndexLib for IPYieldToken;
-//     using MarketApproxPtInLib for MarketState;
-//     using MarketApproxPtOutLib for MarketState;
-//     using MarketMathCore for MarketState;
-
-//     uint256 internal constant _ORDER_DOES_NOT_EXIST = 0;
-//     uint256 internal constant _ORDER_FILLED = 1;
-
-//     IPLimitRouter public limitRouter;
-
-//     // TODO: opt for bytecode
-
-//     function normalFillStatic(FillOrderParams[] memory params)
-//         external
-//         returns (
-//             uint256 actualMaking,
-//             uint256 actualTaking,
-//             uint256 totalFee,
-//             NormalResults memory out,
-//             FillOrderParams[] memory postConvertedOrders
-//         )
-//     {
-//         OrderType Type = params[0].order.Type;
-//         bool tokenFromMaker = (Type == OrderType.SY_FOR_PT || Type == OrderType.SY_FOR_YT);
-
-//         OnchainParams memory onchain = preProcess(params, tokenFromMaker);
-//         out = LimitMath.calcNormalBatch(params, onchain);
-//         postConvertedOrders = params;
-
-//         if (tokenFromMaker) {
-//             (actualMaking, actualTaking, totalFee) = (out.totalMaking, out.totalTaking, out.totalFee);
-//         } else {
-//             (actualMaking, actualTaking, totalFee) = (out.totalMaking, out.totalTaking + out.totalFee, out.totalFee);
-//         }
-//     }
-
-//     function flashFillStatic(FillOrderParams[] memory params)
-//         external
-//         returns (
-//             uint256 actualInputFromTaker,
-//             uint256 actualOutputToTaker,
-//             uint256 totalFee,
-//             NormalResults memory out,
-//             FillOrderParams[] memory postConvertedOrders
-//         )
-//     {
-//         OrderType Type = params[0].order.Type;
-//         bool tokenFromMaker = (Type == OrderType.SY_FOR_PT || Type == OrderType.SY_FOR_YT);
-
-//         OnchainParams memory onchain = preProcess(params, tokenFromMaker);
-//         (out, actualInputFromTaker, actualOutputToTaker) = LimitMath.calcFlashBatch(params, onchain);
-//         totalFee = out.totalFee;
-//         postConvertedOrders = params;
-//     }
-
-//     function preProcess(FillOrderParams[] memory params, bool tokenToSy)
-//         internal
-//         returns (OnchainParams memory onchain)
-//     {
-//         _verifyAndUpdateMakings(params);
-
-//         address YT = params[0].order.YT;
-//         address SY = IPYieldToken(YT).SY();
-//         uint256 expiry = IPYieldToken(YT).expiry();
-//         require(block.timestamp < expiry, "PY expired");
-
-//         if (tokenToSy) {
-//             _mintSyStatic(params, IStandardizedYield(SY));
-//         }
-
-//         onchain = OnchainParams({
-//             timeToExpiry: expiry - block.timestamp,
-//             index: IPYieldToken(YT).newIndex(),
-//             feeRecipient: IPOrderMixin(limitRouter).feeRecipient(),
-//             feeRate: IPOrderMixin(limitRouter).feeRate()
-//         });
-//     }
-
-//     function _verifyAndUpdateMakings(FillOrderParams[] memory params) internal view {
-//         uint256 len = params.length;
-//         for (uint256 i = 0; i < len; i++) {
-//             FillOrderParams memory param = params[i];
-
-//             (, uint256 remainingMakerAmount) = _verifyOrder(param.order);
-//             uint256 netMaking = PMath.min(param.makingAmount, remainingMakerAmount);
-
-//             param.makingAmount = netMaking;
-//         }
-//     }
-
-//     function _verifyOrder(Order memory order)
-//         internal
-//         view
-//         returns (bytes32, /*orderHash*/ uint256 /*remainingMakerAmount*/ )
-//     {
-//         bytes32 orderHash = limitRouter.hashOrder(order);
-//         uint256 remainingMakerAmount = limitRouter.remainingRaw(orderHash);
-
-//         if (remainingMakerAmount == _ORDER_FILLED) return (orderHash, 0);
-
-//         if (remainingMakerAmount == _ORDER_DOES_NOT_EXIST) {
-//             remainingMakerAmount = order.makingAmount;
-//         } else {
-//             unchecked {
-//                 remainingMakerAmount -= 1;
-//             }
-//         }
-
-//         // Check if order is valid predicate wise
-//         if (order.predicate.length > 0) {
-//             bool isValidPredicate = limitRouter.checkPredicate(order);
-//             require(isValidPredicate, "LOP: predicate returned false");
-//         }
-
-//         return (orderHash, remainingMakerAmount);
-//     }
-
-//     function _mintSyStatic(FillOrderParams[] memory params, IStandardizedYield SY) internal view {
-//         uint256 len = params.length;
-//         for (uint256 i = 0; i < len; i++) {
-//             FillOrderParams memory param = params[i];
-//             if (param.makingAmount == 0) continue;
-
-//             Order memory order = param.order;
-
-//             if (order.token != address(SY)) {
-//                 param.makingAmount = SY.previewDeposit(order.token, param.makingAmount);
-//             }
-//         }
-//     }
-// }

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

@@ -1,171 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.17;
-
-import "../../../interfaces/IPMarket.sol";
-import "../../../interfaces/IPRouterStatic.sol";
-import "./StorageLayout.sol";
-
-contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
-    using MarketMathCore for MarketState;
-    using PMath for int256;
-    using PMath for uint256;
-    using LogExpMath for int256;
-    using PYIndexLib for PYIndex;
-    using PYIndexLib for IPYieldToken;
-
-    function getMarketState(address market)
-        public
-        view
-        returns (
-            address pt,
-            address yt,
-            address sy,
-            int256 impliedYield,
-            uint256 marketExchangeRateExcludeFee,
-            MarketState memory state
-        )
-    {
-        (IStandardizedYield SY, IPPrincipalToken PT, IPYieldToken YT) = _readTokens(market);
-        pt = address(PT);
-        yt = address(YT);
-        sy = address(SY);
-        state = _readState(market);
-        impliedYield = _getPtImpliedYield(market);
-        marketExchangeRateExcludeFee = getTradeExchangeRateExcludeFee(market, state);
-    }
-
-    function getTradeExchangeRateExcludeFee(address market, MarketState memory state) public view returns (uint256) {
-        if (IPMarket(market).isExpired()) return PMath.ONE;
-
-        MarketPreCompute memory comp = state.getMarketPreCompute(_pyIndex(market), block.timestamp);
-        int256 preFeeExchangeRate =
-            MarketMathCore._getExchangeRate(state.totalPt, comp.totalAsset, comp.rateScalar, comp.rateAnchor, 0);
-        return preFeeExchangeRate.Uint();
-    }
-
-    function getTradeExchangeRateIncludeFee(address market, int256 netPtOut) public view returns (uint256) {
-        if (IPMarket(market).isExpired()) return PMath.ONE;
-
-        int256 netPtToAccount = netPtOut;
-        MarketState memory state = _readState(market);
-        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);
-            if (postFeeExchangeRate < PMath.IONE) {
-                revert Errors.MarketExchangeRateBelowOne(postFeeExchangeRate);
-            }
-            return postFeeExchangeRate.Uint();
-        } else {
-            return preFeeExchangeRate.mulDown(comp.feeRate).Uint();
-        }
-    }
-
-    function calcPriceImpactPt(address market, int256 netPtOut) public view returns (uint256 priceImpact) {
-        uint256 preTradeRate = getTradeExchangeRateIncludeFee(market, _getSign(netPtOut));
-        uint256 tradedRate = getTradeExchangeRateIncludeFee(market, netPtOut);
-        priceImpact = _calculateImpact(preTradeRate, tradedRate);
-    }
-
-    function calcPriceImpactYt(address market, int256 netPtOut) public view returns (uint256 priceImpact) {
-        uint256 ytPreTradeRate = _calcVirtualYTPrice(getTradeExchangeRateIncludeFee(market, _getSign(netPtOut)));
-        uint256 ytTradedRate = _calcVirtualYTPrice(getTradeExchangeRateIncludeFee(market, netPtOut));
-        priceImpact = _calculateImpact(ytPreTradeRate, ytTradedRate);
-    }
-
-    function calcPriceImpactPY(address market, int256 netPtOut) public view returns (uint256 priceImpact) {
-        uint256 ptPreTradeRate = getTradeExchangeRateIncludeFee(market, _getSign(netPtOut));
-        uint256 ytPreTradeRate = _calcVirtualYTPrice(ptPreTradeRate);
-        uint256 ptTradeRate = getTradeExchangeRateIncludeFee(market, netPtOut);
-        uint256 ytTradeRate = _calcVirtualYTPrice(ptTradeRate);
-
-        uint256 pyPreTradeRate = ytPreTradeRate.divDown(ptPreTradeRate);
-        uint256 pyTradeRate = ytTradeRate.divDown(ptTradeRate);
-        priceImpact = _calculateImpact(pyPreTradeRate, pyTradeRate);
-    }
-
-    function getLpToSyRate(address market) public view returns (uint256) {
-        (IStandardizedYield SY,,) = _readTokens(market);
-        return getLpToAssetRate(market).divDown(SY.exchangeRate());
-    }
-
-    function getPtToSyRate(address market) public view returns (uint256) {
-        (IStandardizedYield SY,,) = _readTokens(market);
-        return getPtToAssetRate(market).divDown(SY.exchangeRate());
-    }
-
-    function getLpToAssetRate(address market) public view returns (uint256) {
-        MarketState memory state = _readState(market);
-        PYIndex pyIndexCurrent = _pyIndex(market);
-        MarketPreCompute memory comp = state.getMarketPreCompute(pyIndexCurrent, block.timestamp);
-
-        int256 totalHypotheticalAsset =
-            comp.totalAsset + state.totalPt.mulDown(int256(_getPtToAssetRate(market, state, pyIndexCurrent)));
-
-        return uint256(totalHypotheticalAsset.divDown(state.totalLp));
-    }
-
-    function getPtToAssetRate(address market) public view returns (uint256) {
-        MarketState memory state = _readState(market);
-        return _getPtToAssetRate(market, state, _pyIndex(market));
-    }
-
-    function _getPtToAssetRate(address market, MarketState memory state, PYIndex pyIndexCurrent)
-        internal
-        view
-        returns (uint256 ptToAssetRate)
-    {
-        if (state.expiry <= block.timestamp) {
-            (IStandardizedYield SY,,) = _readTokens(market);
-            return (SY.exchangeRate().divDown(PYIndex.unwrap(pyIndexCurrent)));
-        }
-        uint256 timeToExpiry = state.expiry - block.timestamp;
-        int256 assetToPtRate = MarketMathCore._getExchangeRateFromImpliedRate(state.lastLnImpliedRate, timeToExpiry);
-
-        ptToAssetRate = uint256(PMath.IONE.divDown(assetToPtRate));
-    }
-
-    function _getPtImpliedYield(address market) internal view returns (int256) {
-        MarketState memory state = _readState(market);
-
-        int256 lnImpliedRate = (state.lastLnImpliedRate).Int();
-        return lnImpliedRate.exp();
-    }
-
-    function _calcVirtualYTPrice(uint256 ptAssetExchangeRate) private pure returns (uint256 ytAssetExchangeRate) {
-        // 1 asset = EX pt
-        // 1 pt = 1/EX Asset
-        // 1 yt + 1/EX Asset = 1 Asset
-        // 1 yt = 1 Asset - 1/EX Asset
-        // 1 yt = (EX - 1) / EX Asset
-        return (ptAssetExchangeRate - PMath.ONE).divDown(ptAssetExchangeRate);
-    }
-
-    function _readState(address market) internal view returns (MarketState memory) {
-        return IPMarket(market).readState(address(this));
-    }
-
-    function _readTokens(address market)
-        internal
-        view
-        returns (IStandardizedYield _SY, IPPrincipalToken _PT, IPYieldToken _YT)
-    {
-        return IPMarket(market).readTokens();
-    }
-
-    function _getSign(int256 netPtOut) private pure returns (int256) {
-        return netPtOut > 0 ? int256(1) : int256(-1);
-    }
-
-    function _calculateImpact(uint256 rateBefore, uint256 rateTraded) private pure returns (uint256 impact) {
-        impact = (rateBefore.Int() - rateTraded.Int()).abs().divDown(rateBefore);
-    }
-
-    function _pyIndex(address market) private view returns (PYIndex) {
-        return PYIndex.wrap(IPRouterStatic(address(this)).pyIndexCurrentViewMarket(market));
-    }
-}