@pendle/core-v2 2.18.0 → 2.19.0-tradingbot

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

@@ -0,0 +1,155 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "./MarketExtLib.sol";
+import "../../../interfaces/TradingBot/IBotDecisionHelper.sol";
+
+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,
+            cloneApproxParams(approxParams)
+        );
+
+        bot.lpBalance -= netLpToRemove;
+        bot.ytBalance += netYtOut;
+
+        return true;
+    }
+
+    function swapPtToYt(
+        BotState memory bot,
+        MarketExtState memory marketExt,
+        uint256 netPtToSwap,
+        ApproxParams memory approxParams
+    ) internal pure returns (bool /*success*/) {
+        if (netPtToSwap > bot.ptBalance) return false;
+        (uint256 netYtOut, ) = marketExt.swapPtToYt(netPtToSwap, cloneApproxParams(approxParams));
+        bot.ptBalance -= netPtToSwap;
+        bot.ytBalance += netYtOut;
+        return true;
+    }
+
+    function swapYtToPt(
+        BotState memory bot,
+        MarketExtState memory marketExt,
+        uint256 netYtToSwap,
+        ApproxParams memory approxParams
+    ) internal pure returns (bool /*success*/) {
+        if (netYtToSwap > bot.ytBalance) return false;
+        (uint256 netPtOut, ) = marketExt.swapYtToPt(netYtToSwap, cloneApproxParams(approxParams));
+        bot.ptBalance += netPtOut;
+        bot.ytBalance -= netYtToSwap;
+        return true;
+    }
+
+    function tvlInSy(
+        BotState memory bot,
+        MarketExtState memory marketExt
+    ) internal pure returns (uint256) {
+        MarketExtState memory marketExtClone = marketExt.clone();
+
+        (uint256 syInLp, uint256 ptInLp) = marketExtClone.removeLiqDual(bot.lpBalance);
+        uint256 totalValue = bot.syBalance + syInLp;
+
+        uint256 totalPt = ptInLp + bot.ptBalance;
+        if (totalPt <= bot.ytBalance) {
+            totalValue += marketExtClone.previewPyToSy(totalPt);
+            totalValue += marketExtClone.swapYtToSy(bot.ytBalance - totalPt);
+        } else {
+            totalValue += marketExtClone.previewPyToSy(bot.ytBalance);
+            totalValue += marketExtClone.swapPtToSy(totalPt - bot.ytBalance);
+        }
+        return totalValue;
+    }
+
+    function clone(BotState memory bot) internal pure returns (BotState memory) {
+        return BotState(bot.lpBalance, bot.ytBalance, bot.ptBalance, bot.syBalance, bot.buyBins);
+    }
+
+    function cloneApproxParams(
+        ApproxParams memory params
+    ) internal pure returns (ApproxParams memory) {
+        return
+            ApproxParams(
+                params.guessMin,
+                params.guessMax,
+                params.guessOffchain,
+                params.maxIteration,
+                params.eps
+            );
+    }
+}

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

@@ -0,0 +1,310 @@
+// 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 MarketApproxPtOutLib for MarketState;
+    using PYIndexLib for PYIndex;
+    using PYIndexLib for IPYieldToken;
+    using LogExpMath for uint256;
+    using Math for uint256;
+    using Math for int256;
+
+    uint256 public constant ONE_YEAR = 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 = addLiqDual(marketExt, netSyIn - netSyToPt, netYtOut);
+    }
+
+    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 = addLiqDual(marketExt, netSyToAdd, netPtFromSwap);
+        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 = addLiqDual(marketExt, netSyToAdd, netPtToAdd);
+    }
+
+    /// @dev Simulates PendleRouter's removeLiquidityDualSyAndPt then swapExactPtForYt
+    function removeLiqToYt(
+        MarketExtState memory marketExt,
+        uint256 netLpToRemove,
+        ApproxParams memory approxParams
+    ) internal pure returns (uint256 netYtOut, uint256 totalPtToSwap) {
+        (uint256 netSyRemoved, uint256 netPtRemoved) = removeLiqDual(marketExt, netLpToRemove);
+
+        uint256 netYtFromSy = marketExt.index.syToAsset(netSyRemoved);
+        uint256 netPtToSwap = netPtRemoved + netYtFromSy;
+
+        uint256 netYtFromSwap;
+        (netYtFromSwap, totalPtToSwap, ) = marketExt.state.approxSwapExactPtForYt(
+            marketExt.index,
+            netPtToSwap,
+            marketExt.blockTime,
+            clone(approxParams)
+        );
+
+        marketExt.state.swapExactPtForSy(marketExt.index, totalPtToSwap, marketExt.blockTime);
+
+        netYtOut = netYtFromSy + netYtFromSwap;
+    }
+
+    /// @dev Simplified version of MarketMathCore's addLiquidity
+    function addLiqDual(
+        MarketExtState memory marketExt,
+        uint256 netSyIn,
+        uint256 netPtIn
+    ) internal pure returns (uint256 /*netLpOut*/) {
+        require(
+            !MiniHelpers.isExpired(marketExt.state.expiry, marketExt.blockTime),
+            "MarketExtLib: expired market"
+        );
+        require(marketExt.state.totalLp > 0, "MarketExtLib: LP < 0");
+
+        int256 syDesired = netSyIn.Int();
+        int256 ptDesired = netPtIn.Int();
+        int256 lpToAccount;
+        int256 ptUsed;
+        int256 syUsed;
+
+        int256 netLpByPt = (ptDesired * marketExt.state.totalLp) / marketExt.state.totalPt;
+        int256 netLpBySy = (syDesired * marketExt.state.totalLp) / marketExt.state.totalSy;
+        if (netLpByPt < netLpBySy) {
+            lpToAccount = netLpByPt;
+            ptUsed = ptDesired;
+            syUsed = (marketExt.state.totalSy * lpToAccount) / marketExt.state.totalLp;
+        } else {
+            lpToAccount = netLpBySy;
+            syUsed = syDesired;
+            ptUsed = (marketExt.state.totalPt * lpToAccount) / marketExt.state.totalLp;
+        }
+
+        marketExt.state.totalSy += syUsed;
+        marketExt.state.totalPt += ptUsed;
+        marketExt.state.totalLp += lpToAccount;
+
+        return lpToAccount.Uint();
+    }
+
+    /// @dev Simplified version of MarketMathCore's removeLiquidity
+    function removeLiqDual(
+        MarketExtState memory marketExt,
+        uint256 netLpToRemove
+    ) internal pure returns (uint256 /*netSyToAccount*/, uint256 /*netPtToAccount*/) {
+        int256 lpToRemove = netLpToRemove.Int();
+
+        int256 netSyToAccount = (lpToRemove * marketExt.state.totalSy) / marketExt.state.totalLp;
+        int256 netPtToAccount = (lpToRemove * marketExt.state.totalPt) / marketExt.state.totalLp;
+
+        marketExt.state.totalLp = marketExt.state.totalLp.subNoNeg(lpToRemove);
+        marketExt.state.totalPt = marketExt.state.totalPt.subNoNeg(netPtToAccount);
+        marketExt.state.totalSy = marketExt.state.totalSy.subNoNeg(netSyToAccount);
+
+        return (netSyToAccount.Uint(), netPtToAccount.Uint());
+    }
+
+    function swapPtToYt(
+        MarketExtState memory marketExt,
+        uint256 exactPtIn,
+        ApproxParams memory approxParams
+    ) internal pure returns (uint256 netYtOut, uint256 totalPtToSwap) {
+        (netYtOut, totalPtToSwap,) = marketExt.state.approxSwapExactPtForYt(
+            marketExt.index,
+            exactPtIn,
+            marketExt.blockTime,
+            approxParams
+        );
+
+        marketExt.state.swapExactPtForSy(marketExt.index, totalPtToSwap, marketExt.blockTime);
+    }
+
+    function swapYtToPt(
+        MarketExtState memory marketExt,
+        uint256 exactYtIn,
+        ApproxParams memory approxParams
+    ) internal pure returns (uint256 netPtOut, uint256 totalPtSwapped) {
+        (netPtOut, totalPtSwapped,) = marketExt.state.approxSwapExactYtForPt(
+            marketExt.index,
+            exactYtIn,
+            marketExt.blockTime,
+            approxParams
+        );
+
+        marketExt.state.swapSyForExactPt(marketExt.index, totalPtSwapped, marketExt.blockTime);
+    }
+
+    function previewPyToSy(
+        MarketExtState memory marketExt,
+        uint256 netPYToRedeem
+    ) internal pure returns (uint256) {
+        return marketExt.index.assetToSy(netPYToRedeem);
+    }
+
+    /// @notice Returns the trade exchange rate, fee excluded
+    function exchangeRate(MarketExtState memory marketExt) internal pure returns (uint256) {
+        MarketPreCompute memory comp = marketExt.state.getMarketPreCompute(
+            marketExt.index,
+            marketExt.blockTime
+        );
+
+        int256 preFeeExchangeRate = MarketMathCore._getExchangeRate(
+            marketExt.state.totalPt,
+            comp.totalAsset,
+            comp.rateScalar,
+            comp.rateAnchor,
+            0
+        );
+
+        return preFeeExchangeRate.Uint();
+    }
+
+    function impliedYield(MarketExtState memory marketExt) internal pure returns (uint256) {
+        return
+            exchangeRate(marketExt).pow(
+                ONE_YEAR.divDown(marketExt.state.expiry - marketExt.blockTime)
+            ) - Math.ONE;
+    }
+
+    function clone(MarketState memory state) internal pure returns (MarketState memory) {
+        return
+            MarketState(
+                state.totalPt,
+                state.totalSy,
+                state.totalLp,
+                state.treasury,
+                state.scalarRoot,
+                state.expiry,
+                state.lnFeeRateRoot,
+                state.reserveFeePercent,
+                state.lastLnImpliedRate
+            );
+    }
+
+    function clone(MarketExtState memory marketExt) internal pure returns (MarketExtState memory) {
+        return MarketExtState(clone(marketExt.state), marketExt.index, marketExt.blockTime);
+    }
+
+    function clone(ApproxParams memory params) internal pure returns (ApproxParams memory) {
+        return
+            ApproxParams(
+                params.guessMin,
+                params.guessMax,
+                params.guessOffchain,
+                params.maxIteration,
+                params.eps
+            );
+    }
+
+    function calcMaxPtIn(MarketExtState memory marketExt) internal pure returns (uint256) {
+        return
+            (MarketApproxPtInLib.calcMaxPtIn(
+                marketExt.state,
+                marketExt.state.getMarketPreCompute(marketExt.index, marketExt.blockTime)
+            ) * 9) / 10;
+    }
+
+    function calcMaxPtOut(MarketExtState memory marketExt) internal pure returns (uint256) {
+        return
+            MarketApproxPtOutLib.calcMaxPtOut(
+                marketExt.state.getMarketPreCompute(marketExt.index, marketExt.blockTime),
+                marketExt.state.totalPt
+            );
+    }
+}

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

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../../interfaces/TradingBot/IBotDecisionHelper.sol";
+import "../../libraries/math/Math.sol";
+
+library SpecSegmentLib {
+    using Math for uint256;
+    using Math for int256;
+
+    function getSegLength(TradingSpecs memory specs) internal pure returns (uint256) {
+        return (specs.sellYtIy - specs.buyYtIy) / (2 * specs.numOfBins);
+    }
+
+    function getMidIyOfSeg(
+        TradingSpecs memory specs,
+        uint256 segId
+    ) internal pure returns (uint256) {
+        assert(segId != 0 && segId != specs.numOfBins * 2);
+        uint256 length = getSegLength(specs);
+        return specs.buyYtIy + length * (segId - 1) + length / 2;
+    }
+
+    function getSegIdForIy(
+        TradingSpecs memory specs,
+        uint256 iy
+    ) internal pure returns (uint256) {
+        if (iy < specs.buyYtIy) {
+            return 0;
+        }
+        if (iy > specs.sellYtIy) {
+            return 2 * specs.numOfBins + 1;
+        }
+        return (iy - specs.buyYtIy) / getSegLength(specs) + 1;
+    }
+
+    function convertSegIdToBinId(
+        BotState memory botState,
+        uint256 segId
+    ) internal pure returns (int256) {
+        int256 binId = segId.Int() - botState.buyBins.Int();
+        if (binId >= 1) binId--;
+        return binId;
+    }
+
+    function convertBinIdToSegId(
+        BotState memory botState,
+        int256 binId
+    ) internal pure returns (uint256) {
+        assert(binId != 0);
+        if (binId >= 1) binId++;
+        return (binId + botState.buyBins.Int()).Uint();
+    }
+
+    function getBinIdForIy(
+        TradingSpecs memory specs,
+        BotState memory botState,
+        uint256 iy
+    ) internal pure returns (int256) {
+        return convertSegIdToBinId(botState, getSegIdForIy(specs, iy));
+    }
+}

package/contracts/core/libraries/Errors.sol

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

package/contracts/core/libraries/TokenAmountLib.sol

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

package/contracts/interfaces/TradingBot/IBotDecisionHelper.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./ITradingBotBase.sol";
+
+enum ActionType {
+    NONE,
+    AddLiqFromYt, // Sell YT for LP
+    RemoveLiqToYt, // Zap out to YT,
+    SwapPtForYt,
+    SwapYtForPt
+}
+
+interface IBotDecisionHelper {
+    enum RebalanceResult {
+        TARGET_NOT_REACHED,
+        SUCCESS,
+        FAIL_OR_TARGET_EXCEED
+    }
+
+    struct RebalanceDetails {
+        StrategyData strategyData;
+        ActionType action;
+        uint256 targetIy;
+    }
+
+    struct ActionToTakeResult {
+        ActionType action;
+        int currentBin;
+        uint256 targetIy;
+        uint256 guessBotParams;
+        uint256 guessIntParams;
+        uint256 amountOut;
+    }
+
+    function getCurrentBin(StrategyData memory strategyData) external view returns (int256);
+
+    function botExtStats(
+        StrategyData memory strategyData
+    )
+        external
+        view
+        returns (uint256 tvlInSy, uint256 iy, uint256 currentSyRatio, uint256 currentYtPtRatio);
+
+    function searchForBotParam(
+        StrategyData memory strategyData,
+        ActionType action,
+        uint256 targetIy,
+        uint256 rebalanceAdditionalCheck,
+        ApproxParams memory botParams,
+        ApproxParams memory intParams
+    ) external view returns (uint256);
+
+    function getFloatingSyAmount(address botAddress) external returns (uint256 floatingSyAmount);
+
+    function getActionDetails(address botAddress) external returns (ActionToTakeResult memory res);
+}

package/contracts/interfaces/TradingBot/ILongYieldDecisionHelper.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./IBotDecisionHelper.sol";
+
+interface ILongYieldDecisionHelper is IBotDecisionHelper {
+    function getAvailableZpiAmount(address botAddress) external returns (uint256 amountSyToZpi);
+}