@pendle/core-v2 2.17.0 → 2.17.2-tradingbot

package/contracts/core/TradingBot/MarketExtLib.sol

@@ -0,0 +1,246 @@
+// 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;
+}
+
+library MarketExtLib {
+    using MarketMathCore for MarketState;
+    using MarketApproxPtInLib 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 = 31536000;
+
+    /// @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 swapSyForExactYt
+    function swapSyToYt(
+        MarketExtState memory marketExt,
+        uint256 exactYtOut
+    ) internal pure returns (uint256 /*netSyIn*/) {
+        (uint256 netSyReceivedInt, , ) = marketExt.state.swapExactPtForSy(
+            marketExt.index,
+            exactYtOut,
+            marketExt.blockTime
+        );
+
+        uint256 totalSyNeedInt = marketExt.index.assetToSyUp(exactYtOut);
+        return totalSyNeedInt.subMax0(netSyReceivedInt);
+    }
+
+    /// @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, , ) = marketExt.state.addLiquidity(
+            netSyIn - netSyToPt,
+            netYtOut,
+            marketExt.blockTime
+        );
+    }
+
+    function addLiqFromSy(
+        MarketExtState memory marketExt,
+        uint256 netPtFromSwap
+    ) internal pure returns (uint256 netLpOut, uint256 netSyIn) {
+        (uint256 netSyToSwap, , ) = marketExt.state.swapSyForExactPt(
+            marketExt.index,
+            netPtFromSwap,
+            marketExt.blockTime
+        );
+        uint256 netSyToAdd = (netPtFromSwap * marketExt.state.totalSy.Uint()) /
+            marketExt.state.totalPt.Uint();
+
+        (, netLpOut, , ) = marketExt.state.addLiquidity(
+            netSyToAdd,
+            netPtFromSwap,
+            marketExt.blockTime
+        );
+        netSyIn = netSyToSwap + netSyToAdd;
+    }
+
+    function addLiqFromYt(
+        MarketExtState memory marketExt,
+        uint256 netPtFromSwap
+    ) internal pure returns (uint256 netLpOut, uint256 netYtIn) {
+        (uint256 netSyToSwap, , ) = marketExt.state.swapSyForExactPt(
+            marketExt.index,
+            netPtFromSwap,
+            marketExt.blockTime
+        );
+
+        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, , ) = marketExt.state.addLiquidity(
+            netSyToAdd,
+            netPtToAdd,
+            marketExt.blockTime
+        );
+    }
+
+    /// @dev Simulates PendleRouter's removeLiquidityDualSyAndPt then swapExactPtForYt
+    function removeLiqToYt(
+        MarketExtState memory marketExt,
+        uint256 netLpToRemove,
+        ApproxParams memory approxParams
+    ) internal pure returns (uint256 /*netYtOut*/) {
+        (uint256 netSyRemoved, uint256 netPtRemoved) = marketExt.state.removeLiquidity(
+            netLpToRemove
+        );
+
+        uint256 netYtFromSy = marketExt.index.syToAsset(netSyRemoved);
+        uint256 netPtToSwap = netPtRemoved + netYtFromSy;
+
+        (uint256 netYtFromSwap, uint256 totalPtToSwap, ) = marketExt.state.approxSwapExactPtForYt(
+            marketExt.index,
+            netPtToSwap,
+            marketExt.blockTime,
+            clone(approxParams)
+        );
+
+        marketExt.state.swapExactPtForSy(marketExt.index, totalPtToSwap, marketExt.blockTime);
+
+        return netYtFromSy + netYtFromSwap;
+    }
+
+    function previewPyToSy(
+        MarketExtState memory marketExt,
+        uint256 netPYToRedeem
+    ) internal pure returns (uint256) {
+        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(
+            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/README.md

@@ -0,0 +1,151 @@
+# Trading Bot
+
+## Structs and enums
+
+### MarketExtLib
+
+Struct for external market state.
+
+- `state`: MarketState
+- `index`: YT's index
+- `blockTime`: timestamp
+
+### BotState
+
+Struct for bot's balances: `lpBalance`, `ytBalance`, `syBalance`.
+
+### LongTradingSpecs
+
+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
+
+### 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. readMarketExtState
+Return the current `MarketExtState`: state of market, YT's index, current block timestamp.
+
+### 7. 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, r (f/TVL limit), x (YT/PT ratio).
+
+### 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 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.
+
+## TradingBotOffchain.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.
+
+### 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`.
+- `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`).
+
+### 5. strategyState
+Calculate the strategy state from BotState, MarketExtState, LongTradingSpecs.
+
+### 6. actionToTake
+Return optimal action to take based on the strategy state.
+
+### 7. tvlInSy
+
+Calculate the TVL in equivalent SY amount.
+

package/contracts/core/TradingBot/TradingBotBase.sol

@@ -0,0 +1,131 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+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 PYIndexLib for IPYieldToken;
+
+    address public immutable market;
+    address public immutable SY;
+    address public immutable PT;
+    address public immutable YT;
+    address public immutable PENDLE;
+
+    constructor(address _market, address _PENDLE) initializer {
+        (IStandardizedYield _SY, IPPrincipalToken _PT, IPYieldToken _YT) = IPMarket(_market)
+            .readTokens();
+
+        market = _market;
+        SY = address(_SY);
+        PT = address(_PT);
+        YT = address(_YT);
+        PENDLE = _PENDLE;
+
+        __BoringOwnable_init();
+    }
+
+    function depositSy(uint256 netSyIn) external onlyOwner {
+        _transferIn(SY, msg.sender, netSyIn);
+        emit DepositSy(netSyIn);
+    }
+
+    /// @dev Receives token and compound to SY
+    function depositToken(
+        address router,
+        TokenInput calldata inp,
+        uint256 minSyOut
+    ) external payable onlyOwner {
+        _transferIn(inp.tokenIn, msg.sender, inp.netTokenIn);
+        _compoundSingle(router, inp, minSyOut);
+        emit DepositToken(inp.tokenIn, inp.netTokenIn);
+    }
+
+    function withdrawFunds(address token, uint256 amount) external onlyOwner {
+        if (amount == type(uint256).max) amount = _selfBalance(token);
+        _transferOut(token, msg.sender, amount);
+        emit WithdrawFunds(token, amount);
+    }
+
+    function claimAndCompound(
+        address router,
+        TokenInput[] calldata inps,
+        uint256 minSyOut
+    ) external onlyOwner returns (uint256 netSyOut, uint256 netPendleOut) {
+        _claimRewards();
+
+        netSyOut = _compound(router, inps, minSyOut);
+
+        netPendleOut = _selfBalance(PENDLE);
+        _transferOut(PENDLE, owner, netPendleOut);
+        emit ClaimAndCompound(netSyOut, netPendleOut);
+    }
+
+    function readMarketExtState(address router) public returns (MarketExtState memory marketExt) {
+        marketExt.state = IPMarket(market).readState(router);
+        marketExt.index = IPYieldToken(YT).newIndex();
+        marketExt.blockTime = block.timestamp;
+    }
+
+    function readBotState() public view returns (BotState memory botState) {
+        botState.lpBalance = _selfBalance(market);
+        botState.syBalance = _selfBalance(SY);
+        botState.ytBalance = _selfBalance(YT);
+    }
+
+    receive() external payable {}
+
+    function _claimRewards() internal {
+        IPYieldToken(YT).redeemDueInterestAndRewards(address(this), true, true);
+        IStandardizedYield(SY).claimRewards(address(this));
+        IPMarket(market).redeemRewards(address(this));
+    }
+
+    function _compound(
+        address router,
+        TokenInput[] calldata inps,
+        uint256 minSyOut
+    ) internal returns (uint256 netSyOut) {
+        netSyOut = 0;
+
+        for (uint256 i = 0; i < inps.length; ++i) {
+            netSyOut += _compoundSingle(router, inps[i], 0);
+        }
+
+        if (netSyOut < minSyOut) revert Errors.BotInsufficientSyOut(netSyOut, minSyOut);
+        return netSyOut;
+    }
+
+    function _compoundSingle(
+        address router,
+        TokenInput memory inp,
+        uint256 minSyOut
+    ) internal returns (uint256 /*netSyOut*/) {
+        if (inp.netTokenIn == type(uint256).max) inp.netTokenIn = _selfBalance(inp.tokenIn);
+
+        return
+            IPAllAction(router).mintSyFromToken{
+                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/core/TradingBot/TradingBotOffchain.sol

@@ -0,0 +1,137 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./BotDecisionLib.sol";
+import "../libraries/TokenAmountLib.sol";
+
+contract TradingBotOffchain {
+    using TokenAmountLib for TokenAmount[];
+    using BotSimulationLib for BotState;
+    using MarketMathCore for MarketState;
+    using MarketApproxPtInLib for MarketState;
+    using PYIndexLib for PYIndex;
+
+    address immutable public decisionLib;
+
+    constructor(address _decisionLib) {
+        decisionLib = _decisionLib;
+    }   
+
+    /// SY interest from YT is excluded
+    function claimForBot(
+        address bot,
+        address market
+    ) external returns (TokenAmount[] memory rewards) {
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
+
+        address[] memory ytRewardTokens = YT.getRewardTokens();
+        (, uint256[] memory ytRewardAmounts) = YT.redeemDueInterestAndRewards(bot, true, true);
+        rewards = rewards.add(ytRewardTokens, ytRewardAmounts);
+
+        address[] memory syRewardTokens = SY.getRewardTokens();
+        uint256[] memory syRewardAmounts = SY.claimRewards(bot);
+        rewards = rewards.add(syRewardTokens, syRewardAmounts);
+
+        address[] memory lpRewardTokens = IPMarket(market).getRewardTokens();
+        uint256[] memory lpRewardAmounts = IPMarket(market).redeemRewards(bot);
+        rewards = rewards.add(lpRewardTokens, lpRewardAmounts);
+    }
+
+    function simulateAction(
+        BotState calldata botCalldata,
+        MarketExtState calldata marketExtCalldata,
+        ActionType action,
+        uint256 botParam,
+        ApproxParams memory swapApproxParams
+    ) external view returns (bool success, BotState memory bot, MarketExtState memory marketExt) {
+        bot = botCalldata;
+        marketExt = marketExtCalldata;
+
+        if (action == ActionType.SwapSyToYt) {
+            success = bot.swapSyToYt(marketExt, botParam);
+        } else if (action == ActionType.AddLiqKeepYt) {
+            success = bot.addLiqKeepYt(marketExt, botParam);
+        } else if (action == ActionType.AddLiqFromSy) {
+            success = bot.addLiqFromSy(marketExt, botParam);
+        } else if (action == ActionType.AddLiqFromYt) {
+            success = bot.addLiqFromYt(marketExt, botParam);
+        } else if (action == ActionType.RemoveLiqToYt) {
+            success = bot.removeLiqToYt(marketExt, botParam, swapApproxParams);
+        } else {
+            success = false;
+        }
+    }
+
+    function searchForBotParam(
+        BotState calldata bot,
+        MarketExtState calldata marketExt,
+        LongTradingSpecs calldata specs,
+        ActionType action,
+        StrategyState calldata initialState,
+        ApproxParams calldata botParams,
+        ApproxParams calldata intParams
+    ) external view returns (uint256) {
+        return
+            BotDecisionLib(decisionLib).binarySearchUntilSwitchState(
+                bot,
+                marketExt,
+                specs,
+                action,
+                initialState,
+                botParams,
+                intParams
+            );
+    }
+
+    function searchForIntParam(
+        MarketExtState calldata marketExt,
+        ActionType action,
+        uint256 botParam,
+        ApproxParams calldata intParams
+    ) external view returns (uint256) {
+        if (action == ActionType.RemoveLiqToYt) {
+            return _searchForIntParamRemoveLiqToYt(marketExt, botParam, intParams);
+        } else {
+            return 0;
+        }
+    }
+
+    function strategyState(
+        BotState calldata bot,
+        MarketExtState calldata marketExt,
+        LongTradingSpecs calldata specs
+    ) external view returns (StrategyState memory) {
+        return BotDecisionLib(decisionLib).strategyState(bot, marketExt, specs);
+    }
+
+    function actionToTake(StrategyState memory currentState) external view returns (ActionType) {
+        return BotDecisionLib(decisionLib).actionToTake(currentState);
+    }
+
+    function tvlInSy(
+        BotState calldata bot,
+        MarketExtState calldata marketExt
+    ) external view returns (uint256) {
+        return BotSimulationLib.tvlInSy(bot, marketExt);
+    }
+
+    function _searchForIntParamRemoveLiqToYt(
+        MarketExtState memory marketExt,
+        uint256 netLpToRemove,
+        ApproxParams memory intParams
+    ) private view returns (uint256 totalPtToSwap) {
+        (uint256 netSyRemoved, uint256 netPtRemoved) = marketExt.state.removeLiquidity(
+            netLpToRemove
+        );
+
+        uint256 netYtFromSy = marketExt.index.syToAsset(netSyRemoved);
+        uint256 netPtToSwap = netPtRemoved + netYtFromSy;
+
+        (, totalPtToSwap, ) = marketExt.state.approxSwapExactPtForYt(
+            marketExt.index,
+            netPtToSwap,
+            marketExt.blockTime,
+            intParams
+        );
+    }
+}

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);
 }