@pendle/core-v2 2.19.0 → 2.20.0-tradingbot

package/contracts/core/TradingBot/DecisionHelper/LongYieldDecisionHelper.sol

@@ -0,0 +1,291 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "./../libraries/BotSimulationLib.sol";
+import "../../libraries/Errors.sol";
+import "../libraries/SpecSegmentLib.sol";
+import "./BotDecisionHelperBase.sol";
+import "../../../interfaces/TradingBot/IBotDecisionHelper.sol";
+import "../../../interfaces/TradingBot/ILongYieldTradingBot.sol";
+
+contract LongYieldDecisionHelper is BotDecisionHelperBase {
+    using MarketExtLib for MarketExtState;
+    using MarketExtLib for ApproxParams;
+    using MarketMathCore for MarketState;
+    using MarketApproxPtInLib for MarketState;
+    using BotSimulationLib for BotState;
+    using PYIndexLib for PYIndex;
+    using Math for uint256;
+    using Math for int256;
+    using LogExpMath for uint256;
+    using SpecSegmentLib for TradingSpecs;
+
+    function getRebalanceAction(
+        address botAddress
+    ) public view returns (RebalanceOutput memory output) {
+        StrategyData memory strategyData = ITradingBotBase(botAddress).readStrategyData();
+        (uint256 tvlInSy, , uint256 syRatio, ) = _calcBotExtStats(
+            strategyData.botState,
+            strategyData.marketExt
+        );
+
+        uint256 lowerBound = strategyData.specs.targetSyRatio.mulDown(
+            Math.ONE - strategyData.specs.bufferSyRatio
+        );
+
+        uint256 upperBound = strategyData.specs.targetSyRatio.mulDown(
+            Math.ONE + strategyData.specs.bufferSyRatio
+        );
+
+        if (syRatio > upperBound) {
+            output.rebalanceType = RebalanceType.AddLiqKeepYt;
+            (output.amountIn, output.amountOut, output.amountOut2) = _getSyAmountForZPI(
+                strategyData.marketExt,
+                tvlInSy,
+                syRatio,
+                strategyData.specs.targetSyRatio
+            );
+        } else if (syRatio < lowerBound) {
+            (output.rebalanceType, output.amountIn, output.amountOut) = _getRemoveRebalance(
+                strategyData,
+                tvlInSy
+            );
+        }
+    }
+
+    // We dont care about AddLiqKeepYt here
+    function getTradeAction(address botAddress) public view returns (TradeResult memory res) {
+        StrategyData memory strategyData = ILongYieldTradingBot(botAddress).readStrategyData();
+        uint256 iy = strategyData.marketExt.impliedYield();
+
+        res.currentBin = _getCurrentBin(strategyData.botState, strategyData.specs, iy);
+        if (res.currentBin == 0) {
+            res.action = TradeActionType.NONE;
+            return res;
+        }
+        res.targetIy = _getTargetImpliedYieldForBin(
+            strategyData.botState,
+            strategyData.specs,
+            res.currentBin
+        );
+
+        uint256 maxAmountForAction = INF;
+        uint256 rebalanceAdditionalCheck;
+
+        if (res.currentBin < 0) {
+            res.action = TradeActionType.RemoveLiqToYt;
+            maxAmountForAction = _calcTradeActionMaxAmount(
+                strategyData.botState.lpBalance,
+                res.currentBin,
+                strategyData.botState.buyBins,
+                strategyData.specs.numOfBins
+            );
+
+            if (maxAmountForAction == 0) {
+                res.action = TradeActionType.NONE;
+                return res;
+            }
+        } else {
+            res.action = TradeActionType.AddLiqFromYt;
+            uint256 maxYtToAddLiq = searchMaxYtToAddLiq(strategyData);
+
+            rebalanceAdditionalCheck = _calcTradeActionMaxAmount(
+                maxYtToAddLiq,
+                res.currentBin,
+                strategyData.botState.buyBins,
+                strategyData.specs.numOfBins
+            );
+
+            if (rebalanceAdditionalCheck == 0) {
+                res.action = TradeActionType.NONE;
+                return res;
+            }
+        }
+
+        res.guessBotParams = searchForBotParam(
+            strategyData,
+            res.action,
+            res.targetIy,
+            rebalanceAdditionalCheck,
+            _getMockApproxParamsWithGuessMax(maxAmountForAction),
+            _getMockApproxParams()
+        );
+        (res.amountOut, res.guessIntParams) = _calcTradeActionAmountOutAndIntParams(
+            strategyData.marketExt,
+            res.action,
+            res.guessBotParams
+        );
+    }
+
+    /**
+     * Given the rebalancing action and its `botParam`, binary search for the optimal internal
+     * parameter `intParam` for the internal action's approximation (e.g. for router's swap)
+     */
+    function _calcTradeActionAmountOutAndIntParams(
+        MarketExtState memory marketExt,
+        TradeActionType action,
+        uint256 botParam
+    ) public pure returns (uint256 amountOut, uint256 intParams) {
+        if (action == TradeActionType.RemoveLiqToYt) {
+            (amountOut, intParams) = marketExt.clone().removeLiqToYt(
+                botParam,
+                _getMockApproxParams()
+            );
+        } else {
+            (amountOut, ) = marketExt.clone().addLiqFromYt(botParam);
+        }
+    }
+
+    function searchMaxYtToAddLiq(
+        StrategyData memory strategyData
+    ) public view returns (uint256 maxYtToAddLiq) {
+        (, , , uint256 ytPtRatioAfter) = _calcBotExtStats(
+            strategyData.botState,
+            strategyData.marketExt
+        );
+        if (ytPtRatioAfter < strategyData.specs.targetYtPtRatio) {
+            return 0;
+        }
+
+        ApproxParams memory guessParams = _getMockApproxParamsWithGuessMax(
+            _weakUpperBound(
+                strategyData.botState,
+                strategyData.marketExt,
+                TradeActionType.AddLiqFromYt
+            )
+        );
+        ApproxParams memory mockSwapParams = _getMockApproxParams();
+        while (guessParams.guessMax > guessParams.guessMin + 1) {
+            uint256 guess = guessParams.guessMin +
+                (guessParams.guessMax - guessParams.guessMin) /
+                2;
+            (
+                bool success,
+                BotState memory botStateAfter,
+                MarketExtState memory marketExtAfter
+            ) = previewAction(strategyData, TradeActionType.AddLiqFromYt, guess, mockSwapParams);
+
+            if (!success) {
+                guessParams.guessMax = guess - 1;
+                continue;
+            }
+
+            (, , , ytPtRatioAfter) = _calcBotExtStats(botStateAfter, marketExtAfter);
+            if (ytPtRatioAfter >= strategyData.specs.targetYtPtRatio) {
+                guessParams.guessMin = guess;
+                maxYtToAddLiq = strategyData.botState.ytBalance - botStateAfter.ytBalance;
+            } else {
+                guessParams.guessMax = guess - 1;
+            }
+        }
+        return maxYtToAddLiq;
+    }
+
+    /// @dev Does not modify params, structs are cloned before simulation
+    function previewAction(
+        StrategyData memory strategyData,
+        TradeActionType action,
+        uint256 botParam,
+        ApproxParams memory intParams
+    ) public pure returns (bool success, BotState memory bot, MarketExtState memory marketExt) {
+        bot = strategyData.botState.clone();
+        marketExt = strategyData.marketExt.clone();
+
+        if (action == TradeActionType.AddLiqFromYt) {
+            success = bot.addLiqFromYt(marketExt, botParam);
+        } else if (action == TradeActionType.RemoveLiqToYt) {
+            success = bot.removeLiqToYt(marketExt, botParam, intParams);
+        } else {
+            success = false;
+        }
+    }
+
+    /// @dev Gives a weak upper bound so that MarketExtLib's simulation doesn't revert
+    function _weakUpperBound(
+        BotState memory bot,
+        MarketExtState memory marketExt,
+        TradeActionType action
+    ) internal pure override returns (uint256) {
+        if (action == TradeActionType.AddLiqFromYt) {
+            return marketExt.calcMaxPtOut();
+        } else {
+            return bot.lpBalance;
+        }
+    }
+
+    function _getTradeActionResult(
+        TradeParams memory params,
+        uint256 botParam,
+        uint256 rebalanceAdditionalCheck,
+        uint256 eps,
+        ApproxParams memory intParams
+    ) internal pure override returns (TradeActionResult) {
+        (
+            bool success,
+            BotState memory newBotState,
+            MarketExtState memory marketExt
+        ) = previewAction(params.strategyData, params.action, botParam, intParams);
+
+        if (!success) return TradeActionResult.FAIL_OR_TARGET_EXCEED;
+
+        uint256 iy = marketExt.impliedYield();
+        if (params.action == TradeActionType.AddLiqFromYt) {
+            uint256 netYtSwapped = params.strategyData.botState.ytBalance - newBotState.ytBalance;
+
+            if (netYtSwapped > rebalanceAdditionalCheck) {
+                return TradeActionResult.FAIL_OR_TARGET_EXCEED;
+            }
+            if (Math.isAGreaterApproxB(iy, params.targetIy, eps)) {
+                return TradeActionResult.SUCCESS;
+            } else {
+                if (iy < params.targetIy) return TradeActionResult.FAIL_OR_TARGET_EXCEED;
+                else return TradeActionResult.TARGET_NOT_REACHED;
+            }
+        } else {
+            if (Math.isASmallerApproxB(iy, params.targetIy, eps)) {
+                return TradeActionResult.SUCCESS;
+            } else {
+                if (iy > params.targetIy) return TradeActionResult.FAIL_OR_TARGET_EXCEED;
+                else return TradeActionResult.TARGET_NOT_REACHED;
+            }
+        }
+    }
+
+    function _getRemoveRebalance(
+        StrategyData memory strategyData,
+        uint256 tvl
+    ) internal pure returns (RebalanceType rebalanceType, uint256 amountIn, uint256 amountOut) {
+        uint256 totalSyRequired = tvl.mulDown(strategyData.specs.targetSyRatio) -
+            strategyData.botState.syBalance;
+
+        if (strategyData.botState.lpBalance > 0) {
+            (int256 syFromLp, int256 ptFromLp) = strategyData
+                .marketExt
+                .clone()
+                .state
+                .removeLiquidityCore(strategyData.botState.lpBalance.Int());
+
+            uint256 availablePYToRedeem = Math.min(
+                strategyData.botState.ytBalance,
+                ptFromLp.Uint()
+            );
+
+            // PT should be zpi redeemed together with YT
+            uint256 totalSyZpi = syFromLp.Uint() +
+                strategyData.marketExt.index.assetToSyUp(availablePYToRedeem);
+
+            rebalanceType = RebalanceType.RemoveLpAndYt;
+            amountOut = Math.min(totalSyZpi, totalSyRequired);
+            amountIn = (strategyData.botState.lpBalance * amountOut) / totalSyZpi;
+        } else {
+            // Position now should only consist of SY & YT
+            uint256 syFromYT = strategyData.marketExt.clone().swapYtToSy(
+                strategyData.botState.ytBalance
+            );
+
+            rebalanceType = RebalanceType.SellYt;
+            amountIn = (totalSyRequired * strategyData.botState.ytBalance) / syFromYT;
+            amountOut = strategyData.marketExt.clone().swapYtToSy(amountIn);
+        }
+    }
+}

package/contracts/core/TradingBot/LongYieldTradingBot.sol

@@ -0,0 +1,128 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./TradingBotBase.sol";
+import "./libraries/LongYieldActionLib.sol";
+import "../../interfaces/TradingBot/ILongYieldTradingBot.sol";
+import "../../interfaces/IPMarketSwapCallback.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+
+contract LongYieldTradingBot is
+    TradingBotBase,
+    UUPSUpgradeable,
+    ILongYieldTradingBot,
+    IPMarketSwapCallback
+{
+    using MarketExtLib for MarketExtState;
+    using Math for uint256;
+    using Math for int256;
+
+    constructor(
+        address _market,
+        address _router,
+        address _PENDLE,
+        address _decisionHelper
+    ) TradingBotBase(_market, _router, _PENDLE, _decisionHelper) {}
+
+    function _authorizeUpgrade(address) internal override onlyOwner {}
+
+    function initialize(TradingSpecs memory _specs) external initializer {
+        _setSpecs(_specs);
+        __BoringOwnable_init();
+    }
+
+    function removeLiquidityToSy(
+        uint256 netLpToRemove,
+        uint256 minSyOut
+    ) external onlyOwner returns (uint256 netSyOut) {
+        return LongYieldActionLib.removeLiquidityToSy(market, netLpToRemove, minSyOut);
+    }
+
+
+    function swapYtToSy(
+        uint256 netYtToSell,
+        uint256 minSyOut
+    ) external onlyOwner returns (uint256 netSyOut) {
+        return LongYieldActionLib.swapYtToSy(market, netYtToSell, minSyOut);
+    }
+
+    function addLiqKeepYt(
+        uint256 netSyIn,
+        uint256 minLpOut,
+        uint256 minYtOut
+    ) external onlyOwner returns (uint256 netLpOut, uint256 netYtOut) {
+        (netLpOut, netYtOut) = LongYieldActionLib.addLiqKeepYt(
+            market,
+            netSyIn,
+            minLpOut,
+            minYtOut
+        );
+        emit AddLiqKeepYt(netSyIn, netLpOut, netYtOut);
+    }
+
+    function addLiqFromYt(
+        AddLiqFromYtInput calldata inputParams
+    ) external onlyOwner returns (uint256 netPtFromSwap, uint256 netLpOut, uint256 netYtIn) {
+        StrategyData memory strategyData = readStrategyData();
+
+        require(
+            IBotDecisionHelper(decisionHelper).getCurrentBin(strategyData) ==
+                inputParams.currentBin,
+            "addLiqFromYt: bin state expired"
+        );
+        netPtFromSwap = decisionHelper.searchForBotParam(
+            readStrategyData(),
+            TradeActionType.AddLiqFromYt,
+            inputParams.targetIy,
+            type(uint256).max,
+            inputParams.botParams,
+            inputParams.botParams // only placeholder, value doesn't matter
+        );
+        (netLpOut, netYtIn) = LongYieldActionLib.addLiqFromYt(
+            market,
+            netPtFromSwap,
+            inputParams.minLpOut
+        );
+
+        _updateSellBinAfterTrade();
+
+        emit AddLiqFromYt(inputParams.botParams, netYtIn, netLpOut);
+    }
+
+    function removeLiqToYt(
+        RemoveLiqToYtInput calldata inputParams
+    ) external onlyOwner returns (uint256 netLpRemoved, uint256 netYtOut) {
+        StrategyData memory strategyData = readStrategyData();
+
+        require(
+            IBotDecisionHelper(decisionHelper).getCurrentBin(strategyData) ==
+                inputParams.currentBin,
+            "removeLiqToYt: bin state expired"
+        );
+
+        netLpRemoved = decisionHelper.searchForBotParam(
+            strategyData,
+            TradeActionType.RemoveLiqToYt,
+            inputParams.targetIy,
+            type(uint256).max,
+            inputParams.botParams,
+            inputParams.guessTotalPtToSwap // value DOES matter
+        );
+
+        (netYtOut, ) = LongYieldActionLib.removeLiqToYt(
+            market,
+            netLpRemoved,
+            inputParams.guessTotalPtToSwap,
+            inputParams.minYtOut
+        );
+
+        _updateSellBinAfterTrade();
+
+        emit RemoveLiqToYt(inputParams.botParams, netLpRemoved, netYtOut);
+    }
+
+    function swapCallback(int256 ptToAccount, int256 syToAccount, bytes calldata data) external {
+        require(msg.sender == market, "not market");
+        LongYieldActionLib.swapCallback(market, ptToAccount, syToAccount, data);
+    }
+}

package/contracts/core/TradingBot/README.md

@@ -0,0 +1,153 @@
+# Trading Bot
+
+## Structs and enums
+
+### MarketExtState
+
+Struct for external market state.
+
+- `state`: MarketState
+- `index`: YT's index
+- `blockTime`: timestamp
+
+### BotState
+
+Struct for bot's balances: `lpBalance`, `ytBalance`, `syBalance`.
+
+### TradingSpecs
+
+Struct for bot's trading limits:
+
+- `lowerIyLimit`: apeYtApy
+- `upperIyLimit`: sellYtApy
+- `floatingSyRatioLimit`: h_r - f/TVL limit, TVL calculated in number of SY.
+- `floatingSyRatioTarget`: l_r - f/TVL target.
+- `ytPtRatioLimit`: h_x - limit for YT/PT
+- `ytPtRatioTarget`: l_x - target for YT/PT
+
+### ActionType
+
+Enum for action.
+
+- 0: SwapSyToYt - Buy YT with SY
+- 1: AddLiqKeepYt - ZPI Zap
+- 2: AddLiqFromSy - Single sided LP
+- 3: AddLiqFromYt - Sell YT for LP
+- 4: RemoveLiqToYt - Zap out to YT
+- 5: NONE
+
+### StrategyFlag
+
+Enum for strategy state.
+
+- 0: GOOD
+- 1: TOO_LOW
+- 2: TOO_HIGH
+
+### StrategyState
+
+Struct for strategy state.
+
+- `iyFlag`: StrategyFlag for IY compared to ape/sellYtApy
+- `syRatioFlag`: StrategyFlag for f/TVL compared to given limit \(r\)
+
+## TradingBotBase.sol
+
+### 1. depositSy
+
+Deposit SY into the bot.
+- SY approval needed.
+
+### 2. depositToken
+
+Deposit funds into the bot, which are then compounded into SY.
+- `inp`: Token input data to swap deposited token to SY. 
+- If `inp.netTokenIn` is set to `2**256 - 1` then it will be set to `_selfBalance()` internally.`
+- Needs sender's approval to bot & bot's approval to router.
+
+### 3. withdrawFunds
+
+Withdraw funds back to sender (only owner).
+
+### 4. approveInf
+
+Infinite approve token to spender.
+
+### 5. claimAndCompound
+
+Claim rewards from SY, YT, market. Then compound the rewards into SY.
+
+- `inps`: Token input data to swap claimed rewards into SY
+- If `inp.netTokenIn` is set to `2**256 - 1` then it will be set to `_selfBalance()` internally.
+- Needs sender's approval to bot & bot's approval to router for tokens.
+
+### 6. claimWithoutCompound
+Intended to be static called from offchain. Claim rewards from SY, YT, market, then return amounts of tokens claimed.
+
+### 7. readMarketExtState
+Return the current `MarketExtState`: state of market, YT's index, current block timestamp.
+
+### 8. readBotState
+Return the current `BotState`: The bot's balance in LP, SY, YT.
+
+
+## LongYieldTradingBot.sol
+
+There are 5 functions for rebalancing actions.
+- For all of them, `botParams` is ApproxParams to find the optimal internal trade parameter.
+- For functions interacting with the router, approval is needed.
+
+### 1. setSpecs
+
+Set the bot's specs: apeYtApy, sellYtApy, h_r (f/TVL limit), l_r (f/TVL target), h_x (YT/PT ratio limit), l_x (YT/PT ratio target).
+
+### 2. swapSyToYt
+
+Rebalance by buying YT with SY. 
+
+### 3. addLiqKeepYt
+
+Rebalance by ZPI zap. 
+
+### 4. addLiqFromSy
+
+Rebalance by adding single sided LP from SY.
+
+### 5. addLiqFromYt
+
+Rebalance by selling YT to LP. 
+
+### 6. removeLiqToYt
+
+Rebalance by zapping out LP to YT.
+
+- `intParams`: ApproxParams for internal approx function (approxSwapExactPtForYt).
+- Zapping LP to YT can lose a few percent of the `tvlInSy`, the estimated TVL of bot in SY. Zapping out too much can cause a significant change in `tvlInSy`, which can unintentionally increase the estimated f/TVL.
+
+## BotDecisionHelper.sol
+
+Offchain helper for trading bot.
+
+### 1. searchForBotParam
+Binary search for the optimal `botParam` for the rebalancing action. To be used in bot's actual rebalancing actions.
+
+- Searches for the minimum `botParam` so that the bot trades just "target" is met.
+- Target to meet is calculated based on the `action` (desired f/TVL, YT/PT, IY).
+- `botParam`: The parameter for the rebalancing function (e.g. `netPtFromSwap` for addLiqFromSy).
+
+### 2. searchForIntParam
+(Only useful for `removeLiqToYt`) 
+Given `botParam`, binary search for the optimal `intParam` for the internal calculations (e.g. `approxSwapExactPtForYt`).
+
+### 3. strategyState
+Calculate the strategy state from BotState, MarketExtState, TradingSpecs.
+
+### 4. actionToTake
+Return optimal action to take based on the BotState and StrategyState.
+
+### 5. previewAction
+Simulate rebalancing action (swap/add/remove) from BotState and MarketExtState.
+
+### 6. botExtStats
+Calculate the external stats for the bot: Estimated TVL in equivalent SY amount, current IY, current f/TVL ratio, current YT/PT ratio
+