@pendle/core-v2 2.18.0 → 2.19.0-tradingbot

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

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