@pendle/core-v2 2.15.2 → 2.17.0-tradingbot

package/contracts/core/TradingBot/BotActionCallback.sol

@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../interfaces/IPMarketSwapCallback.sol";
+import "./BotDecisionLib.sol";
+import "./TradingBotBase.sol";
+
+abstract contract BotActionCallback is TradingBotBase, IPMarketSwapCallback {
+    using Math for int256;
+
+    modifier onlyMarket(address caller) {
+        if (caller != market) revert Errors.BotCallbackNotMarket(caller);
+        _;
+    }
+
+    function swapCallback(
+        int256 ptToAccount,
+        int256 syToAccount,
+        bytes calldata data
+    ) external override onlyMarket(msg.sender) {
+        ActionType swapType = _getActionType(data);
+        if (swapType == ActionType.AddLiqFromYt) {
+            _callbackAddLiqFromYt(ptToAccount, syToAccount, data);
+        } else if (swapType == ActionType.RemoveLiqToYt) {
+            _callbackRemoveLiqToYt(ptToAccount, syToAccount, data);
+        } else {
+            assert(false);
+        }
+    }
+
+    /// ------------------------------------------------------------
+    /// AddLiqFromYt
+    /// ------------------------------------------------------------
+
+    function _callbackAddLiqFromYt(
+        int256 ptToAccount,
+        int256 /*syToAccount*/,
+        bytes calldata data
+    ) internal {
+        uint256 netPyRedeemSy = _decodeAddLiqFromYt(data);
+
+        _transferOut(PT, YT, netPyRedeemSy);
+
+        bool needToBurnYt = (!IPYieldToken(YT).isExpired());
+        if (needToBurnYt) _transferOut(YT, YT, netPyRedeemSy);
+
+        IPYieldToken(YT).redeemPY(market); // all SY goes to market to repay and mint LP
+
+        _transferOut(PT, market, ptToAccount.Uint() - netPyRedeemSy); // remaining PT goes to market to mint LP
+    }
+
+    function _encodeAddLiqFromYt(uint256 netPyRedeemSy) internal pure returns (bytes memory res) {
+        res = new bytes(64);
+        uint256 actionType = uint256(ActionType.AddLiqFromYt);
+
+        assembly {
+            mstore(add(res, 32), actionType)
+            mstore(add(res, 64), netPyRedeemSy)
+        }
+    }
+
+    function _decodeAddLiqFromYt(
+        bytes calldata data
+    ) internal pure returns (uint256 netPyRedeemSy) {
+        assembly {
+            // first 32 bytes is ActionType
+            netPyRedeemSy := calldataload(add(data.offset, 32))
+        }
+    }
+
+    /// ------------------------------------------------------------
+    /// RemoveLiqToYt
+    /// ------------------------------------------------------------
+
+    function _callbackRemoveLiqToYt(
+        int256 /*ptToAccount*/,
+        int256 /*syToAccount*/,
+        bytes calldata data
+    ) internal {
+        uint256 minYtOut = _decodeRemoveLiqToYt(data);
+
+        uint256 netYtOut = IPYieldToken(YT).mintPY(market, address(this)); // PT goes to market to repay
+        if (netYtOut < minYtOut) revert Errors.BotInsufficientYtOut(netYtOut, minYtOut); // 2nd check
+    }
+
+    function _encodeRemoveLiqToYt(uint256 minYtOut) internal pure returns (bytes memory res) {
+        res = new bytes(64);
+        uint256 actionType = uint256(ActionType.RemoveLiqToYt);
+
+        assembly {
+            mstore(add(res, 32), actionType)
+            mstore(add(res, 64), minYtOut)
+        }
+    }
+
+    function _decodeRemoveLiqToYt(bytes calldata data) internal pure returns (uint256 minYtOut) {
+        assembly {
+            // first 32 bytes is ActionType
+            minYtOut := calldataload(add(data.offset, 32))
+        }
+    }
+
+    /// ------------------------------------------------------------
+    /// Misc functions
+    /// ------------------------------------------------------------
+
+    function _getActionType(bytes calldata data) internal pure returns (ActionType actionType) {
+        assembly {
+            actionType := calldataload(data.offset)
+        }
+    }
+}

package/contracts/core/TradingBot/BotActionHelper.sol

@@ -0,0 +1,138 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./TradingBotBase.sol";
+import "./BotActionCallback.sol";
+
+abstract contract BotActionHelper is TradingBotBase, BotActionCallback {
+    using PYIndexLib for IPYieldToken;
+    using PYIndexLib for PYIndex;
+    using MarketMathCore for MarketState;
+    using MarketApproxPtInLib for MarketState;
+    using Math for int256;
+
+    bytes internal constant EMPTY_BYTES = abi.encode();
+
+    function _swapSyToYt(
+        address router,
+        uint256 exactYtOut,
+        uint256 maxSyIn
+    ) internal returns (uint256 netSyIn) {
+        (netSyIn, ) = IPAllAction(router).swapSyForExactYt(
+            address(this),
+            market,
+            exactYtOut,
+            maxSyIn
+        );
+    }
+
+    function _addLiqKeepYt(
+        address router,
+        uint256 netSyIn,
+        uint256 minLpOut,
+        uint256 minYtOut
+    ) internal returns (uint256 /*netLpOut*/, uint256 /*netYtOut*/) {
+        return
+            IPAllAction(router).addLiquiditySingleSyKeepYt(
+                address(this),
+                market,
+                netSyIn,
+                minLpOut,
+                minYtOut
+            );
+    }
+
+    /// @dev Mimics PendleRouter's addLiquiditySingleSy
+    function _addLiqFromSy(
+        uint256 netPtFromSwap,
+        uint256 minLpOut,
+        uint256 maxSyIn
+    ) internal returns (uint256 netLpOut, uint256 netSyIn) {
+        MarketState memory state = IPMarket(market).readState(address(this));
+        PYIndex index = IPYieldToken(YT).newIndex();
+
+        (uint256 netSyToSwap, , ) = state.swapSyForExactPt(index, netPtFromSwap, block.timestamp);
+        (, , uint256 netSyToAdd, ) = state.addLiquidity(
+            maxSyIn - netSyToSwap,
+            netPtFromSwap,
+            block.timestamp
+        ); // ensures netSyToAdd <= maxSyIn - netSyToSwap
+        netSyIn = netSyToSwap + netSyToAdd;
+
+        _transferOut(SY, market, netSyIn);
+        IPMarket(market).swapSyForExactPt(market, netPtFromSwap, EMPTY_BYTES); // PT goes to market for LP
+        (netLpOut, , ) = IPMarket(market).mint(address(this), netSyToAdd, netPtFromSwap);
+
+        if (netLpOut < minLpOut) revert Errors.BotInsufficientLpOut(netLpOut, minLpOut);
+    }
+
+    function _addLiqFromYt(
+        uint256 netPtFromSwap,
+        uint256 minLpOut,
+        uint256 maxYtIn
+    ) internal returns (uint256 netLpOut, uint256 netYtIn) {
+        MarketState memory state = IPMarket(market).readState(address(this));
+        PYIndex index = IPYieldToken(YT).newIndex();
+
+        (uint256 netSyToSwap, , ) = state.swapSyForExactPt(index, netPtFromSwap, block.timestamp);
+
+        // (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(index);
+        uint256 netPtToAddNumerator = (netPtFromSwap * Math.ONE - netSyToSwap * pyIndex);
+        uint256 netPtToAddDenominator = (Math.ONE +
+            (state.totalSy.Uint() * pyIndex) /
+            state.totalPt.Uint());
+        uint256 netPtToAdd = netPtToAddNumerator / netPtToAddDenominator;
+
+        netYtIn = netPtFromSwap - netPtToAdd; // = netPtRedeemSy
+        if (netYtIn > maxYtIn) revert Errors.BotExceededLimitYtIn(netYtIn, maxYtIn);
+
+        IPMarket(market).swapSyForExactPt(
+            address(this),
+            netPtFromSwap,
+            _encodeAddLiqFromYt(netYtIn)
+        );
+
+        uint256 netSyFromPy = index.assetToSy(netYtIn);
+        uint256 netSyToAdd = netSyFromPy - netSyToSwap;
+
+        (netLpOut, , ) = IPMarket(market).mint(address(this), netSyToAdd, netPtToAdd);
+        if (netLpOut < minLpOut) revert Errors.BotInsufficientLpOut(netLpOut, minLpOut);
+    }
+
+    /// @dev Behaves like PendleRouter's removeLiquidityDualSyAndPt then swapExactPtForYt
+    /// @param guessTotalPtToSwap Same like for PendleRouter's swapExactPtForYt
+    function _removeLiqToYt(
+        uint256 netLpToRemove,
+        ApproxParams memory guessTotalPtToSwap,
+        uint256 minYtOut
+    ) internal returns (uint256 netYtOut) {
+        _transferOut(market, market, netLpToRemove);
+        (uint256 netSyFromLp, uint256 netPtFromLp) = IPMarket(market).burn(
+            YT,
+            market,
+            netLpToRemove
+        ); // SY goes to YT to mint PY, PT goes to market to swap
+
+        MarketState memory state = IPMarket(market).readState(address(this));
+        PYIndex index = IPYieldToken(YT).newIndex();
+
+        uint256 netPtFromSy = index.syToAsset(netSyFromLp);
+        (uint256 netYtFromSwap, uint256 totalPtToSwap, ) = state.approxSwapExactPtForYt(
+            index,
+            netPtFromLp + netPtFromSy,
+            block.timestamp,
+            guessTotalPtToSwap
+        );
+
+        netYtOut = netYtFromSwap + netPtFromSy;
+        if (netYtOut < minYtOut) revert Errors.BotInsufficientYtOut(netYtOut, minYtOut);
+
+        IPMarket(market).swapExactPtForSy(YT, totalPtToSwap, _encodeRemoveLiqToYt(minYtOut)); // SY goes to YT to mint PY
+    }
+}

package/contracts/core/TradingBot/BotDecisionLib.sol

@@ -0,0 +1,272 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "./BotSimulationLib.sol";
+import "../libraries/Errors.sol";
+
+struct LongTradingSpecs {
+    uint256 lowerIyLimit; // apeYtApy
+    uint256 upperIyLimit; // sellYtApy
+    uint256 floatingSyRatioLimit; // r
+    uint256 ytPtRatioLimit; // ytPtRatio (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;
+}
+
+library BotDecisionLib {
+    using MarketExtLib for MarketExtState;
+    using MarketExtLib for ApproxParams;
+    using BotSimulationLib for BotState;
+    using Math for uint256;
+
+    enum RebalanceResult {
+        FAIL,
+        OLD_STATE,
+        NEW_STATE
+    }
+
+    struct RebalanceDetails {
+        BotState bot;
+        MarketExtState marketExt;
+        LongTradingSpecs specs;
+        ActionType action;
+        StrategyState oldState;
+    }
+
+    /**
+     * Finds the smallest paramater such that the bot reaches a new state, otherwise finds the
+     * largest parameter possible that doesn't fail.
+     *
+     * @param botParams ApproxParams for this binary search function
+     * @param oldState The initial StrategyState, to be moved away from
+     * @param intParams ApproxParams for internal action's approximation (e.g. for router's swap)
+     * @dev For `botParams`, eps = the precision such that slightly lower
+     * ((return value) * (1 - eps)) does not reach a new state
+     *
+     * - Returns `botParams.guessOffchain` if verifies that it reaches a new state,
+     * and slightly lower does not reach a new state.
+     * - Reverts if `botParams.guessMin` is invalid, or returns `botParams.guessMin` if reaches a
+     * new state
+     * - Returns `botParams.guessMax` if it is valid & does not reach a new state
+     * - Otherwise, binary search for `guess` such that it reaches a new state, and slightly lower
+     * does not reach a new state
+     *
+     */
+    function binarySearchUntilSwitchState(
+        BotState memory bot,
+        MarketExtState memory marketExt,
+        LongTradingSpecs memory specs,
+        ActionType action,
+        StrategyState memory oldState,
+        ApproxParams memory botParams,
+        ApproxParams memory intParams
+    ) internal pure returns (uint256) {
+        RebalanceDetails memory rebalance = RebalanceDetails(
+            bot,
+            marketExt,
+            specs,
+            action,
+            oldState
+        );
+
+        if (botParams.guessOffchain != 0) {
+            uint256 guessOffchainMinusDelta = botParams.guessOffchain.mulDown(
+                Math.ONE - botParams.eps
+            );
+            if (
+                _rebalanceResult(rebalance, botParams.guessOffchain, intParams) ==
+                RebalanceResult.NEW_STATE &&
+                _rebalanceResult(rebalance, guessOffchainMinusDelta, intParams) ==
+                RebalanceResult.OLD_STATE
+            ) return botParams.guessOffchain;
+        }
+
+        {
+            uint256 guessUpperBound = _weakUpperBound(bot, marketExt, action);
+            if (botParams.guessMax > guessUpperBound) botParams.guessMax = guessUpperBound;
+            if (botParams.guessMin > botParams.guessMax)
+                revert Errors.BotBinarySearchInvalidRange(
+                    uint256(action),
+                    botParams.guessMin,
+                    botParams.guessMax
+                );
+
+            if (
+                _rebalanceResult(rebalance, botParams.guessMax, intParams) ==
+                RebalanceResult.OLD_STATE
+            ) return botParams.guessMax;
+        }
+
+        {
+            RebalanceResult guessMinResult = _rebalanceResult(
+                rebalance,
+                botParams.guessMin,
+                intParams
+            );
+            if (guessMinResult == RebalanceResult.FAIL)
+                revert Errors.BotBinarySearchGuessMinInvalid(uint256(action), botParams.guessMin);
+            if (guessMinResult == RebalanceResult.NEW_STATE) return botParams.guessMin;
+        }
+
+        for (uint256 iter = 0; iter < botParams.maxIteration; ++iter) {
+            uint256 guess = botParams.guessMin + (botParams.guessMax - botParams.guessMin) / 2;
+
+            if (_rebalanceResult(rebalance, guess, intParams) == RebalanceResult.OLD_STATE) {
+                botParams.guessMin = guess;
+            } else {
+                botParams.guessMax = guess;
+            }
+
+            if (Math.isASmallerApproxB(botParams.guessMin, botParams.guessMax, botParams.eps)) {
+                if (
+                    _rebalanceResult(rebalance, botParams.guessMax, intParams) ==
+                    RebalanceResult.FAIL
+                ) return botParams.guessMin;
+
+                return botParams.guessMax;
+            }
+        }
+
+        revert Errors.BotBinarySearchFail();
+    }
+
+    function _rebalanceResult(
+        RebalanceDetails memory rebalance,
+        uint256 botParam,
+        ApproxParams memory intParams
+    ) private pure returns (RebalanceResult) {
+        (bool success, StrategyState memory newState) = _stateAfterRebalance(
+            rebalance,
+            botParam,
+            intParams
+        );
+
+        if (!success) return RebalanceResult.FAIL;
+        if (_sameStrategyState(rebalance.oldState, newState)) return RebalanceResult.OLD_STATE;
+        return RebalanceResult.NEW_STATE;
+    }
+
+    function _sameStrategyState(
+        StrategyState memory initialState,
+        StrategyState memory otherState
+    ) private pure returns (bool) {
+        return
+            (initialState.iyFlag == otherState.iyFlag) &&
+            (initialState.syRatioFlag == otherState.syRatioFlag);
+    }
+
+    function _stateAfterRebalance(
+        RebalanceDetails memory rebalance,
+        uint256 botParam,
+        ApproxParams memory intParams
+    ) private pure returns (bool success, StrategyState memory currentState) {
+        BotState memory botClone = rebalance.bot.clone();
+        MarketExtState memory marketExtClone = rebalance.marketExt.clone();
+
+        if (rebalance.action == ActionType.SwapSyToYt) {
+            success = botClone.swapSyToYt(marketExtClone, botParam);
+        } else if (rebalance.action == ActionType.AddLiqKeepYt) {
+            success = botClone.addLiqKeepYt(marketExtClone, botParam);
+        } else if (rebalance.action == ActionType.AddLiqFromSy) {
+            success = botClone.addLiqFromSy(marketExtClone, botParam);
+        } else if (rebalance.action == ActionType.AddLiqFromYt) {
+            success = botClone.addLiqFromYt(marketExtClone, botParam);
+        } else if (rebalance.action == ActionType.RemoveLiqToYt) {
+            success = botClone.removeLiqToYt(marketExtClone, botParam, intParams.clone());
+        } else {
+            success = false;
+        }
+
+        if (success) {
+            currentState = strategyState(botClone, marketExtClone, rebalance.specs);
+        }
+    }
+
+    /// @dev Gives a weak upper bound so that MarketExtLib's simulation doesn't revert
+    function _weakUpperBound(
+        BotState memory bot,
+        MarketExtState memory marketExt,
+        ActionType action
+    ) private pure returns (uint256) {
+        if (action == ActionType.SwapSyToYt) {
+            return marketExt.calcMaxPtIn();
+        } else if (action == ActionType.AddLiqKeepYt) {
+            return bot.syBalance;
+        } else if (action == ActionType.AddLiqFromSy) {
+            return marketExt.calcMaxPtOut();
+        } else if (action == ActionType.AddLiqFromYt) {
+            return marketExt.calcMaxPtOut();
+        } else if (action == ActionType.RemoveLiqToYt) {
+            return bot.lpBalance;
+        } else {
+            return 0;
+        }
+    }
+
+    function strategyState(
+        BotState memory bot,
+        MarketExtState memory marketExt,
+        LongTradingSpecs memory specs
+    ) internal pure returns (StrategyState memory currentState) {
+        uint256 iy = marketExt.impliedYield();
+        (, uint256 ptInLp) = marketExt.previewAssetsFromLp(bot.lpBalance);
+        uint256 currentYtPtRatio = (
+            ptInLp == 0 ? type(uint256).max : bot.ytBalance.divDown(ptInLp)
+        );
+
+        if (iy < specs.lowerIyLimit) {
+            currentState.iyFlag = StrategyFlag.TOO_LOW;
+        } else if (specs.upperIyLimit < iy && currentYtPtRatio > specs.ytPtRatioLimit) {
+            currentState.iyFlag = StrategyFlag.TOO_HIGH;
+        } else {
+            currentState.iyFlag = StrategyFlag.GOOD;
+        }
+
+        uint256 currentSyRatio = bot.syBalance.divDown(bot.tvlInSy(marketExt));
+        if (currentSyRatio > specs.floatingSyRatioLimit) {
+            currentState.syRatioFlag = StrategyFlag.TOO_HIGH;
+        } else {
+            currentState.syRatioFlag = StrategyFlag.GOOD;
+        }
+    }
+
+    function actionToTake(StrategyState memory currentState) internal pure returns (ActionType) {
+        if (currentState.iyFlag == StrategyFlag.TOO_LOW) {
+            if (currentState.syRatioFlag == StrategyFlag.TOO_HIGH) {
+                return ActionType.SwapSyToYt;
+            } else {
+                return ActionType.RemoveLiqToYt;
+            }
+        } else if (currentState.iyFlag == StrategyFlag.GOOD) {
+            if (currentState.syRatioFlag == StrategyFlag.TOO_HIGH) {
+                return ActionType.AddLiqKeepYt;
+            } else {
+                return ActionType.NONE;
+            }
+        } else {
+            if (currentState.syRatioFlag == StrategyFlag.TOO_HIGH) {
+                return ActionType.AddLiqFromSy;
+            } else {
+                return ActionType.AddLiqFromYt;
+            }
+        }
+    }
+}

package/contracts/core/TradingBot/BotSimulationLib.sol

@@ -0,0 +1,115 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "./MarketExtLib.sol";
+
+struct BotState {
+    uint256 lpBalance;
+    uint256 ytBalance;
+    uint256 syBalance;
+}
+
+library BotSimulationLib {
+    using MarketMathCore for MarketState;
+    using MarketExtLib for MarketExtState;
+    using Math for uint256;
+    using Math for int256;
+
+    function swapSyToYt(
+        BotState memory bot,
+        MarketExtState memory marketExt,
+        uint256 exactYtOut
+    ) internal pure returns (bool /*success*/) {
+        uint256 netSyIn = marketExt.swapSyToYt(exactYtOut);
+
+        if (netSyIn > bot.syBalance) return false;
+
+        bot.syBalance -= netSyIn;
+        bot.ytBalance += exactYtOut;
+
+        return true;
+    }
+
+    function addLiqKeepYt(
+        BotState memory bot,
+        MarketExtState memory marketExt,
+        uint256 netSyIn
+    ) internal pure returns (bool /*success*/) {
+        if (netSyIn > bot.syBalance) return false;
+
+        (uint256 netLpOut, uint256 netYtOut) = marketExt.addLiqKeepYt(netSyIn);
+
+        bot.syBalance -= netSyIn;
+        bot.lpBalance += netLpOut;
+        bot.ytBalance += netYtOut;
+
+        return true;
+    }
+
+    function addLiqFromSy(
+        BotState memory bot,
+        MarketExtState memory marketExt,
+        uint256 netPtFromSwap
+    ) internal pure returns (bool /*success*/) {
+        (uint256 netLpOut, uint256 netSyIn) = marketExt.addLiqFromSy(netPtFromSwap);
+
+        if (netSyIn > bot.syBalance) return false;
+
+        bot.syBalance -= netSyIn;
+        bot.lpBalance += netLpOut;
+
+        return true;
+    }
+
+    function addLiqFromYt(
+        BotState memory bot,
+        MarketExtState memory marketExt,
+        uint256 netPtFromSwap
+    ) internal pure returns (bool /*success*/) {
+        (uint256 netLpOut, uint256 netYtIn) = marketExt.addLiqFromYt(netPtFromSwap);
+
+        if (netYtIn > bot.ytBalance) return false;
+
+        bot.ytBalance -= netYtIn;
+        bot.lpBalance += netLpOut;
+
+        return true;
+    }
+
+    function removeLiqToYt(
+        BotState memory bot,
+        MarketExtState memory marketExt,
+        uint256 netLpToRemove,
+        ApproxParams memory approxParams
+    ) internal pure returns (bool /*success*/) {
+        if (netLpToRemove > bot.lpBalance) return false;
+
+        uint256 netYtOut = marketExt.removeLiqToYt(netLpToRemove, approxParams);
+
+        bot.lpBalance -= netLpToRemove;
+        bot.ytBalance += netYtOut;
+
+        return true;
+    }
+
+    /// @dev Only for estimation, does not reflect exact SY amount that would be redeemed
+    function tvlInSy(
+        BotState memory bot,
+        MarketExtState memory marketExt
+    ) internal pure returns (uint256) {
+        (uint256 syInLp, uint256 ptInLp) = marketExt.previewAssetsFromLp(bot.lpBalance);
+        uint256 totalValue = bot.syBalance + syInLp;
+        if (ptInLp <= bot.ytBalance) {
+            totalValue += marketExt.previewPyToSy(ptInLp);
+            totalValue += marketExt.clone().swapYtToSy(bot.ytBalance - ptInLp);
+        } else {
+            totalValue += marketExt.previewPyToSy(bot.ytBalance);
+            totalValue += marketExt.clone().swapPtToSy(ptInLp - bot.ytBalance);
+        }
+        return totalValue;
+    }
+
+    function clone(BotState memory bot) internal pure returns (BotState memory) {
+        return BotState(bot.lpBalance, bot.ytBalance, bot.syBalance);
+    }
+}