@pendle/core-v2 2.17.5-tradingbot → 2.17.6-tradingbot

package/contracts/core/TradingBot/LongYieldTradingBot.sol

@@ -3,7 +3,6 @@ pragma solidity 0.8.17;
 
 import "./TradingBotBase.sol";
 import "./BotActionHelper.sol";
-import "./BotDecisionLib.sol";
 import "../../interfaces/TradingBot/ILongYieldTradingBot.sol";
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 
@@ -14,14 +13,14 @@ contract LongYieldTradingBot is
     UUPSUpgradeable
 {
     LongTradingSpecs public specs;
-    address public immutable decisionLib;
+    IBotDecisionHelper public immutable decisionHelper;
 
     constructor(
         address _market,
         address _PENDLE,
-        address _decisionLib
+        address _decisionHelper
     ) TradingBotBase(_market, _PENDLE) {
-        decisionLib = _decisionLib;
+        decisionHelper = BotDecisionHelper(_decisionHelper);
     }
 
     function _authorizeUpgrade(address) internal override onlyOwner {}
@@ -36,22 +35,27 @@ contract LongYieldTradingBot is
     }
 
     function _setSpecs(LongTradingSpecs memory _specs) internal {
+        require(_specs.lowerIyLimit <= _specs.upperIyLimit, "INVALID_IY_LIMITS");
+        require(
+            _specs.floatingSyRatioLimit >= _specs.floatingSyRatioTarget,
+            "INVALID_FLOATING_SY_RATIO"
+        );
+        require(_specs.ytPtRatioLimit >= _specs.ytPtRatioTarget, "INVALID_YT_PT_RATIO");
+
         specs = _specs;
     }
 
     function swapSyToYt(
         address router,
-        StrategyState memory oldState,
         ApproxParams calldata botParams,
         uint256 minYtOut,
         uint256 maxSyIn
     ) external onlyOwner returns (uint256 exactYtOut, uint256 netSyIn) {
-        exactYtOut = BotDecisionLib(decisionLib).binarySearchUntilSwitchState(
+        (exactYtOut, ) = decisionHelper.searchForBotParam(
             readBotState(),
             readMarketExtState(router),
             specs,
             ActionType.SwapSyToYt,
-            oldState,
             botParams,
             botParams // only placeholder, value doesn't matter
         );
@@ -59,23 +63,21 @@ contract LongYieldTradingBot is
         if (exactYtOut < minYtOut) revert Errors.BotInsufficientYtOut(exactYtOut, minYtOut);
         netSyIn = _swapSyToYt(router, exactYtOut, maxSyIn);
 
-        emit SwapSyToYt(oldState, botParams, maxSyIn, exactYtOut, netSyIn);
+        emit SwapSyToYt(botParams, maxSyIn, exactYtOut, netSyIn);
     }
 
     function addLiqKeepYt(
         address router,
-        StrategyState memory oldState,
         ApproxParams calldata botParams,
         uint256 maxSyIn,
         uint256 minLpOut,
         uint256 minYtOut
     ) external onlyOwner returns (uint256 netSyIn, uint256 netLpOut, uint256 netYtOut) {
-        netSyIn = BotDecisionLib(decisionLib).binarySearchUntilSwitchState(
+        (netSyIn, ) = decisionHelper.searchForBotParam(
             readBotState(),
             readMarketExtState(router),
             specs,
             ActionType.AddLiqKeepYt,
-            oldState,
             botParams,
             botParams // only placeholder, value doesn't matter
         );
@@ -83,63 +85,57 @@ contract LongYieldTradingBot is
         if (netSyIn > maxSyIn) revert Errors.BotExceededLimitSyIn(netSyIn, maxSyIn);
         (netLpOut, netYtOut) = _addLiqKeepYt(router, netSyIn, minLpOut, minYtOut);
 
-        emit AddLiqKeepYt(oldState, botParams, maxSyIn, netSyIn, netLpOut, netYtOut);
+        emit AddLiqKeepYt(botParams, maxSyIn, netSyIn, netLpOut, netYtOut);
     }
 
     function addLiqFromSy(
-        StrategyState memory oldState,
         ApproxParams calldata botParams,
         uint256 minLpOut,
         uint256 maxSyIn
     ) external onlyOwner returns (uint256 netPtFromSwap, uint256 netLpOut, uint256 netSyIn) {
-        netPtFromSwap = BotDecisionLib(decisionLib).binarySearchUntilSwitchState(
+        (netPtFromSwap, ) = decisionHelper.searchForBotParam(
             readBotState(),
             readMarketExtState(address(this)),
             specs,
             ActionType.AddLiqFromSy,
-            oldState,
             botParams,
             botParams // only placeholder, value doesn't matter
         );
 
         (netLpOut, netSyIn) = _addLiqFromSy(netPtFromSwap, minLpOut, maxSyIn);
 
-        emit AddLiqFromSy(oldState, botParams, maxSyIn, netSyIn, netLpOut);
+        emit AddLiqFromSy(botParams, maxSyIn, netSyIn, netLpOut);
     }
 
     function addLiqFromYt(
-        StrategyState memory oldState,
         ApproxParams calldata botParams,
         uint256 minLpOut,
         uint256 maxYtIn
     ) external onlyOwner returns (uint256 netPtFromSwap, uint256 netLpOut, uint256 netYtIn) {
-        netPtFromSwap = BotDecisionLib(decisionLib).binarySearchUntilSwitchState(
+        (netPtFromSwap, ) = decisionHelper.searchForBotParam(
             readBotState(),
             readMarketExtState(address(this)),
             specs,
             ActionType.AddLiqFromYt,
-            oldState,
             botParams,
             botParams // only placeholder, value doesn't matter
         );
         (netLpOut, netYtIn) = _addLiqFromYt(netPtFromSwap, minLpOut, maxYtIn);
 
-        emit AddLiqFromYt(oldState, botParams, maxYtIn, netYtIn, netLpOut);
+        emit AddLiqFromYt(botParams, maxYtIn, netYtIn, netLpOut);
     }
 
     function removeLiqToYt(
-        StrategyState memory oldState,
         ApproxParams calldata botParams,
         ApproxParams calldata guessTotalPtToSwap,
         uint256 maxLpRemoved,
         uint256 minYtOut
     ) external onlyOwner returns (uint256 netLpRemoved, uint256 netYtOut, uint256 totalPtToSwap) {
-        netLpRemoved = BotDecisionLib(decisionLib).binarySearchUntilSwitchState(
+        (netLpRemoved, ) = decisionHelper.searchForBotParam(
             readBotState(),
             readMarketExtState(address(this)),
             specs,
             ActionType.RemoveLiqToYt,
-            oldState,
             botParams,
             guessTotalPtToSwap // value DOES matter
         );
@@ -149,6 +145,6 @@ contract LongYieldTradingBot is
 
         (netYtOut, totalPtToSwap) = _removeLiqToYt(netLpRemoved, guessTotalPtToSwap, minYtOut);
 
-        emit RemoveLiqToYt(oldState, botParams, maxLpRemoved, netLpRemoved, netYtOut);
+        emit RemoveLiqToYt(botParams, maxLpRemoved, netLpRemoved, netYtOut);
     }
 }

package/contracts/core/TradingBot/MarketExtLib.sol

@@ -77,11 +77,7 @@ library MarketExtLib {
 
         netYtOut = marketExt.index.syToAsset(netSyToPt);
 
-        (, netLpOut, , ) = marketExt.state.addLiquidity(
-            netSyIn - netSyToPt,
-            netYtOut,
-            marketExt.blockTime
-        );
+        netLpOut = addLiqDual(marketExt, netSyIn - netSyToPt, netYtOut);
     }
 
     function addLiqFromSy(
@@ -96,11 +92,7 @@ library MarketExtLib {
         uint256 netSyToAdd = (netPtFromSwap * marketExt.state.totalSy.Uint()) /
             marketExt.state.totalPt.Uint();
 
-        (, netLpOut, , ) = marketExt.state.addLiquidity(
-            netSyToAdd,
-            netPtFromSwap,
-            marketExt.blockTime
-        );
+        netLpOut = addLiqDual(marketExt, netSyToAdd, netPtFromSwap);
         netSyIn = netSyToSwap + netSyToAdd;
     }
 
@@ -126,11 +118,7 @@ library MarketExtLib {
         uint256 netSyFromPy = marketExt.index.assetToSy(netYtIn);
         uint256 netSyToAdd = netSyFromPy - netSyToSwap;
 
-        (, netLpOut, , ) = marketExt.state.addLiquidity(
-            netSyToAdd,
-            netPtToAdd,
-            marketExt.blockTime
-        );
+        netLpOut = addLiqDual(marketExt, netSyToAdd, netPtToAdd);
     }
 
     /// @dev Simulates PendleRouter's removeLiquidityDualSyAndPt then swapExactPtForYt
@@ -138,15 +126,14 @@ library MarketExtLib {
         MarketExtState memory marketExt,
         uint256 netLpToRemove,
         ApproxParams memory approxParams
-    ) internal pure returns (uint256 /*netYtOut*/) {
-        (uint256 netSyRemoved, uint256 netPtRemoved) = marketExt.state.removeLiquidity(
-            netLpToRemove
-        );
+    ) 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, uint256 totalPtToSwap, ) = marketExt.state.approxSwapExactPtForYt(
+        uint256 netYtFromSwap;
+        (netYtFromSwap, totalPtToSwap, ) = marketExt.state.approxSwapExactPtForYt(
             marketExt.index,
             netPtToSwap,
             marketExt.blockTime,
@@ -155,7 +142,61 @@ library MarketExtLib {
 
         marketExt.state.swapExactPtForSy(marketExt.index, totalPtToSwap, marketExt.blockTime);
 
-        return netYtFromSy + netYtFromSwap;
+        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(
@@ -165,14 +206,6 @@ library MarketExtLib {
         return marketExt.index.assetToSy(netPYToRedeem);
     }
 
-    function previewAssetsFromLp(
-        MarketExtState memory marketExt,
-        uint256 lpBalance
-    ) internal pure returns (uint256 syInLp, uint256 ptInLp) {
-        syInLp = (lpBalance * marketExt.state.totalSy.Uint()) / marketExt.state.totalLp.Uint();
-        ptInLp = (lpBalance * marketExt.state.totalPt.Uint()) / marketExt.state.totalLp.Uint();
-    }
-
     /// @notice Returns the trade exchange rate, fee excluded
     function exchangeRate(MarketExtState memory marketExt) internal pure returns (uint256) {
         MarketPreCompute memory comp = marketExt.state.getMarketPreCompute(
@@ -230,10 +263,10 @@ library MarketExtLib {
 
     function calcMaxPtIn(MarketExtState memory marketExt) internal pure returns (uint256) {
         return
-            MarketApproxPtInLib.calcMaxPtIn(
+            (MarketApproxPtInLib.calcMaxPtIn(
                 marketExt.state,
                 marketExt.state.getMarketPreCompute(marketExt.index, marketExt.blockTime)
-            ) * 9 / 10;
+            ) * 9) / 10;
     }
 
     function calcMaxPtOut(MarketExtState memory marketExt) internal pure returns (uint256) {

package/contracts/core/TradingBot/README.md

@@ -2,7 +2,7 @@
 
 ## Structs and enums
 
-### MarketExtLib
+### MarketExtState
 
 Struct for external market state.
 
@@ -20,8 +20,10 @@ Struct for bot's trading limits:
 
 - `lowerIyLimit`: apeYtApy
 - `upperIyLimit`: sellYtApy
-- `floatingSyRatioLimit`: f/TVL limit, TVL calculated in number of SY.
-- `ytPtRatioLimit`: limit for YT/PT
+- `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
 
@@ -79,10 +81,13 @@ Claim rewards from SY, YT, market. Then compound the 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. readMarketExtState
+### 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.
 
-### 7. readBotState
+### 8. readBotState
 Return the current `BotState`: The bot's balance in LP, SY, YT.
 
 
@@ -94,7 +99,7 @@ There are 5 functions for rebalancing actions.
 
 ### 1. setSpecs
 
-Set the bot's specs: apeYtApy, sellYtApy, r (f/TVL limit), x (YT/PT ratio).
+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
 
@@ -117,35 +122,32 @@ Rebalance by selling YT to LP.
 Rebalance by zapping out LP to YT.
 
 - `intParams`: ApproxParams for internal approx function (approxSwapExactPtForYt).
-- Zapping LP to YT can lose a few percent of trading value. Zapping out too much can cause a significant change in TVL, so the resulting strategy state can differ from expected, which can cause unintended behaviour.
+- 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.
 
-## TradingBotOffchain.sol
+## BotDecisionHelper.sol
 
 Offchain helper for trading bot.
 
-### 1. claimForBot
-Claim rewards for bot, return the list of reward tokens and amounts claimed.
-
-### 2. simulateAction
-Simulate rebalancing action (swap/add/remove) from BotState and MarketExtState.
+### 1. searchForBotParam
+Binary search for the optimal `botParam` for the rebalancing action. To be used in bot's actual rebalancing actions.
 
-### 3. searchForBotParam
-Binary search for the optimal `botParam` for the rebalancing action. Simulate the same process used in the bot's rebalancing functions.
-
-- Searches for the minimum `botParam` so that the bot trades just until the bot's new strategy state would differ from `initialState`.
+- 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).
 
-### 4. searchForIntParam
-(Only useful for `removeLiqToYt`). 
-Given the `botParam`, binary search for the optimal `intParam` for the internal calculations (for `approxSwapExactPtForYt`).
+### 2. searchForIntParam
+(Only useful for `removeLiqToYt`) 
+Given `botParam`, binary search for the optimal `intParam` for the internal calculations (e.g. `approxSwapExactPtForYt`).
 
-### 5. strategyState
+### 3. strategyState
 Calculate the strategy state from BotState, MarketExtState, LongTradingSpecs.
 
-### 6. actionToTake
-Return optimal action to take based on the strategy state.
+### 4. actionToTake
+Return optimal action to take based on the BotState and StrategyState.
 
-### 7. tvlInSy
+### 5. previewAction
+Simulate rebalancing action (swap/add/remove) from BotState and MarketExtState.
 
-Calculate the TVL in equivalent SY amount.
+### 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
 

package/contracts/core/TradingBot/TradingBotBase.sol

@@ -3,12 +3,12 @@ pragma solidity 0.8.17;
 
 import "../libraries/BoringOwnableUpgradeable.sol";
 import "../libraries/TokenHelper.sol";
-import "../../interfaces/IPAllAction.sol";
 import "../../interfaces/TradingBot/ITradingBotBase.sol";
 
 import "./BotSimulationLib.sol";
 
 abstract contract TradingBotBase is BoringOwnableUpgradeable, TokenHelper, ITradingBotBase {
+    using TokenAmountLib for TokenAmount[];
     using PYIndexLib for IPYieldToken;
 
     address public immutable market;
@@ -30,6 +30,21 @@ abstract contract TradingBotBase is BoringOwnableUpgradeable, TokenHelper, ITrad
         __BoringOwnable_init();
     }
 
+    function approveInf(MultiApproval[] calldata arr) external onlyOwner {
+        for (uint256 i = 0; i < arr.length; ) {
+            MultiApproval calldata ele = arr[i];
+            for (uint256 j = 0; j < ele.tokens.length; ) {
+                _safeApproveInf(ele.tokens[j], ele.spender);
+                unchecked {
+                    j++;
+                }
+            }
+            unchecked {
+                i++;
+            }
+        }
+    }
+
     function depositSy(uint256 netSyIn) external onlyOwner {
         _transferIn(SY, msg.sender, netSyIn);
         emit DepositSy(netSyIn);
@@ -66,6 +81,26 @@ abstract contract TradingBotBase is BoringOwnableUpgradeable, TokenHelper, ITrad
         emit ClaimAndCompound(netSyOut, netPendleOut);
     }
 
+    /// Claim without compound, intended for offchain usage
+    /// @dev SY interest from YT is excluded
+    function claimWithoutCompound() external onlyOwner returns (TokenAmount[] memory rewards) {
+        address[] memory ytRewardTokens = IPYieldToken(YT).getRewardTokens();
+        (, uint256[] memory ytRewardAmounts) = IPYieldToken(YT).redeemDueInterestAndRewards(
+            address(this),
+            true,
+            true
+        );
+        rewards = rewards.add(ytRewardTokens, ytRewardAmounts);
+
+        address[] memory syRewardTokens = IStandardizedYield(SY).getRewardTokens();
+        uint256[] memory syRewardAmounts = IStandardizedYield(SY).claimRewards(address(this));
+        rewards = rewards.add(syRewardTokens, syRewardAmounts);
+
+        address[] memory lpRewardTokens = IPMarket(market).getRewardTokens();
+        uint256[] memory lpRewardAmounts = IPMarket(market).redeemRewards(address(this));
+        rewards = rewards.add(lpRewardTokens, lpRewardAmounts);
+    }
+
     function readMarketExtState(address router) public returns (MarketExtState memory marketExt) {
         marketExt.state = IPMarket(market).readState(router);
         marketExt.index = IPYieldToken(YT).newIndex();
@@ -113,19 +148,4 @@ abstract contract TradingBotBase is BoringOwnableUpgradeable, TokenHelper, ITrad
                 value: inp.tokenIn == NATIVE ? inp.netTokenIn : 0
             }(address(this), SY, minSyOut, inp);
     }
-
-    function approveInf(MultiApproval[] calldata arr) external onlyOwner {
-        for (uint256 i = 0; i < arr.length; ) {
-            MultiApproval calldata ele = arr[i];
-            for (uint256 j = 0; j < ele.tokens.length; ) {
-                _safeApproveInf(ele.tokens[j], ele.spender);
-                unchecked {
-                    j++;
-                }
-            }
-            unchecked {
-                i++;
-            }
-        }
-    }
 }

package/contracts/interfaces/TradingBot/IBotDecisionHelper.sol

@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../core/TradingBot/BotSimulationLib.sol";
+
+struct LongTradingSpecs {
+    uint256 lowerIyLimit; // apeYtApy
+    uint256 upperIyLimit; // sellYtApy
+    uint256 floatingSyRatioLimit; // h_r
+    uint256 floatingSyRatioTarget; // l_r
+    uint256 ytPtRatioLimit; // h_x
+    uint256 ytPtRatioTarget; // l_x
+}
+
+enum ActionType {
+    SwapSyToYt, // Buy YT with SY
+    AddLiqKeepYt, // ZPI Zap
+    AddLiqFromSy, // Single sided LP
+    AddLiqFromYt, // Sell YT for LP
+    RemoveLiqToYt, // Zap out to YT,
+    NONE
+}
+
+enum StrategyFlag {
+    GOOD,
+    TOO_LOW,
+    TOO_HIGH
+}
+
+struct StrategyState {
+    StrategyFlag iyFlag;
+    StrategyFlag syRatioFlag;
+}
+
+interface IBotDecisionHelper {
+    enum RebalanceResult {
+        FAIL,
+        TARGET_REACHED,
+        TARGET_NOT_REACHED
+    }
+
+    struct RebalanceDetails {
+        BotState bot;
+        MarketExtState marketExt;
+        LongTradingSpecs specs;
+        ActionType action;
+    }
+
+    function searchForBotParam(
+        BotState memory bot,
+        MarketExtState memory marketExt,
+        LongTradingSpecs memory specs,
+        ActionType action,
+        ApproxParams memory botParams,
+        ApproxParams memory intParams
+    ) external pure returns (uint256, RebalanceResult);
+
+    function searchForIntParam(
+        MarketExtState memory marketExt,
+        ActionType action,
+        uint256 botParam,
+        ApproxParams memory intParams
+    ) external pure returns (uint256);
+
+    function strategyState(
+        BotState memory bot,
+        MarketExtState memory marketExt,
+        LongTradingSpecs memory specs
+    ) external pure returns (StrategyState memory);
+
+    function actionToTake(
+        BotState memory botState,
+        StrategyState memory currentState
+    ) external pure returns (ActionType);
+
+    function previewAction(
+        BotState memory botData,
+        MarketExtState memory marketExtData,
+        ActionType action,
+        uint256 botParam,
+        ApproxParams memory swapApproxParams
+    ) external pure returns (bool, BotState memory, MarketExtState memory);
+
+    function botExtStats(
+        BotState memory bot,
+        MarketExtState memory marketExt
+    )
+        external
+        pure
+        returns (uint256 tvlInSy, uint256 iy, uint256 currentSyRatio, uint256 currentYtPtRatio);
+}

package/contracts/interfaces/TradingBot/ILongYieldTradingBot.sol

@@ -2,21 +2,12 @@
 pragma solidity 0.8.17;
 
 import "./ITradingBotBase.sol";
-import "../../core/TradingBot/BotDecisionLib.sol";
+import "./IBotDecisionHelper.sol";
 
-interface ILongYieldTradingBot {
-    function setSpecs(LongTradingSpecs calldata _specs) external;
-
-    event SwapSyToYt(
-        StrategyState state,
-        ApproxParams botParams,
-        uint256 maxSyIn,
-        uint256 exactYtOut,
-        uint256 netSyIn
-    );
+interface ILongYieldTradingBot is ITradingBotBase {
+    event SwapSyToYt(ApproxParams botParams, uint256 maxSyIn, uint256 exactYtOut, uint256 netSyIn);
 
     event AddLiqKeepYt(
-        StrategyState state,
         ApproxParams botParams,
         uint256 maxSyIn,
         uint256 netSyIn,
@@ -24,33 +15,21 @@ interface ILongYieldTradingBot {
         uint256 netYtOut
     );
 
-    event AddLiqFromSy(
-        StrategyState state,
-        ApproxParams botParams,
-        uint256 maxSyIn,
-        uint256 netSyIn,
-        uint256 netLpOut
-    );
+    event AddLiqFromSy(ApproxParams botParams, uint256 maxSyIn, uint256 netSyIn, uint256 netLpOut);
 
-    event AddLiqFromYt(
-        StrategyState state,
-        ApproxParams botParams,
-        uint256 maxYtIn,
-        uint256 netYtIn,
-        uint256 netLpOut
-    );
+    event AddLiqFromYt(ApproxParams botParams, uint256 maxYtIn, uint256 netYtIn, uint256 netLpOut);
 
     event RemoveLiqToYt(
-        StrategyState state,
         ApproxParams botParams,
         uint256 maxLpRemoved,
         uint256 netLpIn,
         uint256 netYtOut
     );
 
+    function setSpecs(LongTradingSpecs calldata _specs) external;
+
     function swapSyToYt(
         address router,
-        StrategyState memory oldState,
         ApproxParams calldata botParams,
         uint256 minYtOut,
         uint256 maxSyIn
@@ -58,7 +37,6 @@ interface ILongYieldTradingBot {
 
     function addLiqKeepYt(
         address router,
-        StrategyState memory oldState,
         ApproxParams calldata botParams,
         uint256 maxSyIn,
         uint256 minLpOut,
@@ -66,21 +44,18 @@ interface ILongYieldTradingBot {
     ) external returns (uint256 netSyIn, uint256 netLpOut, uint256 netYtOut);
 
     function addLiqFromSy(
-        StrategyState memory oldState,
         ApproxParams calldata botParams,
         uint256 minLpOut,
         uint256 maxSyIn
     ) external returns (uint256 netPtFromSwap, uint256 netLpOut, uint256 netSyIn);
 
     function addLiqFromYt(
-        StrategyState memory oldState,
         ApproxParams calldata botParams,
         uint256 minLpOut,
         uint256 maxYtIn
     ) external returns (uint256 netPtFromSwap, uint256 netLpOut, uint256 netYtIn);
 
     function removeLiqToYt(
-        StrategyState memory oldState,
         ApproxParams calldata botParams,
         ApproxParams calldata guessTotalPtToSwap,
         uint256 maxLpRemoved,