@pendle/core-v2 2.18.1 → 2.19.0-tradingbot

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

@@ -0,0 +1,198 @@
+// 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

@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../base/TradingBotBase.sol";
+import "../base/BotActionHelper.sol";
+import "../../../interfaces/TradingBot/IShortYieldTradingBot.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+
+contract ShortYieldTradingBot is
+    TradingBotBase,
+    BotActionHelper,
+    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

@@ -0,0 +1,112 @@
+// 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)
+        }
+    }
+}

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

@@ -0,0 +1,178 @@
+// 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 _mintPY(
+        uint256 netSyIn,
+        uint256 minPyOut
+    ) internal returns (uint256 netPyOut) {
+        return IPAllAction(router).mintPyFromSy(
+            address(this),
+            YT,
+            netSyIn,
+            minPyOut
+        );
+    }
+
+    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
+    ) 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
+    }
+
+    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
+        );
+    }
+}