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

package/contracts/core/TradingBot/libraries/LongYieldActionLib.sol

@@ -0,0 +1,279 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+// import "../base/TradingBotBase.sol";
+import "../../../router/base/MarketApproxLib.sol";
+import "../../../interfaces/IPAllAction.sol";
+import "../../../interfaces/IPMarket.sol";
+import "../../../interfaces/TradingBot/IBotDecisionHelper.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+library LongYieldActionLib {
+    using PYIndexLib for IPYieldToken;
+    using PYIndexLib for PYIndex;
+    using MarketMathCore for MarketState;
+    using MarketApproxPtInLib for MarketState;
+    using Math for int256;
+    using SafeERC20 for IERC20;
+
+    bytes internal constant EMPTY_BYTES = abi.encode();
+
+    address internal constant ROUTER = 0x0000000001E4ef00d069e71d6bA041b0A16F7eA0;
+
+    function removeLiquidityToSy(
+        address market,
+        uint256 netLpToRemove,
+        uint256 minSyOut
+    ) public returns (uint256 netSyOut) {
+        (uint256 netSyFromLp, uint256 netPtOut) = IPAllAction(ROUTER).removeLiquidityDualSyAndPt(
+            address(this),
+            market,
+            netLpToRemove,
+            0,
+            0
+        );
+
+        (, , IPYieldToken YT) = IPMarket(market).readTokens();
+        uint256 netSyFromRedeemPY = IPAllAction(ROUTER).redeemPyToSy(
+            address(this),
+            address(YT),
+            Math.min(netPtOut, YT.balanceOf(address(this))),
+            0
+        );
+
+        netSyOut = netSyFromLp + netSyFromRedeemPY;
+        require(netSyOut > minSyOut, "removeLiquidityToSy: insufficient sy out");
+    }
+
+    function swapYtToSy(
+        address market,
+        uint256 netYtIn,
+        uint256 minSyOut
+    ) public returns (uint256 netSyOut) {
+        (netSyOut, ) = IPAllAction(ROUTER).swapExactYtForSy(
+            address(this),
+            market,
+            netYtIn,
+            minSyOut
+        );
+    }
+
+    function addLiqKeepYt(
+        address market,
+        uint256 netSyIn,
+        uint256 minLpOut,
+        uint256 minYtOut
+    ) public returns (uint256 /*netLpOut*/, uint256 /*netYtOut*/) {
+        return
+            IPAllAction(ROUTER).addLiquiditySingleSyKeepYt(
+                address(this),
+                market,
+                netSyIn,
+                minLpOut,
+                minYtOut
+            );
+    }
+
+    function addLiqFromYt(
+        address market,
+        uint256 netPtFromSwap,
+        uint256 minLpOut
+    ) public returns (uint256 netLpOut, uint256 netYtIn) {
+        MarketState memory state = IPMarket(market).readState(address(this));
+        (, , IPYieldToken YT) = IPMarket(market).readTokens();
+
+        PYIndex index = 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(
+        address market,
+        uint256 netLpToRemove,
+        ApproxParams memory guessTotalPtToSwap,
+        uint256 minYtOut
+    ) public returns (uint256 netYtOut, uint256 totalPtToSwap) {
+        IERC20(market).safeTransfer(market, netLpToRemove);
+        (, , IPYieldToken YT) = IPMarket(market).readTokens();
+        (uint256 netSyFromLp, uint256 netPtFromLp) = IPMarket(market).burn(
+            address(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(
+            address(YT),
+            totalPtToSwap,
+            _encodeRemoveLiqToYt(minYtOut)
+        ); // SY goes to YT to mint PY
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               Callback
+    //////////////////////////////////////////////////////////////*/
+
+    function swapCallback(
+        address market,
+        int256 ptToAccount,
+        int256 syToAccount,
+        bytes calldata data
+    ) public {
+        TradeActionType swapType = _getActionType(data);
+
+        (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
+
+        if (swapType == TradeActionType.AddLiqFromYt) {
+            _callbackAddLiqFromYt(
+                market,
+                address(PT),
+                address(YT),
+                ptToAccount,
+                syToAccount,
+                data
+            );
+        } else if (swapType == TradeActionType.RemoveLiqToYt) {
+            _callbackRemoveLiqToYt(
+                market,
+                address(PT),
+                address(YT),
+                ptToAccount,
+                syToAccount,
+                data
+            );
+        } else {
+            assert(false);
+        }
+    }
+
+    /// ------------------------------------------------------------
+    /// AddLiqFromYt
+    /// ------------------------------------------------------------
+
+    function _callbackAddLiqFromYt(
+        address market,
+        address PT,
+        address YT,
+        int256 ptToAccount,
+        int256 /*syToAccount*/,
+        bytes calldata data
+    ) internal {
+        uint256 netPyRedeemSy = _decodeAddLiqFromYt(data);
+        IERC20(PT).safeTransfer(address(YT), netPyRedeemSy);
+
+        bool needToBurnYt = (!IPYieldToken(YT).isExpired());
+        if (needToBurnYt) IERC20(YT).safeTransfer(YT, netPyRedeemSy);
+
+        IPYieldToken(YT).redeemPY(market); // all SY goes to market to repay and mint LP
+        IERC20(PT).safeTransfer(market, ptToAccount.Uint() - netPyRedeemSy); // remaining PT goes to market to mint LP
+    }
+
+    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(
+        address market,
+        address /*PT*/,
+        address YT,
+        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
+    }
+
+    /// ------------------------------------------------------------
+    /// Misc functions
+    /// ------------------------------------------------------------
+
+    function _getActionType(bytes calldata data) internal pure returns (TradeActionType actionType) {
+        assembly {
+            actionType := calldataload(data.offset)
+        }
+    }
+
+    function _decodeRemoveLiqToYt(bytes calldata data) internal pure returns (uint256 minYtOut) {
+        assembly {
+            // first 32 bytes is ActionType
+            minYtOut := calldataload(add(data.offset, 32))
+        }
+    }
+
+    function _encodeRemoveLiqToYt(uint256 minYtOut) internal pure returns (bytes memory res) {
+        res = new bytes(64);
+        uint256 actionType = uint256(TradeActionType.RemoveLiqToYt);
+
+        assembly {
+            mstore(add(res, 32), actionType)
+            mstore(add(res, 64), minYtOut)
+        }
+    }
+
+    function _encodeAddLiqFromYt(uint256 netPyRedeemSy) internal pure returns (bytes memory res) {
+        res = new bytes(64);
+        uint256 actionType = uint256(TradeActionType.AddLiqFromYt);
+
+        assembly {
+            mstore(add(res, 32), actionType)
+            mstore(add(res, 64), netPyRedeemSy)
+        }
+    }
+}

package/contracts/core/TradingBot/libraries/SpecSegmentLib.sol

@@ -16,7 +16,7 @@ library SpecSegmentLib {
         TradingSpecs memory specs,
         uint256 segId
     ) internal pure returns (uint256) {
-        assert(segId != 0 && segId != specs.numOfBins * 2);
+        assert(segId != 0 && segId != specs.numOfBins * 2 + 1);
         uint256 length = getSegLength(specs);
         return specs.buyYtIy + length * (segId - 1) + length / 2;
     }

package/contracts/core/TradingBot/libraries/TvlLib.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "./MarketExtLib.sol";
+import "../../../interfaces/TradingBot/IBotDecisionHelper.sol";
+import "../../../oracles/PendleLpOracleLib.sol";
+
+library TvlLib {
+    using MarketMathCore for MarketState;
+    using MarketExtLib for MarketExtState;
+    using Math for uint256;
+    using Math for int256;
+    using PendleLpOracleLib for IPMarket;
+    using PendlePtOracleLib for IPMarket;
+    using PYIndexLib for PYIndex;
+
+    uint32 internal constant ORACLE_DURATION = 1800;
+
+    function getOracleTvl(address market, BotState memory bot) public view returns (uint256) {
+        PYIndex index = IPMarket(market)._getPYIndexCurrent();
+
+        uint256 tvlInAsset;
+        if (bot.lpBalance > 0) {
+            tvlInAsset += bot.lpBalance.mulDown(
+                IPMarket(market).getLpToAssetRate(ORACLE_DURATION)
+            );
+        }
+
+        if (bot.ptBalance + bot.ytBalance > 0) {
+            uint256 ptPrice = IPMarket(market).getPtToAssetRate(ORACLE_DURATION);
+            uint256 ytPrice = Math.ONE - ptPrice;
+            tvlInAsset += bot.ptBalance.mulDown(ptPrice) + bot.ytBalance.mulDown(ytPrice);
+        }
+
+        return index.assetToSy(tvlInAsset) + bot.syBalance;
+    }
+
+    function getLiquidateTvl(
+        BotState memory bot,
+        MarketExtState memory marketExt
+    ) public 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;
+    }
+}

package/contracts/interfaces/TradingBot/IBotDecisionHelper.sol

@@ -3,29 +3,41 @@ pragma solidity 0.8.17;
 
 import "./ITradingBotBase.sol";
 
-enum ActionType {
+enum TradeActionType {
     NONE,
     AddLiqFromYt, // Sell YT for LP
-    RemoveLiqToYt, // Zap out to YT,
-    SwapPtForYt,
-    SwapYtForPt
+    RemoveLiqToYt // Zap out to YT,
+}
+
+enum RebalanceType {
+    NONE,
+    AddLiqKeepYt,
+    RemoveLpAndYt,
+    SellYt
 }
 
 interface IBotDecisionHelper {
-    enum RebalanceResult {
+    enum TradeActionResult {
         TARGET_NOT_REACHED,
         SUCCESS,
         FAIL_OR_TARGET_EXCEED
     }
 
-    struct RebalanceDetails {
+    struct RebalanceOutput {
+        RebalanceType rebalanceType;
+        uint256 amountIn;
+        uint256 amountOut;
+        uint256 amountOut2;
+    }
+
+    struct TradeParams {
         StrategyData strategyData;
-        ActionType action;
+        TradeActionType action;
         uint256 targetIy;
     }
 
-    struct ActionToTakeResult {
-        ActionType action;
+    struct TradeResult {
+        TradeActionType action;
         int currentBin;
         uint256 targetIy;
         uint256 guessBotParams;
@@ -35,23 +47,29 @@ interface IBotDecisionHelper {
 
     function getCurrentBin(StrategyData memory strategyData) external view returns (int256);
 
-    function botExtStats(
-        StrategyData memory strategyData
-    )
-        external
-        view
-        returns (uint256 tvlInSy, uint256 iy, uint256 currentSyRatio, uint256 currentYtPtRatio);
-
     function searchForBotParam(
         StrategyData memory strategyData,
-        ActionType action,
+        TradeActionType action,
         uint256 targetIy,
         uint256 rebalanceAdditionalCheck,
         ApproxParams memory botParams,
         ApproxParams memory intParams
     ) external view returns (uint256);
 
-    function getFloatingSyAmount(address botAddress) external returns (uint256 floatingSyAmount);
+    function getRebalanceAction(address botAddress) external view returns (RebalanceOutput memory);
+
+    function getTradeAction(address botAddress) external view returns (TradeResult memory res);
 
-    function getActionDetails(address botAddress) external returns (ActionToTakeResult memory res);
+    function getBotPosition(
+        address botAddress
+    )
+        external
+        view
+        returns (
+            StrategyData memory strategyData,
+            uint256 tvlInSy,
+            uint256 iy,
+            uint256 currentSyRatio,
+            uint256 currentYtPtRatio
+        );
 }

package/contracts/interfaces/TradingBot/ITradingBotBase.sol

@@ -17,7 +17,7 @@ struct TradingSpecs {
     uint256 buyYtIy;
     uint256 sellYtIy;
     uint256 targetSyRatio;
-    uint256 maxSyRatio;
+    uint256 bufferSyRatio;
     uint256 targetYtPtRatio;
     uint256 numOfBins;
 }
@@ -40,24 +40,14 @@ interface ITradingBotBase {
 
     event WithdrawFunds(address indexed token, uint256 amount);
 
-    event ClaimAndCompound(uint256 netSyOut, uint256 netPendleOut);
+    event ClaimAndCompound(uint256 netSyOut);
 
-    function approveInf(MultiApproval[] calldata arr) external;
-
-    function depositSy(uint256 netSyIn) external;
-
-    function depositToken(TokenInput calldata inp, uint256 minSyOut) external payable;
-
-    function withdrawFunds(address token, uint256 amount) external;
-
-    function claimAndCompound(
-        TokenInput[] calldata inps,
+    function compound(
+        TokenInput calldata inp,
         uint256 minSyOut
-    ) external returns (uint256 netSyOut, uint256 netPendleOut);
-
-    function claimWithoutCompound() external returns (TokenAmount[] memory rewards);
+    ) external returns (uint256 netSyOut);
 
-    function readStrategyData() external returns (StrategyData memory strategyData);
+    function readStrategyData() external view returns (StrategyData memory strategyData);
 
     function setSpecs(TradingSpecs calldata _specs) external;
 }

package/contracts/oracles/PendleLpOracleLib.sol

@@ -55,7 +55,7 @@ library PendleLpOracleLib {
         return state.getMarketPreCompute(_getPYIndexCurrent(market), block.timestamp);
     }
 
-    function _getPYIndexCurrent(IPMarket market) private view returns (PYIndex) {
+    function _getPYIndexCurrent(IPMarket market) internal view returns (PYIndex) {
         (IStandardizedYield SY, , IPYieldToken YT) = market.readTokens();
         uint256 ytIndex = YT.pyIndexStored();
         uint256 pyIndexCurrent;

package/deployments/core.ts

@@ -0,0 +1,29 @@
+import ethCoreJSON from './1-core.json';
+
+export interface PendleCore {
+    PENDLE: string;
+    yieldContractFactory: string;
+    marketFactory: string;
+    bulkSellerFactory: string;
+    bulkSellerOffchain: string;
+    router: string;
+    routerStatic: string;
+    vePendle: string;
+    gaugeController: string;
+}
+
+export interface PendleCoreMainchain extends PendleCore {
+    senderEndpoint: string;
+    votingController: string;
+    feeDistributor: string;
+}
+
+export interface PendleCoreSidechain extends PendleCore {
+    receiverEndpoint: string;
+}
+
+const ethCore: PendleCoreMainchain = ethCoreJSON;
+
+export const pendleCore = {
+    ethereum: ethCore,
+};

package/deployments/index.ts

@@ -0,0 +1,4 @@
+export * from './core';
+export * from './markets';
+export * from './misc';
+export * from '../typechain-types';

package/deployments/markets/ape-june-29-2023.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketApeJune292022JSON from '../1-markets/APE-JUNE-29.json';
+export const apeJune292022: MarketDeployment = marketApeJune292022JSON;

package/deployments/markets/balancer-reth-dec-28-2023.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketBalancerRethDec282023JSON from '../1-markets/BALANCER-LP-AURA-RETH-WETH-28DEC.json';
+export const balancerRethDec282023: MarketDeployment = marketBalancerRethDec282023JSON;

package/deployments/markets/balancer-wsteth-jun-27-2024.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketBalancerWstEthJun272024JSON from '../1-markets/BALANCER-LP-AURA-WSTETH-WETH-JUN272024.json';
+export const balancerWstEthJun272024: MarketDeployment = marketBalancerWstEthJun272024JSON;

package/deployments/markets/curve-fraxusdc-march-30-2023.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketCurveFraxUsdcMarch302023JSON from '../1-markets/FRAXUSDC-CURVELP-MARCH30.json';
+export const curveFraxUsdcMarch302023: MarketDeployment = marketCurveFraxUsdcMarch302023JSON;

package/deployments/markets/index.ts

@@ -0,0 +1,17 @@
+import { apeJune292022 } from './ape-june-29-2023';
+import { balancerRethDec282023 } from './balancer-reth-dec-28-2023';
+import { balancerWstEthJun272024 } from './balancer-wsteth-jun-27-2024';
+import { curveFraxUsdcMarch302023 } from './curve-fraxusdc-march-30-2023';
+import { looksMarch302023 } from './looks-march-30-2023';
+import { stEthJune292023 } from './steth-june-29-2023';
+import { stEthMarch302023 } from './steth-march-30-2023';
+
+export const markets = {
+    apeJune292022,
+    balancerRethDec282023,
+    balancerWstEthJun272024,
+    curveFraxUsdcMarch302023,
+    looksMarch302023,
+    stEthJune292023,
+    stEthMarch302023,
+};

package/deployments/markets/looks-march-30-2023.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketLooksMarch302023JSON from '../1-markets/LOOKS-STAKING-MARCH30.json';
+export const looksMarch302023: MarketDeployment = marketLooksMarch302023JSON;

package/deployments/markets/steth-june-29-2023.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketStEthJune292023JSON from '../1-markets/STETH-JUNE29.json';
+export const stEthJune292023: MarketDeployment = marketStEthJune292023JSON;

package/deployments/markets/steth-march-30-2023.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketStEthMarch302023JSON from '../1-markets/STETH-MARCH30.json';
+export const stEthMarch302023: MarketDeployment = marketStEthMarch302023JSON;

package/deployments/markets/types.ts

@@ -0,0 +1,9 @@
+export interface MarketDeployment {
+    name: string;
+    SY: string;
+    YT: string;
+    PT: string;
+    market: string;
+    expiry: number;
+    bulkSeller?: string;
+}

package/deployments/misc.ts

@@ -0,0 +1,23 @@
+import { BigNumber as BN, utils } from 'ethers';
+
+export const MISC_CONSTS = {
+    RONE: BN.from(2).pow(40),
+    ONE_E_12: BN.from(10).pow(12),
+    ONE_E_18: BN.from(10).pow(18),
+    INF: BN.from(2).pow(256).sub(1),
+    ZERO_BYTES: utils.formatBytes32String(''),
+    ZERO_ADDRESS: '0x0000000000000000000000000000000000000000',
+    DUMMY_ADDRESS: '0xDEADbeEfEEeEEEeEEEeEEeeeeeEeEEeeeeEEEEeE',
+    ONE_HOUR: BN.from(3600),
+    ONE_DAY: BN.from(86400),
+    ONE_WEEK: BN.from(86400 * 7),
+    FIFTEEN_DAY: BN.from(86400 * 15),
+    ONE_MONTH: BN.from(2592000),
+    THREE_MONTH: BN.from(2592000 * 3),
+    FIVE_MONTH: BN.from(2592000 * 5),
+    SIX_MONTH: BN.from(2592000 * 6),
+    ONE_QUARTER: BN.from(7884000),
+    ONE_YEAR: BN.from(31536000),
+    END_OF_2023: BN.from(1703721600),
+    JUNE_OF_2022: BN.from(1656547200),
+};

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "2.19.1-tradingbot",
+  "version": "2.20.0-tradingbot",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",