@pendle/core-v2 2.19.1-tradingbot → 2.20.0-tradingbot

package/contracts/core/TradingBot/LongYield/LongYieldActionHelper.sol

@@ -1,101 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
-
-import "../base/TradingBotBase.sol";
-import "../base/BotActionCallback.sol";
-
-abstract contract LongYieldActionHelper 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 _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
-            );
-    }
-    
-    function _addLiqFromYt(
-        uint256 netPtFromSwap,
-        uint256 minLpOut
-    ) 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
-
-        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, uint256 totalPtToSwap) {
-        _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;
-        (netYtFromSwap, 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/ShortYield/ShortYieldActionHelper.sol

@@ -1,54 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
-
-import "../base/TradingBotBase.sol";
-
-abstract contract ShortYieldActionHelper is TradingBotBase {
-    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 _mintPY(
-        uint256 netSyIn,
-        uint256 minPyOut
-    ) internal returns (uint256 netPyOut) {
-        return IPAllAction(router).mintPyFromSy(
-            address(this),
-            YT,
-            netSyIn,
-            minPyOut
-        );
-    }
-
-    function _swapPtForYt(
-        uint256 netPtToSwap,
-        ApproxParams memory guessTotalPtToSwap,
-        uint256 minYtOut
-    ) internal returns (uint256 netYtOut) {
-        (netYtOut, ) = IPAllAction(router).swapExactPtForYt(
-            address(this),
-            market,
-            netPtToSwap,
-            minYtOut,
-            guessTotalPtToSwap
-        );
-    }
-
-    function _swapYtForPt(
-        uint256 netYtToSwap,
-        ApproxParams memory guessTotalYtToSwap,
-        uint256 minPtOut
-    ) internal returns (uint256 netPtOut) {
-        (netPtOut, ) = IPAllAction(router).swapExactYtForPt(
-            address(this),
-            market,
-            netYtToSwap,
-            minPtOut,
-            guessTotalYtToSwap
-        );
-    }
-}

package/contracts/core/TradingBot/ShortYield/ShortYieldDecisionHelper.sol

@@ -1,198 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.0;
-
-import "../libraries/BotSimulationLib.sol";
-import "../../libraries/Errors.sol";
-import "../libraries/SpecSegmentLib.sol";
-import "../base/BotDecisionHelperBase.sol";
-import "../../../interfaces/TradingBot/IShortYieldDecisionHelper.sol";
-import "../../../interfaces/TradingBot/IShortYieldTradingBot.sol";
-
-contract ShortYieldDecisionHelper is BotDecisionHelperBase, IShortYieldDecisionHelper {
-    using MarketExtLib for MarketExtState;
-    using MarketExtLib for ApproxParams;
-    using MarketMathCore for MarketState;
-    using MarketApproxPtInLib for MarketState;
-    using BotSimulationLib for BotState;
-    using PYIndexLib for PYIndex;
-    using Math for uint256;
-    using Math for int256;
-    using LogExpMath for uint256;
-    using SpecSegmentLib for TradingSpecs;
-
-    // We dont care about AddLiqKeepYt here
-    function getActionDetails(address botAddress) public returns (ActionToTakeResult memory res) {
-        StrategyData memory strategyData = IShortYieldTradingBot(botAddress).readStrategyData();
-        uint256 iy = strategyData.marketExt.impliedYield();
-
-        res.currentBin = _getCurrentBin(strategyData.botState, strategyData.specs, iy);
-        if (res.currentBin == 0) {
-            res.action = ActionType.NONE;
-            return res;
-        }
-        res.targetIy = _getTargetImpliedYieldForBin(
-            strategyData.botState,
-            strategyData.specs,
-            res.currentBin
-        );
-
-        uint256 maxAmountForAction = INF;
-
-        if (res.currentBin < 0) {
-            res.action = ActionType.SwapPtForYt;
-            uint256 maxPtToSwap = _searchMaxPtToSwap(strategyData);
-            maxAmountForAction = _calcMaxAmountForAction(
-                maxPtToSwap,
-                res.currentBin,
-                strategyData.botState.buyBins,
-                strategyData.specs.numOfBins
-            );
-        } else {
-            res.action = ActionType.SwapYtForPt;
-            maxAmountForAction = _calcMaxAmountForAction(
-                strategyData.botState.ytBalance,
-                res.currentBin,
-                strategyData.botState.buyBins,
-                strategyData.specs.numOfBins
-            );
-        }
-
-        if (maxAmountForAction == 0) {
-            return res;
-        }
-
-        res.guessBotParams = searchForBotParam(
-            strategyData,
-            res.action,
-            res.targetIy,
-            0,
-            _getMockApproxParamsWithGuessMax(maxAmountForAction),
-            _getMockApproxParams()
-        );
-        (res.amountOut, res.guessIntParams) = _calcAmountOutAndIntParams(
-            strategyData.marketExt,
-            res.action,
-            res.guessBotParams
-        );
-    }
-
-    /**
-     * Given the rebalancing action and its `botParam`, binary search for the optimal internal
-     * parameter `intParam` for the internal action's approximation (e.g. for router's swap)
-     */
-    function _calcAmountOutAndIntParams(
-        MarketExtState memory marketExt,
-        ActionType action,
-        uint256 botParam
-    ) public pure returns (uint256 amountOut, uint256 intParams) {
-        if (action == ActionType.SwapPtForYt) {
-            (amountOut, intParams) = marketExt.clone().swapPtToYt(
-                botParam,
-                _getMockApproxParams()
-            );
-        } else {
-            (amountOut, intParams) = marketExt.clone().swapYtToPt(
-                botParam,
-                _getMockApproxParams()
-            );
-        }
-    }
-
-    function _searchMaxPtToSwap(StrategyData memory strategyData) internal pure returns (uint256) {
-        (, , , uint256 ytPtRatio) = _calcBotExtStats(
-            strategyData.botState,
-            strategyData.marketExt
-        );
-        if (ytPtRatio > strategyData.specs.targetYtPtRatio) {
-            return 0;
-        }
-
-        ApproxParams memory guessParams = _getMockApproxParamsWithGuessMax(
-            strategyData.botState.ptBalance
-        );
-        ApproxParams memory mockSwapParams = _getMockApproxParams();
-        while (guessParams.guessMax > guessParams.guessMin + 1) {
-            uint256 guess = guessParams.guessMin +
-                (guessParams.guessMax - guessParams.guessMin) /
-                2;
-
-            (
-                bool success,
-                BotState memory botStateAfter,
-                MarketExtState memory marketExtAfter
-            ) = previewAction(strategyData, ActionType.SwapPtForYt, guess, mockSwapParams);
-
-            if (!success) {
-                guessParams.guessMax = guess - 1;
-                continue;
-            }
-
-            (, , , uint256 ytPtRatioAfter) = _calcBotExtStats(botStateAfter, marketExtAfter);
-            if (ytPtRatioAfter <= strategyData.specs.targetYtPtRatio) {
-                guessParams.guessMin = guess;
-            } else {
-                guessParams.guessMax = guess - 1;
-            }
-        }
-        return guessParams.guessMin;
-    }
-
-    /// @dev Does not modify params, structs are cloned before simulation
-    function previewAction(
-        StrategyData memory strategyData,
-        ActionType action,
-        uint256 botParam,
-        ApproxParams memory intParams
-    ) public pure returns (bool success, BotState memory bot, MarketExtState memory marketExt) {
-        bot = strategyData.botState.clone();
-        marketExt = strategyData.marketExt.clone();
-
-        if (action == ActionType.SwapPtForYt) {
-            success = bot.swapPtToYt(marketExt, botParam, intParams);
-        } else if (action == ActionType.SwapYtForPt) {
-            success = bot.swapYtToPt(marketExt, botParam, intParams);
-        } else {
-            success = false;
-        }
-    }
-
-    /// @dev Gives a weak upper bound so that MarketExtLib's simulation doesn't revert
-    function _weakUpperBound(
-        BotState memory bot,
-        MarketExtState memory,
-        ActionType action
-    ) internal pure override returns (uint256) {
-        if (action == ActionType.SwapPtForYt) {
-            return bot.ptBalance;
-        } else {
-            return bot.ytBalance;
-        }
-    }
-
-    function _rebalanceResult(
-        RebalanceDetails memory rebalance,
-        uint256 botParam,
-        uint256,
-        uint256 eps,
-        ApproxParams memory intParams
-    ) internal pure override returns (RebalanceResult) {
-        (bool success, , MarketExtState memory marketExt) = previewAction(
-            rebalance.strategyData,
-            rebalance.action,
-            botParam,
-            intParams
-        );
-
-        if (!success) return RebalanceResult.FAIL_OR_TARGET_EXCEED;
-
-        uint256 iy = marketExt.impliedYield();
-        if (rebalance.action == ActionType.SwapPtForYt) {
-            if (iy > rebalance.targetIy) return RebalanceResult.FAIL_OR_TARGET_EXCEED;
-        } else {
-            if (iy < rebalance.targetIy) return RebalanceResult.FAIL_OR_TARGET_EXCEED;
-        }
-
-        if (Math.isAApproxB(iy, rebalance.targetIy, eps)) return RebalanceResult.SUCCESS;
-        else return RebalanceResult.TARGET_NOT_REACHED;
-    }
-}

package/contracts/core/TradingBot/ShortYield/ShortYieldTradingBot.sol

@@ -1,101 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
-
-import "../base/TradingBotBase.sol";
-import "./ShortYieldActionHelper.sol";
-import "../../../interfaces/TradingBot/IShortYieldTradingBot.sol";
-import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
-
-contract ShortYieldTradingBot is
-    TradingBotBase,
-    ShortYieldActionHelper,
-    IShortYieldTradingBot,
-    UUPSUpgradeable
-{
-    using MarketExtLib for MarketExtState;
-    using Math for uint256;
-    using Math for int256;
-
-    constructor(
-        address _market,
-        address _router,
-        address _PENDLE,
-        address _decisionHelper
-    ) TradingBotBase(_market, _router, _PENDLE, _decisionHelper) {}
-
-    function _authorizeUpgrade(address) internal override onlyOwner {}
-
-    function initialize(TradingSpecs memory _specs) external initializer {
-        _setSpecs(_specs);
-        __BoringOwnable_init();
-    }
-
-    function mintPY(
-        uint256 netSyIn,
-        uint256 minPyOut
-    ) external onlyOwner returns (uint256 netPyOut) {
-        netPyOut = _mintPY(netSyIn, minPyOut);
-        emit MintPy(netSyIn, minPyOut);
-    }
-
-    function swapPtForYt(
-        SwapInput calldata inputParams
-    ) external onlyOwner returns (uint256 netYtOut) {
-        StrategyData memory strategyData = readStrategyData();
-
-        require(
-            IBotDecisionHelper(decisionHelper).getCurrentBin(strategyData) ==
-                inputParams.currentBin,
-            "removeLiqToYt: bin state expired"
-        );
-
-        uint256 netPtToSwap = decisionHelper.searchForBotParam(
-            strategyData,
-            ActionType.SwapPtForYt,
-            inputParams.targetIy,
-            type(uint256).max,
-            inputParams.botParams,
-            inputParams.guessTotalPtToSwap
-        );
-
-        netYtOut = _swapPtForYt(
-            netPtToSwap,
-            inputParams.guessTotalPtToSwap,
-            inputParams.minAmountOut
-        );
-
-        _updateSellBinAfterTrade();
-
-        emit SwapPtForYt(inputParams, netYtOut);
-    }
-
-    function swapYtForPt(
-        SwapInput calldata inputParams
-    ) external onlyOwner returns (uint256 netPtOut) {
-        StrategyData memory strategyData = readStrategyData();
-
-        require(
-            IBotDecisionHelper(decisionHelper).getCurrentBin(strategyData) ==
-                inputParams.currentBin,
-            "removeLiqToYt: bin state expired"
-        );
-
-        uint256 netYtToSwap = decisionHelper.searchForBotParam(
-            strategyData,
-            ActionType.SwapYtForPt,
-            inputParams.targetIy,
-            type(uint256).max,
-            inputParams.botParams,
-            inputParams.guessTotalPtToSwap
-        );
-
-        netPtOut = _swapYtForPt(
-            netYtToSwap,
-            inputParams.guessTotalPtToSwap,
-            inputParams.minAmountOut
-        );
-
-        _updateSellBinAfterTrade();
-        emit SwapYtForPt(inputParams, netPtOut);
-    }
-}

package/contracts/core/TradingBot/base/BotActionCallback.sol

@@ -1,112 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
-
-import "../../../interfaces/IPMarketSwapCallback.sol";
-import "../../../interfaces/TradingBot/IBotDecisionHelper.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)
-        }
-    }
-}