@pendle/core-v2 2.18.1 → 2.19.0-tradingbot

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

@@ -0,0 +1,235 @@
+// 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 "../../../interfaces/TradingBot/IBotDecisionHelper.sol";
+import "../../../interfaces/TradingBot/ITradingBotBase.sol";
+
+abstract contract BotDecisionHelperBase is IBotDecisionHelper {
+    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;
+
+    uint256 public constant MINIMAL_EPS = 100000000000000;
+    uint256 public constant INF = type(uint256).max;
+
+    function getFloatingSyAmount(address botAddress) public returns (uint256 floatingSyAmount) {
+        StrategyData memory strategyData = ITradingBotBase(botAddress).readStrategyData();
+        (uint256 tvlInSy, , uint256 syRatio, ) = _calcBotExtStats(
+            strategyData.botState,
+            strategyData.marketExt
+        );
+        if (syRatio < strategyData.specs.maxSyRatio) return 0;
+
+        return strategyData.botState.syBalance - tvlInSy.mulDown(strategyData.specs.targetSyRatio);
+    }
+
+    function botExtStats(
+        StrategyData memory strategyData
+    )
+        external
+        pure
+        returns (uint256 tvlInSy, uint256 iy, uint256 currentSyRatio, uint256 currentYtPtRatio)
+    {
+        return _calcBotExtStats(strategyData.botState, strategyData.marketExt);
+    }
+
+    /**
+     * Return the current bin corresponds to market state
+     *
+     * Negative value -> buy bin, b_abs(currentBin)
+     * Positive value -> sell bin, s_abs(currentBin)
+     * Zero -> Do nothing
+     */
+    function getCurrentBin(StrategyData memory strategyData) public pure returns (int256) {
+        return
+            _getCurrentBin(
+                strategyData.botState,
+                strategyData.specs,
+                strategyData.marketExt.impliedYield()
+            );
+    }
+
+    /**
+     * Binary search for the smallest parameter `botParam` for the corresponding rebalancing action
+     * such that the bot reaches desired target, otherwise give the largest `botParam` possible
+     * that action doesn't revert.
+     *
+     * @param action Action to take, from which target is derived
+     * @param botParams ApproxParams for `botParam`
+     * @param intParams ApproxParams for internal action's approximation (e.g. for router's swap)
+     *
+     * For `botParams`, eps = the precision such that slightly lower
+     * (param = (return value) * (1 - eps)) does not reach target
+     *
+     * - Returns `botParams.guessOffchain` if it reaches target, and slightly lower does not
+     * - Reverts if `botParams.guessMin` is invalid, or returns `botParams.guessMin` if reaches
+     * target
+     * - Returns `botParams.guessMax` if it is valid & does not reach target
+     * - Otherwise, binary search for `guess` such that it reaches target, and slightly lower does
+     * not
+     *
+     */
+    function searchForBotParam(
+        StrategyData memory strategyData,
+        ActionType action,
+        uint256 targetIy,
+        uint256 rebalanceAdditionalCheck,
+        ApproxParams memory botParams,
+        ApproxParams memory intParams
+    ) public pure returns (uint256) {
+        RebalanceDetails memory rebalance = RebalanceDetails(strategyData, action, targetIy);
+        if (botParams.guessOffchain != 0) {
+            // guessoffchain is good
+            if (
+                _rebalanceResult(
+                    rebalance,
+                    botParams.guessOffchain,
+                    rebalanceAdditionalCheck,
+                    botParams.eps,
+                    intParams
+                ) == RebalanceResult.SUCCESS
+            ) return botParams.guessOffchain;
+        }
+
+        {
+            // invalid range
+            uint256 guessUpperBound = _weakUpperBound(
+                strategyData.botState,
+                strategyData.marketExt,
+                action
+            );
+            if (botParams.guessMax > guessUpperBound) botParams.guessMax = guessUpperBound;
+            if (botParams.guessMin > botParams.guessMax)
+                revert Errors.BotBinarySearchInvalidRange(
+                    uint256(action),
+                    botParams.guessMin,
+                    botParams.guessMax
+                );
+        }
+
+        {
+            // if botParams.guessMax is either success or unsatisfied (target_not_reached), then we'll just go with it
+            if (
+                _rebalanceResult(
+                    rebalance,
+                    botParams.guessMax,
+                    rebalanceAdditionalCheck,
+                    botParams.eps,
+                    intParams
+                ) != RebalanceResult.FAIL_OR_TARGET_EXCEED
+            ) {
+                return botParams.guessMax;
+            }
+        }
+
+        for (uint256 iter = 0; iter < botParams.maxIteration; ++iter) {
+            uint256 guess = botParams.guessMin + (botParams.guessMax - botParams.guessMin) / 2;
+
+            RebalanceResult res = _rebalanceResult(
+                rebalance,
+                guess,
+                rebalanceAdditionalCheck,
+                botParams.eps,
+                intParams
+            );
+
+            if (res == RebalanceResult.SUCCESS) {
+                return guess;
+            } else if (res == RebalanceResult.TARGET_NOT_REACHED) {
+                botParams.guessMin = guess;
+            } else {
+                botParams.guessMax = guess;
+            }
+        }
+
+        revert Errors.BotBinarySearchFail();
+    }
+
+    function _calcBotExtStats(
+        BotState memory botState,
+        MarketExtState memory marketExt
+    )
+        internal
+        pure
+        returns (uint256 tvlInSy, uint256 iy, uint256 currentSyRatio, uint256 currentYtPtRatio)
+    {
+        tvlInSy = botState.tvlInSy(marketExt);
+        iy = marketExt.impliedYield();
+        currentSyRatio = botState.syBalance.divDown(tvlInSy);
+        (, uint256 ptInLp) = marketExt.clone().removeLiqDual(botState.lpBalance);
+
+        uint256 totalPt = ptInLp + botState.ptBalance;
+        currentYtPtRatio = (totalPt == 0 ? type(uint256).max : botState.ytBalance.divDown(totalPt));
+    }
+
+    function _getMockApproxParamsWithGuessMax(
+        uint256 guessMax
+    ) internal pure returns (ApproxParams memory) {
+        return ApproxParams(1, guessMax, 0, 256, MINIMAL_EPS);
+    }
+
+    function _getMockApproxParams() internal pure returns (ApproxParams memory) {
+        return ApproxParams(1, INF, 0, 256, MINIMAL_EPS);
+    }
+
+    function _getCurrentBin(
+        BotState memory botState,
+        TradingSpecs memory specs,
+        uint256 iy
+    ) internal pure returns (int256) {
+        return specs.getBinIdForIy(botState, iy);
+    }
+
+    function _getTargetImpliedYieldForBin(
+        BotState memory botState,
+        TradingSpecs memory specs,
+        int256 binId
+    ) internal pure returns (uint256) {
+        assert(binId != 0); // No action should be taken
+
+        uint256 segId = SpecSegmentLib.convertBinIdToSegId(botState, binId);
+
+        if (binId < 0) {
+            return specs.getMidIyOfSeg(segId + 1);
+        } else {
+            return specs.getMidIyOfSeg(segId - 1);
+        }
+    }
+
+    function _weakUpperBound(
+        BotState memory bot,
+        MarketExtState memory marketExt,
+        ActionType action
+    ) internal pure virtual returns (uint256);
+
+    function _rebalanceResult(
+        RebalanceDetails memory rebalance,
+        uint256 botParam,
+        uint256 rebalanceAdditionalCheck,
+        uint256 eps,
+        ApproxParams memory intParams
+    ) internal pure virtual returns (RebalanceResult);
+
+    function _calcMaxAmountForAction(
+        uint256 amount,
+        int256 currentBin,
+        uint256 buyBins,
+        uint256 numOfBins
+    ) internal pure returns (uint256) {
+        assert(currentBin != 0);
+        uint256 pressureDenom = currentBin < 0 ? buyBins : numOfBins * 2 - buyBins;
+        uint256 actionPressure = (currentBin.abs() * Math.ONE) / pressureDenom;
+        uint256 proportion = (Math.ONE + actionPressure).pow(actionPressure) - Math.ONE;
+        return amount.mulDown(proportion);
+    }
+}

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

@@ -0,0 +1,184 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../libraries/BoringOwnableUpgradeable.sol";
+import "../../libraries/TokenHelper.sol";
+import "../../../interfaces/TradingBot/ITradingBotBase.sol";
+import "../libraries/BotSimulationLib.sol";
+
+abstract contract TradingBotBase is BoringOwnableUpgradeable, TokenHelper, ITradingBotBase {
+    using TokenAmountLib for TokenAmount[];
+    using PYIndexLib for IPYieldToken;
+    using MarketExtLib for MarketExtState;
+    using Math for uint256;
+    using Math for int256;
+
+    IBotDecisionHelper public immutable decisionHelper;
+    address public immutable market;
+    address public immutable router;
+    address public immutable SY;
+    address public immutable PT;
+    address public immutable YT;
+    address public immutable PENDLE;
+
+    TradingSpecs public specs;
+    uint256 public buyBins;
+
+    constructor(
+        address _market,
+        address _router,
+        address _PENDLE,
+        address _decisionHelper
+    ) initializer {
+        (IStandardizedYield _SY, IPPrincipalToken _PT, IPYieldToken _YT) = IPMarket(_market)
+            .readTokens();
+
+        market = _market;
+        router = _router;
+        SY = address(_SY);
+        PT = address(_PT);
+        YT = address(_YT);
+        PENDLE = _PENDLE;
+        decisionHelper = IBotDecisionHelper(_decisionHelper);
+
+        __BoringOwnable_init();
+    }
+
+    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++;
+            }
+        }
+    }
+
+    function depositSy(uint256 netSyIn) external onlyOwner {
+        _transferIn(SY, msg.sender, netSyIn);
+        emit DepositSy(netSyIn);
+    }
+
+    /// @dev Receives token and compound to SY
+    function depositToken(TokenInput calldata inp, uint256 minSyOut) external payable onlyOwner {
+        _transferIn(inp.tokenIn, msg.sender, inp.netTokenIn);
+        _compoundSingle(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(
+        TokenInput[] calldata inps,
+        uint256 minSyOut
+    ) external onlyOwner returns (uint256 netSyOut, uint256 netPendleOut) {
+        _claimRewards();
+
+        netSyOut = _compound(inps, minSyOut);
+
+        netPendleOut = _selfBalance(PENDLE);
+        _transferOut(PENDLE, owner, netPendleOut);
+        emit ClaimAndCompound(netSyOut, netPendleOut);
+    }
+
+    /// Claim without compound, intended for offchain usage
+    /// @dev SY interest from YT is excluded
+    function claimWithoutCompound() external onlyOwner returns (TokenAmount[] memory rewards) {
+        address[] memory ytRewardTokens = IPYieldToken(YT).getRewardTokens();
+        (, uint256[] memory ytRewardAmounts) = IPYieldToken(YT).redeemDueInterestAndRewards(
+            address(this),
+            true,
+            true
+        );
+        rewards = rewards.add(ytRewardTokens, ytRewardAmounts);
+
+        address[] memory syRewardTokens = IStandardizedYield(SY).getRewardTokens();
+        uint256[] memory syRewardAmounts = IStandardizedYield(SY).claimRewards(address(this));
+        rewards = rewards.add(syRewardTokens, syRewardAmounts);
+
+        address[] memory lpRewardTokens = IPMarket(market).getRewardTokens();
+        uint256[] memory lpRewardAmounts = IPMarket(market).redeemRewards(address(this));
+        rewards = rewards.add(lpRewardTokens, lpRewardAmounts);
+    }
+
+    function readMarketExtState() 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);
+        botState.ptBalance = _selfBalance(PT);
+        botState.buyBins = buyBins;
+    }
+
+    receive() external payable {}
+
+    function _setBuyBins(uint256 _buyBins) internal {
+        buyBins = _buyBins;
+    }
+
+    function _claimRewards() internal {
+        IPYieldToken(YT).redeemDueInterestAndRewards(address(this), true, true);
+        IStandardizedYield(SY).claimRewards(address(this));
+        IPMarket(market).redeemRewards(address(this));
+    }
+
+    function _compound(
+        TokenInput[] calldata inps,
+        uint256 minSyOut
+    ) internal returns (uint256 netSyOut) {
+        netSyOut = 0;
+
+        for (uint256 i = 0; i < inps.length; ++i) {
+            netSyOut += _compoundSingle(inps[i], 0);
+        }
+
+        if (netSyOut < minSyOut) revert Errors.BotInsufficientSyOut(netSyOut, minSyOut);
+        return netSyOut;
+    }
+
+    function _compoundSingle(
+        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 setSpecs(TradingSpecs calldata _specs) external onlyOwner {
+        _setSpecs(_specs);
+    }
+
+    function _setSpecs(TradingSpecs memory _specs) internal {
+        specs = _specs;
+        _setBuyBins(specs.numOfBins);
+    }
+
+    function readStrategyData() public returns (StrategyData memory strategyData) {
+        strategyData.botState = readBotState();
+        strategyData.marketExt = readMarketExtState();
+        strategyData.specs = specs;
+    }
+
+    function _updateSellBinAfterTrade() internal {
+        int256 binShift = IBotDecisionHelper(decisionHelper).getCurrentBin(readStrategyData());
+        _setBuyBins((buyBins.Int() + binShift).Uint());
+    }
+}

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