@pendle/core-v2 2.20.1 → 2.21.0-tradingbot

package/contracts/core/TradingBot/libraries/MarketExtLib.sol

@@ -0,0 +1,272 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "../../../interfaces/IPMarket.sol";
+import "../../StandardizedYield/PYIndex.sol";
+import "../../../router/base/MarketApproxLib.sol";
+
+struct MarketExtState {
+    MarketState state;
+    PYIndex index;
+    uint256 blockTime;
+}
+
+// Audit notes for MarketExtLib:
+// 1.   All changes made by functions simulating the actions containing marketExt as input params
+//      should also be reflected in the params itself
+// 2.   All approxParams (used for MarketApproxLib) passing into the functions should be cloned 
+//      before being used. 
+
+library MarketExtLib {
+    using MarketMathCore for MarketState;
+    using MarketApproxPtInLib for MarketState;
+    using MarketApproxPtOutLib for MarketState;
+    using PYIndexLib for PYIndex;
+    using PYIndexLib for IPYieldToken;
+    using LogExpMath for uint256;
+    using Math for uint256;
+    using Math for int256;
+
+    uint256 public constant ONE_YEAR = 365 days;
+
+    /// @dev Simulates PendleRouter's swapExactYtForSy
+    function swapYtToSy(
+        MarketExtState memory marketExt,
+        uint256 exactYtIn
+    ) internal pure returns (uint256 /*netSyOut*/) {
+        (uint256 netSyOwedInt, , ) = marketExt.state.swapSyForExactPt(
+            marketExt.index,
+            exactYtIn,
+            marketExt.blockTime
+        );
+
+        uint256 netPYToRepaySyOwedInt = marketExt.index.syToAssetUp(netSyOwedInt);
+        uint256 netPYToRedeemSyOutInt = exactYtIn - netPYToRepaySyOwedInt;
+
+        return marketExt.index.assetToSy(netPYToRedeemSyOutInt);
+    }
+
+    /// @dev Simulates PendleRouter's swapExactPtForSy
+    function swapPtToSy(
+        MarketExtState memory marketExt,
+        uint256 exactPtIn
+    ) internal pure returns (uint256 netSyOut) {
+        (netSyOut, , ) = marketExt.state.swapExactPtForSy(
+            marketExt.index,
+            exactPtIn,
+            marketExt.blockTime
+        );
+    }
+
+    /// @dev Simulates PendleRouter's addLiquiditySingleSyKeepYt
+    function addLiqKeepYt(
+        MarketExtState memory marketExt,
+        uint256 netSyIn
+    ) internal pure returns (uint256 netLpOut, uint256 netYtOut) {
+        uint256 netSyToPt = (netSyIn * marketExt.state.totalPt.Uint()) /
+            (marketExt.state.totalPt.Uint() +
+                marketExt.index.syToAsset(marketExt.state.totalSy.Uint()));
+
+        netYtOut = marketExt.index.syToAsset(netSyToPt);
+
+        netLpOut = addLiqDual(marketExt, netSyIn - netSyToPt, netYtOut);
+    }
+
+    /**
+     * Workflow of the addLiqFromYt action: 
+     * - Call market.swapSyForExactPt(), getting [%%%%%%++*] PT where:
+     *      - The % part used to redeemed to SY along with YT, and pay the SY debt for market
+     *      - The + part used to redeemed to SY (combined with above) to add liquidity together with PT
+     *      - The * part used to add liquidity to the market
+     * 
+     * Amount of PT to swap to SY (%) is determined by amount of SY in debt
+     * Thus, some math calculation is made to determine how much PT is used to add liquidity (*) and later
+     * used to deduce the (+) part
+     */
+    function addLiqFromYt(
+        MarketExtState memory marketExt,
+        uint256 netPtFromSwap
+    ) internal pure returns (uint256 netLpOut, uint256 netYtIn) {
+        (uint256 netSyToSwap, , ) = marketExt.state.swapSyForExactPt(
+            marketExt.index,
+            netPtFromSwap,
+            marketExt.blockTime
+        );
+
+        // (1) --> netPtRedeemSy = netPtFromSwap - netPtToAdd
+        // (2) --> (netPtRedeemSy * ONE / pyIndex) = (netPtToAdd * totalSy / totalPt) + netSyToSwap
+        // (2) * pyIndex / ONE --> netPtRedeemSy = (netPtToAdd * totalSy / totalPt * pyIndex / ONE) + netSyToSwap * pyIndex / ONE
+        // ==> netPtFromSwap - netPtToAdd = (netPtToAdd * totalSy / totalPt * pyIndex / ONE) + netSyToSwap * pyIndex / ONE
+        // ==> netPtToAdd * (ONE + totalSy * pyIndex / totalPt) = netPtFromSwap * ONE - netSyToSwap * pyIndex
+
+        uint256 pyIndex = PYIndex.unwrap(marketExt.index);
+        uint256 netPtToAddNumerator = (netPtFromSwap * Math.ONE - netSyToSwap * pyIndex);
+        uint256 netPtToAddDenominator = (Math.ONE +
+            (marketExt.state.totalSy.Uint() * pyIndex) /
+            marketExt.state.totalPt.Uint());
+        uint256 netPtToAdd = netPtToAddNumerator / netPtToAddDenominator;
+
+        netYtIn = netPtFromSwap - netPtToAdd;
+
+        uint256 netSyFromPy = marketExt.index.assetToSy(netYtIn);
+        uint256 netSyToAdd = netSyFromPy - netSyToSwap;
+
+        netLpOut = addLiqDual(marketExt, netSyToAdd, netPtToAdd);
+    }
+
+    /// @dev Simulates PendleRouter's removeLiquidityDualSyAndPt then swapExactPtForYt
+    function removeLiqToYt(
+        MarketExtState memory marketExt,
+        uint256 netLpToRemove,
+        ApproxParams memory approxParams
+    ) internal pure returns (uint256 netYtOut, uint256 totalPtToSwap) {
+        (uint256 netSyRemoved, uint256 netPtRemoved) = removeLiqDual(marketExt, netLpToRemove);
+
+        uint256 netYtFromSy = marketExt.index.syToAsset(netSyRemoved);
+        uint256 netPtToSwap = netPtRemoved + netYtFromSy;
+
+        uint256 netYtFromSwap;
+        (netYtFromSwap, totalPtToSwap, ) = marketExt.state.approxSwapExactPtForYt(
+            marketExt.index,
+            netPtToSwap,
+            marketExt.blockTime,
+            clone(approxParams)
+        );
+
+        marketExt.state.swapExactPtForSy(marketExt.index, totalPtToSwap, marketExt.blockTime);
+
+        netYtOut = netYtFromSy + netYtFromSwap;
+    }
+
+    /// @dev Simplified version of MarketMathCore's addLiquidity
+    function addLiqDual(
+        MarketExtState memory marketExt,
+        uint256 netSyIn,
+        uint256 netPtIn
+    ) internal pure returns (uint256 /*netLpOut*/) {
+        require(
+            !MiniHelpers.isExpired(marketExt.state.expiry, marketExt.blockTime),
+            "MarketExtLib: expired market"
+        );
+        require(marketExt.state.totalLp > 0, "MarketExtLib: LP < 0");
+
+        int256 syDesired = netSyIn.Int();
+        int256 ptDesired = netPtIn.Int();
+        int256 lpToAccount;
+        int256 ptUsed;
+        int256 syUsed;
+
+        int256 netLpByPt = (ptDesired * marketExt.state.totalLp) / marketExt.state.totalPt;
+        int256 netLpBySy = (syDesired * marketExt.state.totalLp) / marketExt.state.totalSy;
+        if (netLpByPt < netLpBySy) {
+            lpToAccount = netLpByPt;
+            ptUsed = ptDesired;
+            syUsed = (marketExt.state.totalSy * lpToAccount) / marketExt.state.totalLp;
+        } else {
+            lpToAccount = netLpBySy;
+            syUsed = syDesired;
+            ptUsed = (marketExt.state.totalPt * lpToAccount) / marketExt.state.totalLp;
+        }
+
+        marketExt.state.totalSy += syUsed;
+        marketExt.state.totalPt += ptUsed;
+        marketExt.state.totalLp += lpToAccount;
+
+        return lpToAccount.Uint();
+    }
+
+    /// @dev Simplified version of MarketMathCore's removeLiquidity
+    function removeLiqDual(
+        MarketExtState memory marketExt,
+        uint256 netLpToRemove
+    ) internal pure returns (uint256 /*netSyToAccount*/, uint256 /*netPtToAccount*/) {
+        int256 lpToRemove = netLpToRemove.Int();
+
+        int256 netSyToAccount = (lpToRemove * marketExt.state.totalSy) / marketExt.state.totalLp;
+        int256 netPtToAccount = (lpToRemove * marketExt.state.totalPt) / marketExt.state.totalLp;
+
+        marketExt.state.totalLp = marketExt.state.totalLp.subNoNeg(lpToRemove);
+        marketExt.state.totalPt = marketExt.state.totalPt.subNoNeg(netPtToAccount);
+        marketExt.state.totalSy = marketExt.state.totalSy.subNoNeg(netSyToAccount);
+
+        return (netSyToAccount.Uint(), netPtToAccount.Uint());
+    }
+
+    function previewPyToSy(
+        MarketExtState memory marketExt,
+        uint256 netPYToRedeem
+    ) internal pure returns (uint256) {
+        return marketExt.index.assetToSy(netPYToRedeem);
+    }
+
+    /// @notice Returns the trade exchange rate, fee excluded
+    function exchangeRate(MarketExtState memory marketExt) internal pure returns (uint256) {
+        MarketPreCompute memory comp = marketExt.state.getMarketPreCompute(
+            marketExt.index,
+            marketExt.blockTime
+        );
+
+        int256 preFeeExchangeRate = MarketMathCore._getExchangeRate(
+            marketExt.state.totalPt,
+            comp.totalAsset,
+            comp.rateScalar,
+            comp.rateAnchor,
+            0
+        );
+
+        return preFeeExchangeRate.Uint();
+    }
+
+    function impliedYield(MarketExtState memory marketExt) internal pure returns (uint256) {
+        return
+            exchangeRate(marketExt).pow(
+                ONE_YEAR.divDown(marketExt.state.expiry - marketExt.blockTime)
+            ) - Math.ONE;
+    }
+
+    function clone(MarketState memory state) internal pure returns (MarketState memory) {
+        return
+            MarketState(
+                state.totalPt,
+                state.totalSy,
+                state.totalLp,
+                state.treasury,
+                state.scalarRoot,
+                state.expiry,
+                state.lnFeeRateRoot,
+                state.reserveFeePercent,
+                state.lastLnImpliedRate
+            );
+    }
+
+    function clone(MarketExtState memory marketExt) internal pure returns (MarketExtState memory) {
+        return MarketExtState(clone(marketExt.state), marketExt.index, marketExt.blockTime);
+    }
+
+    function clone(ApproxParams memory params) internal pure returns (ApproxParams memory) {
+        return
+            ApproxParams(
+                params.guessMin,
+                params.guessMax,
+                params.guessOffchain,
+                params.maxIteration,
+                params.eps
+            );
+    }
+
+    function calcMaxPtIn(MarketExtState memory marketExt) internal pure returns (uint256) {
+        return
+            (MarketApproxPtInLib.calcMaxPtIn(
+                marketExt.state,
+                marketExt.state.getMarketPreCompute(marketExt.index, marketExt.blockTime)
+            ) * 9) / 10;
+    }
+
+    function calcMaxPtOut(MarketExtState memory marketExt) internal pure returns (uint256) {
+        return
+            MarketApproxPtOutLib.calcMaxPtOut(
+                marketExt.state.getMarketPreCompute(marketExt.index, marketExt.blockTime),
+                marketExt.state.totalPt
+            );
+    }
+}

package/contracts/core/TradingBot/libraries/SpecSegmentLib.sol

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../../interfaces/TradingBot/IBotDecisionHelper.sol";
+import "../../libraries/math/Math.sol";
+
+// Library convention:
+// BinId: the index of the bin as defined in the docs [-4 ... 4], could be [-3 ... 5] in case
+// botState.buyBins is decreased
+// SegId: the index of the bin shifted botState.buyBins to the right [0 ... 8], always remains
+// in this range
+
+// This library aims to implement:
+// - The binId <-> segId <-> iy conversion
+// - Calculate implied yield related information for bin/seg
+
+library SpecSegmentLib {
+    using Math for uint256;
+    using Math for int256;
+
+    function getSegLength(TradingSpecs memory specs) internal pure returns (uint256) {
+        return (specs.sellYtIy - specs.buyYtIy) / (2 * specs.numOfBins);
+    }
+
+    function getMidIyOfSeg(
+        TradingSpecs memory specs,
+        uint256 segId
+    ) internal pure returns (uint256) {
+        // This function is called when the currentBin sees the segId bin as the target
+        // As so, the leftmost and rightmost bin should not be considered
+        assert(segId != 0 && segId != specs.numOfBins * 2 + 1);
+
+        uint256 length = getSegLength(specs);
+        return specs.buyYtIy + length * (segId - 1) + length / 2;
+    }
+
+    function getSegIdForIy(
+        TradingSpecs memory specs,
+        uint256 iy
+    ) internal pure returns (uint256) {
+        if (iy < specs.buyYtIy) {
+            return 0;
+        }
+        if (iy > specs.sellYtIy) {
+            return 2 * specs.numOfBins + 1;
+        }
+        return (iy - specs.buyYtIy) / getSegLength(specs) + 1;
+    }
+
+    function convertSegIdToBinId(
+        BotState memory botState,
+        uint256 segId
+    ) internal pure returns (int256) {
+        int256 binId = segId.Int() - botState.buyBins.Int();
+        if (binId >= 1) binId--;
+        return binId;
+    }
+
+    function convertBinIdToSegId(
+        BotState memory botState,
+        int256 binId
+    ) internal pure returns (uint256) {
+        // It's impossible to determine the segId of two middle bins as they share the binId value of 0
+        // In practice, we don't need to take any action in case currentBin = 0, so this case can be ignored
+        assert(binId != 0); 
+
+        if (binId >= 1) binId++;
+        return (binId + botState.buyBins.Int()).Uint();
+    }
+
+    function getBinIdForIy(
+        TradingSpecs memory specs,
+        BotState memory botState,
+        uint256 iy
+    ) internal pure returns (int256) {
+        return convertSegIdToBinId(botState, getSegIdForIy(specs, iy));
+    }
+}

package/contracts/core/TradingBot/libraries/TvlLib.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "./MarketExtLib.sol";
+import "../../../interfaces/TradingBot/IBotDecisionHelper.sol";
+import "../../../oracles/PendleLpOracleLib.sol";
+
+library TvlLib {
+    using MarketMathCore for MarketState;
+    using MarketExtLib for MarketExtState;
+    using Math for uint256;
+    using Math for int256;
+    using PendleLpOracleLib for IPMarket;
+    using PendlePtOracleLib for IPMarket;
+    using PYIndexLib for PYIndex;
+
+    uint32 internal constant ORACLE_DURATION = 1800;
+
+    /**
+     * @param market market address
+     * @param bot currnet bot state
+     * @return tvl total value locked in SY (excluding uncompounded reward tokens/interest) by oracle prices
+     */
+    function getOracleTvl(address market, BotState memory bot) public view returns (uint256) {
+        PYIndex index = IPMarket(market)._getPYIndexCurrent();
+
+        uint256 tvlInAsset;
+        if (bot.lpBalance > 0) {
+            tvlInAsset += bot.lpBalance.mulDown(
+                IPMarket(market).getLpToAssetRate(ORACLE_DURATION)
+            );
+        }
+
+        if (bot.ptBalance + bot.ytBalance > 0) {
+            uint256 ptPrice = IPMarket(market).getPtToAssetRate(ORACLE_DURATION);
+            uint256 ytPrice = Math.ONE - ptPrice;
+            tvlInAsset += bot.ptBalance.mulDown(ptPrice) + bot.ytBalance.mulDown(ytPrice);
+        }
+
+        return index.assetToSy(tvlInAsset) + bot.syBalance;
+    }
+
+    /**
+     * 
+     * @param bot current bot state
+     * @param marketExt current market state
+     * @return Total value locked in SY (excluding uncompounded reward tokens/interest) if we perform liquidation
+     * on all bot's assets
+     */
+    function getLiquidateTvl(
+        BotState memory bot,
+        MarketExtState memory marketExt
+    ) public pure returns (uint256) {
+        MarketExtState memory marketExtClone = marketExt.clone();
+
+        (uint256 syInLp, uint256 ptInLp) = marketExtClone.removeLiqDual(bot.lpBalance);
+        uint256 totalValue = bot.syBalance + syInLp;
+
+        uint256 totalPt = ptInLp + bot.ptBalance;
+        if (totalPt <= bot.ytBalance) {
+            totalValue += marketExtClone.previewPyToSy(totalPt);
+            totalValue += marketExtClone.swapYtToSy(bot.ytBalance - totalPt);
+        } else {
+            totalValue += marketExtClone.previewPyToSy(bot.ytBalance);
+            totalValue += marketExtClone.swapPtToSy(totalPt - bot.ytBalance);
+        }
+        return totalValue;
+    }
+}

package/contracts/core/libraries/Errors.sol

@@ -177,4 +177,16 @@ library Errors {
     // Swap Aggregator
     error SAInsufficientTokenIn(address tokenIn, uint256 amountExpected, uint256 amountActual);
     error UnsupportedSelector(uint256 aggregatorType, bytes4 selector);
+
+    // Trading Bot
+    error BotBinarySearchInvalidRange(uint256 action, uint256 guessMin, uint256 guessMax);
+    error BotBinarySearchGuessMinInvalid(uint256 action, uint256 guessMin);
+    error BotBinarySearchFail();
+    error BotExceededLimitSyIn(uint256 actualSyIn, uint256 limitSyIn);
+    error BotExceededLimitYtIn(uint256 actualYtIn, uint256 limitYtIn);
+    error BotExceededLimitLpToRemove(uint256 actualLpToRemove, uint256 limitLpToRemove);
+    error BotInsufficientSyOut(uint256 actualSyOut, uint256 requiredSyOut);
+    error BotInsufficientYtOut(uint256 actualYtOut, uint256 requiredYtOut);
+    error BotInsufficientLpOut(uint256 actualLpOut, uint256 requiredLpOut);
+    error BotCallbackNotMarket(address caller);
 }

package/contracts/core/libraries/TokenAmountLib.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity >=0.8.0;
+
+struct TokenAmount {
+    address token;
+    uint256 amount;
+}
+
+library TokenAmountLib {
+    function add(
+        TokenAmount[] memory list,
+        address token,
+        uint256 amount
+    ) internal pure returns (TokenAmount[] memory newList) {
+        if (amount == 0) return list;
+
+        uint256 newTokenIndex = list.length;
+        for (uint256 i = 0; i < list.length; i++) {
+            if (list[i].token == token) {
+                newTokenIndex = i;
+                break;
+            }
+        }
+
+        newList = new TokenAmount[](list.length + (newTokenIndex == list.length ? 1 : 0));
+        for (uint256 i = 0; i < list.length; i++) {
+            newList[i] = list[i];
+        }
+        newList[newTokenIndex] = TokenAmount(
+            token,
+            (newTokenIndex == list.length ? 0 : list[newTokenIndex].amount) + amount
+        );
+    }
+
+    function add(
+        TokenAmount[] memory list,
+        address[] memory tokens,
+        uint256[] memory amounts
+    ) internal pure returns (TokenAmount[] memory newList) {
+        newList = list;
+        require(tokens.length == amounts.length, "TokenAmountLib: length mismatch");
+        for (uint256 i = 0; i < tokens.length; i++) {
+            newList = add(newList, tokens[i], amounts[i]);
+        }
+        return newList;
+    }
+}

package/contracts/interfaces/IPActionInfoStatic.sol

@@ -1,4 +1,3 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
 interface IPActionInfoStatic {
@@ -29,16 +28,16 @@ interface IPActionInfoStatic {
     function getPY(address py) external view returns (address pt, address yt);
 
     /// can be SY, PY or Market
-    function getTokensInOut(address token)
-        external
-        view
-        returns (address[] memory tokensIn, address[] memory tokensOut);
+    function getTokensInOut(
+        address token
+    ) external view returns (address[] memory tokensIn, address[] memory tokensOut);
 
     function getUserSYInfo(address sy, address user) external returns (UserSYInfo memory res);
 
     function getUserPYInfo(address py, address user) external returns (UserPYInfo memory res);
 
-    function getUserMarketInfo(address market, address user)
-        external
-        returns (UserMarketInfo memory res);
+    function getUserMarketInfo(
+        address market,
+        address user
+    ) external returns (UserMarketInfo memory res);
 }

package/contracts/interfaces/IPActionMarketAuxStatic.sol

@@ -3,15 +3,16 @@ pragma solidity ^0.8.17;
 import "./IPMarket.sol";
 
 interface IPActionMarketAuxStatic {
-    function calcPriceImpactPY(address market, int256 netPtOut) external view returns (uint256);
+    function calcPriceImpactPY(address market, int256 netPtOut) external returns (uint256);
 
-    function calcPriceImpactPt(address market, int256 netPtOut) external view returns (uint256);
+    function calcPriceImpactPt(address market, int256 netPtOut) external returns (uint256);
 
-    function calcPriceImpactYt(address market, int256 netPtOut) external view returns (uint256);
+    function calcPriceImpactYt(address market, int256 netPtOut) external returns (uint256);
 
-    function getMarketState(address market)
+    function getMarketState(
+        address market
+    )
         external
-        view
         returns (
             address pt,
             address yt,
@@ -21,21 +22,13 @@ interface IPActionMarketAuxStatic {
             MarketState memory state
         );
 
-    function getTradeExchangeRateExcludeFee(address market, MarketState memory state)
-        external
-        view
-        returns (uint256);
-
-    function getTradeExchangeRateIncludeFee(address market, int256 netPtOut)
-        external
-        view
-        returns (uint256);
-
-    function getLpToSyRate(address market) external view returns (uint256);
-
-    function getPtToSyRate(address market) external view returns (uint256);
-
-    function getLpToAssetRate(address market) external view returns (uint256);
+    function getTradeExchangeRateExcludeFee(
+        address market,
+        MarketState memory state
+    ) external returns (uint256);
 
-    function getPtToAssetRate(address market) external view returns (uint256);
+    function getTradeExchangeRateIncludeFee(
+        address market,
+        int256 netPtOut
+    ) external returns (uint256);
 }