@pendle/core-v2 2.15.2 → 2.17.0-tradingbot

package/contracts/core/TradingBot/LongYieldTradingBot.sol

@@ -0,0 +1,148 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./TradingBotBase.sol";
+import "./BotActionHelper.sol";
+import "./BotDecisionLib.sol";
+import "../../interfaces/TradingBot/ILongYieldTradingBot.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+
+contract LongYieldTradingBot is
+    TradingBotBase,
+    BotActionHelper,
+    ILongYieldTradingBot,
+    UUPSUpgradeable
+{
+    LongTradingSpecs public specs;
+
+    constructor(
+        address _market,
+        address _PENDLE,
+        LongTradingSpecs memory _specs
+    ) TradingBotBase(_market, _PENDLE) {
+        specs = _specs;
+    }
+
+    function _authorizeUpgrade(address) internal override onlyOwner {}
+
+    function initialize() external initializer {
+        __BoringOwnable_init();
+    }
+
+    function setSpecs(LongTradingSpecs calldata _specs) external onlyOwner {
+        specs = _specs;
+    }
+
+    function swapSyToYt(
+        address router,
+        StrategyState memory oldState,
+        ApproxParams calldata botParams,
+        uint256 minYtOut,
+        uint256 maxSyIn
+    ) external onlyOwner returns (uint256 exactYtOut, uint256 netSyIn) {
+        exactYtOut = BotDecisionLib.binarySearchUntilSwitchState(
+            readBotState(),
+            readMarketExtState(router),
+            specs,
+            ActionType.SwapSyToYt,
+            oldState,
+            botParams,
+            botParams // only placeholder, value doesn't matter
+        );
+
+        if (exactYtOut < minYtOut) revert Errors.BotInsufficientYtOut(exactYtOut, minYtOut);
+        netSyIn = _swapSyToYt(router, exactYtOut, maxSyIn);
+
+        emit SwapSyToYt(oldState, botParams, maxSyIn, exactYtOut, netSyIn);
+    }
+
+    function addLiqKeepYt(
+        address router,
+        StrategyState memory oldState,
+        ApproxParams calldata botParams,
+        uint256 maxSyIn,
+        uint256 minLpOut,
+        uint256 minYtOut
+    ) external onlyOwner returns (uint256 netSyIn, uint256 netLpOut, uint256 netYtOut) {
+        netSyIn = BotDecisionLib.binarySearchUntilSwitchState(
+            readBotState(),
+            readMarketExtState(router),
+            specs,
+            ActionType.AddLiqKeepYt,
+            oldState,
+            botParams,
+            botParams // only placeholder, value doesn't matter
+        );
+
+        if (netSyIn > maxSyIn) revert Errors.BotExceededLimitSyIn(netSyIn, maxSyIn);
+        (netLpOut, netYtOut) = _addLiqKeepYt(router, netSyIn, minLpOut, minYtOut);
+
+        emit AddLiqKeepYt(oldState, botParams, maxSyIn, netSyIn, netLpOut, netYtOut);
+    }
+
+    function addLiqFromSy(
+        StrategyState memory oldState,
+        ApproxParams calldata botParams,
+        uint256 minLpOut,
+        uint256 maxSyIn
+    ) external onlyOwner returns (uint256 netLpOut, uint256 netSyIn) {
+        uint256 netPtFromSwap = BotDecisionLib.binarySearchUntilSwitchState(
+            readBotState(),
+            readMarketExtState(address(this)),
+            specs,
+            ActionType.AddLiqFromSy,
+            oldState,
+            botParams,
+            botParams // only placeholder, value doesn't matter
+        );
+
+        (netLpOut, netSyIn) = _addLiqFromSy(netPtFromSwap, minLpOut, maxSyIn);
+
+        emit AddLiqFromSy(oldState, botParams, maxSyIn, netSyIn, netLpOut);
+    }
+
+    function addLiqFromYt(
+        StrategyState memory oldState,
+        ApproxParams calldata botParams,
+        uint256 minLpOut,
+        uint256 maxYtIn
+    ) external onlyOwner returns (uint256 netLpOut, uint256 netYtIn) {
+        uint256 netPtFromSwap = BotDecisionLib.binarySearchUntilSwitchState(
+            readBotState(),
+            readMarketExtState(address(this)),
+            specs,
+            ActionType.AddLiqFromYt,
+            oldState,
+            botParams,
+            botParams // only placeholder, value doesn't matter
+        );
+        (netLpOut, netYtIn) = _addLiqFromYt(netPtFromSwap, minLpOut, maxYtIn);
+
+        emit AddLiqFromYt(oldState, botParams, maxYtIn, netYtIn, netLpOut);
+    }
+
+    function removeLiqToYt(
+        StrategyState memory oldState,
+        ApproxParams calldata botParams,
+        ApproxParams calldata guessTotalPtToSwap,
+        uint256 maxLpRemoved,
+        uint256 minYtOut
+    ) external onlyOwner returns (uint256 netLpRemoved, uint256 netYtOut) {
+        netLpRemoved = BotDecisionLib.binarySearchUntilSwitchState(
+            readBotState(),
+            readMarketExtState(address(this)),
+            specs,
+            ActionType.RemoveLiqToYt,
+            oldState,
+            botParams,
+            guessTotalPtToSwap // value DOES matter
+        );
+
+        if (netLpRemoved > maxLpRemoved)
+            revert Errors.BotExceededLimitLpToRemove(netLpRemoved, maxLpRemoved);
+
+        netYtOut = _removeLiqToYt(netLpRemoved, guessTotalPtToSwap, minYtOut);
+
+        emit RemoveLiqToYt(oldState, botParams, maxLpRemoved, netLpRemoved, netYtOut);
+    }
+}

package/contracts/core/TradingBot/MarketExtLib.sol

@@ -0,0 +1,246 @@
+// 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 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, , ) = marketExt.state.addLiquidity(
+            netSyIn - netSyToPt,
+            netYtOut,
+            marketExt.blockTime
+        );
+    }
+
+    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, , ) = marketExt.state.addLiquidity(
+            netSyToAdd,
+            netPtFromSwap,
+            marketExt.blockTime
+        );
+        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, , ) = marketExt.state.addLiquidity(
+            netSyToAdd,
+            netPtToAdd,
+            marketExt.blockTime
+        );
+    }
+
+    /// @dev Simulates PendleRouter's removeLiquidityDualSyAndPt then swapExactPtForYt
+    function removeLiqToYt(
+        MarketExtState memory marketExt,
+        uint256 netLpToRemove,
+        ApproxParams memory approxParams
+    ) internal pure returns (uint256 /*netYtOut*/) {
+        (uint256 netSyRemoved, uint256 netPtRemoved) = marketExt.state.removeLiquidity(
+            netLpToRemove
+        );
+
+        uint256 netYtFromSy = marketExt.index.syToAsset(netSyRemoved);
+        uint256 netPtToSwap = netPtRemoved + netYtFromSy;
+
+        (uint256 netYtFromSwap, uint256 totalPtToSwap, ) = marketExt.state.approxSwapExactPtForYt(
+            marketExt.index,
+            netPtToSwap,
+            marketExt.blockTime,
+            clone(approxParams)
+        );
+
+        marketExt.state.swapExactPtForSy(marketExt.index, totalPtToSwap, marketExt.blockTime);
+
+        return netYtFromSy + netYtFromSwap;
+    }
+
+    function previewPyToSy(
+        MarketExtState memory marketExt,
+        uint256 netPYToRedeem
+    ) internal pure returns (uint256) {
+        return marketExt.index.assetToSy(netPYToRedeem);
+    }
+
+    function previewAssetsFromLp(
+        MarketExtState memory marketExt,
+        uint256 lpBalance
+    ) internal pure returns (uint256 syInLp, uint256 ptInLp) {
+        syInLp = (lpBalance * marketExt.state.totalSy.Uint()) / marketExt.state.totalLp.Uint();
+        ptInLp = (lpBalance * marketExt.state.totalPt.Uint()) / marketExt.state.totalLp.Uint();
+    }
+
+    /// @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/README.md

@@ -0,0 +1,151 @@
+# Trading Bot
+
+## Structs and enums
+
+### MarketExtLib
+
+Struct for external market state.
+
+- `state`: MarketState
+- `index`: YT's index
+- `blockTime`: timestamp
+
+### BotState
+
+Struct for bot's balances: `lpBalance`, `ytBalance`, `syBalance`.
+
+### LongTradingSpecs
+
+Struct for bot's trading limits:
+
+- `lowerIyLimit`: apeYtApy
+- `upperIyLimit`: sellYtApy
+- `floatingSyRatioLimit`: f/TVL limit, TVL calculated in number of SY.
+- `ytPtRatioLimit`: limit for YT/PT
+
+### ActionType
+
+Enum for action.
+
+- 0: SwapSyToYt - Buy YT with SY
+- 1: AddLiqKeepYt - ZPI Zap
+- 2: AddLiqFromSy - Single sided LP
+- 3: AddLiqFromYt - Sell YT for LP
+- 4: RemoveLiqToYt - Zap out to YT
+- 5: NONE
+
+### StrategyFlag
+
+Enum for strategy state.
+
+- 0: GOOD
+- 1: TOO_LOW
+- 2: TOO_HIGH
+
+### StrategyState
+
+Struct for strategy state.
+
+- `iyFlag`: StrategyFlag for IY compared to ape/sellYtApy
+- `syRatioFlag`: StrategyFlag for f/TVL compared to given limit \(r\)
+
+## TradingBotBase.sol
+
+### 1. depositSy
+
+Deposit SY into the bot.
+- SY approval needed.
+
+### 2. depositToken
+
+Deposit funds into the bot, which are then compounded into SY.
+- `inp`: Token input data to swap deposited token to SY. 
+- If `inp.netTokenIn` is set to `2**256 - 1` then it will be set to `_selfBalance()` internally.`
+- Needs sender's approval to bot & bot's approval to router.
+
+### 3. withdrawFunds
+
+Withdraw funds back to sender (only owner).
+
+### 4. approveInf
+
+Infinite approve token to spender.
+
+### 5. claimAndCompound
+
+Claim rewards from SY, YT, market. Then compound the rewards into SY.
+
+- `inps`: Token input data to swap claimed rewards into SY
+- If `inp.netTokenIn` is set to `2**256 - 1` then it will be set to `_selfBalance()` internally.
+- Needs sender's approval to bot & bot's approval to router for tokens.
+
+### 6. readMarketExtState
+Return the current `MarketExtState`: state of market, YT's index, current block timestamp.
+
+### 7. readBotState
+Return the current `BotState`: The bot's balance in LP, SY, YT.
+
+
+## LongYieldTradingBot.sol
+
+There are 5 functions for rebalancing actions.
+- For all of them, `botParams` is ApproxParams to find the optimal internal trade parameter.
+- For functions interacting with the router, approval is needed.
+
+### 1. setSpecs
+
+Set the bot's specs: apeYtApy, sellYtApy, r (f/TVL limit), x (YT/PT ratio).
+
+### 2. swapSyToYt
+
+Rebalance by buying YT with SY. 
+
+### 3. addLiqKeepYt
+
+Rebalance by ZPI zap. 
+
+### 4. addLiqFromSy
+
+Rebalance by adding single sided LP from SY.
+
+### 5. addLiqFromYt
+
+Rebalance by selling YT to LP. 
+
+### 6. removeLiqToYt
+
+Rebalance by zapping out LP to YT.
+
+- `intParams`: ApproxParams for internal approx function (approxSwapExactPtForYt).
+- Zapping LP to YT can lose a few percent of trading value. Zapping out too much can cause a significant change in TVL, so the resulting strategy state can differ from expected, which can cause unintended behaviour.
+
+## TradingBotOffchain.sol
+
+Offchain helper for trading bot.
+
+### 1. claimForBot
+Claim rewards for bot, return the list of reward tokens and amounts claimed.
+
+### 2. simulateAction
+Simulate rebalancing action (swap/add/remove) from BotState and MarketExtState.
+
+### 3. searchForBotParam
+Binary search for the optimal `botParam` for the rebalancing action. Simulate the same process used in the bot's rebalancing functions.
+
+- Searches for the minimum `botParam` so that the bot trades just until the bot's new strategy state would differ from `initialState`.
+- `botParam`: The parameter for the rebalancing function (e.g. `netPtFromSwap` for addLiqFromSy).
+
+### 4. searchForIntParam
+(Only useful for `removeLiqToYt`). 
+Given the `botParam`, binary search for the optimal `intParam` for the internal calculations (for `approxSwapExactPtForYt`).
+
+### 5. strategyState
+Calculate the strategy state from BotState, MarketExtState, LongTradingSpecs.
+
+### 6. actionToTake
+Return optimal action to take based on the strategy state.
+
+### 7. tvlInSy
+
+Calculate the TVL in equivalent SY amount.
+

package/contracts/core/TradingBot/TradingBotBase.sol

@@ -0,0 +1,120 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../libraries/BoringOwnableUpgradeable.sol";
+import "../libraries/TokenHelper.sol";
+import "../../interfaces/IPAllAction.sol";
+import "../../interfaces/TradingBot/ITradingBotBase.sol";
+
+import "./BotSimulationLib.sol";
+
+abstract contract TradingBotBase is BoringOwnableUpgradeable, TokenHelper, ITradingBotBase {
+    using PYIndexLib for IPYieldToken;
+
+    address public immutable market;
+    address public immutable SY;
+    address public immutable PT;
+    address public immutable YT;
+    address public immutable PENDLE;
+
+    constructor(address _market, address _PENDLE) initializer {
+        (IStandardizedYield _SY, IPPrincipalToken _PT, IPYieldToken _YT) = IPMarket(_market)
+            .readTokens();
+
+        market = _market;
+        SY = address(_SY);
+        PT = address(_PT);
+        YT = address(_YT);
+        PENDLE = _PENDLE;
+
+        __BoringOwnable_init();
+    }
+
+    function depositSy(uint256 netSyIn) external onlyOwner {
+        _transferIn(SY, msg.sender, netSyIn);
+        emit DepositSy(netSyIn);
+    }
+
+    /// @dev Receives token and compound to SY
+    function depositToken(
+        address router,
+        TokenInput calldata inp,
+        uint256 minSyOut
+    ) external payable onlyOwner {
+        _transferIn(inp.tokenIn, msg.sender, inp.netTokenIn);
+        _compoundSingle(router, 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 approveInf(address token, address spender) external onlyOwner {
+        _safeApproveInf(token, spender);
+    }
+
+    function claimAndCompound(
+        address router,
+        TokenInput[] calldata inps,
+        uint256 minSyOut
+    ) external onlyOwner returns (uint256 netSyOut, uint256 netPendleOut) {
+        _claimRewards();
+
+        netSyOut = _compound(router, inps, minSyOut);
+
+        netPendleOut = _selfBalance(PENDLE);
+        _transferOut(PENDLE, owner, netPendleOut);
+        emit ClaimAndCompound(netSyOut, netPendleOut);
+    }
+
+    function readMarketExtState(address router) 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);
+    }
+
+    receive() external payable {}
+
+    function _claimRewards() internal {
+        IPYieldToken(YT).redeemDueInterestAndRewards(address(this), true, true);
+        IStandardizedYield(SY).claimRewards(address(this));
+        IPMarket(market).redeemRewards(address(this));
+    }
+
+    function _compound(
+        address router,
+        TokenInput[] calldata inps,
+        uint256 minSyOut
+    ) internal returns (uint256 netSyOut) {
+        netSyOut = 0;
+
+        for (uint256 i = 0; i < inps.length; ++i) {
+            netSyOut += _compoundSingle(router, inps[i], 0);
+        }
+
+        if (netSyOut < minSyOut) revert Errors.BotInsufficientSyOut(netSyOut, minSyOut);
+        return netSyOut;
+    }
+
+    function _compoundSingle(
+        address router,
+        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);
+    }
+}