@pendle/core-v2 2.17.7-tradingbot → 2.18.0-tradingbot

package/contracts/core/TradingBot/TradingBotBase.sol

@@ -12,16 +12,20 @@ abstract contract TradingBotBase is BoringOwnableUpgradeable, TokenHelper, ITrad
     using PYIndexLib for IPYieldToken;
 
     address public immutable market;
+    address public immutable router;
     address public immutable SY;
     address public immutable PT;
     address public immutable YT;
     address public immutable PENDLE;
 
-    constructor(address _market, address _PENDLE) initializer {
+    uint256 public buyBins;
+
+    constructor(address _market, address _router, address _PENDLE) initializer {
         (IStandardizedYield _SY, IPPrincipalToken _PT, IPYieldToken _YT) = IPMarket(_market)
             .readTokens();
 
         market = _market;
+        router = _router;
         SY = address(_SY);
         PT = address(_PT);
         YT = address(_YT);
@@ -52,12 +56,11 @@ abstract contract TradingBotBase is BoringOwnableUpgradeable, TokenHelper, ITrad
 
     /// @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);
+        _compoundSingle(inp, minSyOut);
         emit DepositToken(inp.tokenIn, inp.netTokenIn);
     }
 
@@ -68,13 +71,12 @@ abstract contract TradingBotBase is BoringOwnableUpgradeable, TokenHelper, ITrad
     }
 
     function claimAndCompound(
-        address router,
         TokenInput[] calldata inps,
         uint256 minSyOut
     ) external onlyOwner returns (uint256 netSyOut, uint256 netPendleOut) {
         _claimRewards();
 
-        netSyOut = _compound(router, inps, minSyOut);
+        netSyOut = _compound(inps, minSyOut);
 
         netPendleOut = _selfBalance(PENDLE);
         _transferOut(PENDLE, owner, netPendleOut);
@@ -101,7 +103,7 @@ abstract contract TradingBotBase is BoringOwnableUpgradeable, TokenHelper, ITrad
         rewards = rewards.add(lpRewardTokens, lpRewardAmounts);
     }
 
-    function readMarketExtState(address router) public returns (MarketExtState memory marketExt) {
+    function readMarketExtState() public returns (MarketExtState memory marketExt) {
         marketExt.state = IPMarket(market).readState(router);
         marketExt.index = IPYieldToken(YT).newIndex();
         marketExt.blockTime = block.timestamp;
@@ -111,10 +113,15 @@ abstract contract TradingBotBase is BoringOwnableUpgradeable, TokenHelper, ITrad
         botState.lpBalance = _selfBalance(market);
         botState.syBalance = _selfBalance(SY);
         botState.ytBalance = _selfBalance(YT);
+        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));
@@ -122,14 +129,13 @@ abstract contract TradingBotBase is BoringOwnableUpgradeable, TokenHelper, ITrad
     }
 
     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);
+            netSyOut += _compoundSingle(inps[i], 0);
         }
 
         if (netSyOut < minSyOut) revert Errors.BotInsufficientSyOut(netSyOut, minSyOut);
@@ -137,7 +143,6 @@ abstract contract TradingBotBase is BoringOwnableUpgradeable, TokenHelper, ITrad
     }
 
     function _compoundSingle(
-        address router,
         TokenInput memory inp,
         uint256 minSyOut
     ) internal returns (uint256 /*netSyOut*/) {

package/contracts/interfaces/TradingBot/IBotDecisionHelper.sol

@@ -4,88 +4,72 @@ pragma solidity 0.8.17;
 import "../../core/TradingBot/BotSimulationLib.sol";
 
 struct LongTradingSpecs {
-    uint256 lowerIyLimit; // apeYtApy
-    uint256 upperIyLimit; // sellYtApy
-    uint256 floatingSyRatioLimit; // h_r
-    uint256 floatingSyRatioTarget; // l_r
-    uint256 ytPtRatioLimit; // h_x
-    uint256 ytPtRatioTarget; // l_x
+    uint256 buyYtIy;
+    uint256 sellYtIy;
+    uint256 targetSyRatio;
+    uint256 maxSyRatio;
+    uint256 minYtPtRatio;
+    uint256 numOfBins;
 }
 
 enum ActionType {
-    SwapSyToYt, // Buy YT with SY
-    AddLiqKeepYt, // ZPI Zap
-    AddLiqFromSy, // Single sided LP
+    NONE,
     AddLiqFromYt, // Sell YT for LP
-    RemoveLiqToYt, // Zap out to YT,
-    NONE
+    RemoveLiqToYt // Zap out to YT,
 }
 
-enum StrategyFlag {
-    GOOD,
-    TOO_LOW,
-    TOO_HIGH
-}
-
-struct StrategyState {
-    StrategyFlag iyFlag;
-    StrategyFlag syRatioFlag;
+struct StrategyData {
+    BotState botState;
+    MarketExtState marketExt;
+    LongTradingSpecs specs;
 }
 
 interface IBotDecisionHelper {
     enum RebalanceResult {
-        FAIL,
-        TARGET_REACHED,
-        TARGET_NOT_REACHED
+        TARGET_NOT_REACHED,
+        SUCCESS,
+        FAIL_OR_TARGET_EXCEED
     }
 
     struct RebalanceDetails {
-        BotState bot;
-        MarketExtState marketExt;
-        LongTradingSpecs specs;
+        StrategyData strategyData;
         ActionType action;
+        uint256 targetIy;
     }
 
-    function searchForBotParam(
-        BotState memory bot,
-        MarketExtState memory marketExt,
-        LongTradingSpecs memory specs,
-        ActionType action,
-        ApproxParams memory botParams,
-        ApproxParams memory intParams
-    ) external pure returns (uint256, RebalanceResult);
-
-    function searchForIntParam(
-        MarketExtState memory marketExt,
-        ActionType action,
-        uint256 botParam,
-        ApproxParams memory intParams
-    ) external pure returns (uint256);
-
-    function strategyState(
-        BotState memory bot,
-        MarketExtState memory marketExt,
-        LongTradingSpecs memory specs
-    ) external pure returns (StrategyState memory);
+    struct ActionToTakeResult {
+        ActionType action;
+        int currentBin;
+        uint256 targetIy;
+        uint256 guessBotParams;
+        uint256 guessIntParams;
+        uint256 amountOut;
+    }
 
-    function actionToTake(
-        BotState memory botState,
-        StrategyState memory currentState
-    ) external pure returns (ActionType);
+    function getCurrentBin(StrategyData memory strategyData) external view returns (int256);
 
     function previewAction(
-        BotState memory botData,
-        MarketExtState memory marketExtData,
+        StrategyData memory strategyData,
         ActionType action,
         uint256 botParam,
         ApproxParams memory swapApproxParams
-    ) external pure returns (bool, BotState memory, MarketExtState memory);
+    ) external view returns (bool, BotState memory, MarketExtState memory);
 
     function botExtStats(
-        BotState memory bot,
-        MarketExtState memory marketExt
+        StrategyData memory strategyData
     )
         external
-        pure
+        view
         returns (uint256 tvlInSy, uint256 iy, uint256 currentSyRatio, uint256 currentYtPtRatio);
+
+    function searchForBotParam(
+        StrategyData memory strategyData,
+        ActionType action,
+        uint256 targetIy,
+        uint256 rebalanceAdditionalCheck,
+        ApproxParams memory botParams,
+        ApproxParams memory intParams
+    ) external view returns (uint256);
+
+    function getAvailableZpiAmount(address botAddress) external returns (uint256 amountSyToZpi);
 }

package/contracts/interfaces/TradingBot/ILongYieldTradingBot.sol

@@ -8,8 +8,6 @@ interface ILongYieldTradingBot is ITradingBotBase {
     event SwapSyToYt(ApproxParams botParams, uint256 maxSyIn, uint256 exactYtOut, uint256 netSyIn);
 
     event AddLiqKeepYt(
-        ApproxParams botParams,
-        uint256 maxSyIn,
         uint256 netSyIn,
         uint256 netLpOut,
         uint256 netYtOut
@@ -17,48 +15,40 @@ interface ILongYieldTradingBot is ITradingBotBase {
 
     event AddLiqFromSy(ApproxParams botParams, uint256 maxSyIn, uint256 netSyIn, uint256 netLpOut);
 
-    event AddLiqFromYt(ApproxParams botParams, uint256 maxYtIn, uint256 netYtIn, uint256 netLpOut);
+    event AddLiqFromYt(ApproxParams botParams, uint256 netYtIn, uint256 netLpOut);
 
-    event RemoveLiqToYt(
-        ApproxParams botParams,
-        uint256 maxLpRemoved,
-        uint256 netLpIn,
-        uint256 netYtOut
-    );
+    event RemoveLiqToYt(ApproxParams botParams, uint256 netLpIn, uint256 netYtOut);
 
-    function setSpecs(LongTradingSpecs calldata _specs) external;
+    struct AddLiqFromYtInput {
+        ApproxParams botParams;
+        uint256 minLpOut;
+        uint256 targetIy;
+        int256 currentBin;
+    }
 
-    function swapSyToYt(
-        address router,
-        ApproxParams calldata botParams,
-        uint256 minYtOut,
-        uint256 maxSyIn
-    ) external returns (uint256 exactYtOut, uint256 netSyIn);
+    struct RemoveLiqToYtInput {
+        ApproxParams botParams;
+        ApproxParams guessTotalPtToSwap;
+        uint256 minYtOut;
+        uint256 targetIy;
+        int256 currentBin;
+    }
+
+    function setSpecs(LongTradingSpecs calldata _specs) external;
 
     function addLiqKeepYt(
-        address router,
-        ApproxParams calldata botParams,
-        uint256 maxSyIn,
+        uint256 netSyIn,
         uint256 minLpOut,
         uint256 minYtOut
-    ) external returns (uint256 netSyIn, uint256 netLpOut, uint256 netYtOut);
-
-    function addLiqFromSy(
-        ApproxParams calldata botParams,
-        uint256 minLpOut,
-        uint256 maxSyIn
-    ) external returns (uint256 netPtFromSwap, uint256 netLpOut, uint256 netSyIn);
+    ) external returns (uint256 netLpOut, uint256 netYtOut);
 
     function addLiqFromYt(
-        ApproxParams calldata botParams,
-        uint256 minLpOut,
-        uint256 maxYtIn
+        AddLiqFromYtInput calldata inputParams
     ) external returns (uint256 netPtFromSwap, uint256 netLpOut, uint256 netYtIn);
 
     function removeLiqToYt(
-        ApproxParams calldata botParams,
-        ApproxParams calldata guessTotalPtToSwap,
-        uint256 maxLpRemoved,
-        uint256 minYtOut
-    ) external returns (uint256 netLpRemoved, uint256 netYtOut, uint256 totalPtToSwap);
+        RemoveLiqToYtInput calldata inputParams
+    ) external returns (uint256 netLpRemoved, uint256 netYtOut);
+
+    function readStrategyData() external returns (StrategyData memory strategyData);
 }

package/contracts/interfaces/TradingBot/ITradingBotBase.sol

@@ -24,7 +24,6 @@ interface ITradingBotBase {
     function depositSy(uint256 netSyIn) external;
 
     function depositToken(
-        address router,
         TokenInput calldata inp,
         uint256 minSyOut
     ) external payable;
@@ -32,14 +31,13 @@ interface ITradingBotBase {
     function withdrawFunds(address token, uint256 amount) external;
 
     function claimAndCompound(
-        address router,
         TokenInput[] calldata inps,
         uint256 minSyOut
     ) external returns (uint256 netSyOut, uint256 netPendleOut);
 
     function claimWithoutCompound() external returns (TokenAmount[] memory rewards);
 
-    function readMarketExtState(address router) external returns (MarketExtState memory marketExt);
+    function readMarketExtState() external returns (MarketExtState memory marketExt);
 
     function readBotState() external view returns (BotState memory botState);
 }

package/package.json

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

package/typechain-types/BotActionCallback.ts

@@ -73,12 +73,19 @@ export type BotStateStruct = {
   lpBalance: BigNumberish;
   ytBalance: BigNumberish;
   syBalance: BigNumberish;
+  buyBins: BigNumberish;
 };
 
-export type BotStateStructOutput = [BigNumber, BigNumber, BigNumber] & {
+export type BotStateStructOutput = [
+  BigNumber,
+  BigNumber,
+  BigNumber,
+  BigNumber
+] & {
   lpBalance: BigNumber;
   ytBalance: BigNumber;
   syBalance: BigNumber;
+  buyBins: BigNumber;
 };
 
 export type MarketStateStruct = {
@@ -144,16 +151,18 @@ export interface BotActionCallbackInterface extends utils.Interface {
     "SY()": FunctionFragment;
     "YT()": FunctionFragment;
     "approveInf((address[],address)[])": FunctionFragment;
-    "claimAndCompound(address,(address,uint256,address,address,address,(uint8,address,bytes,bool))[],uint256)": FunctionFragment;
+    "buyBins()": FunctionFragment;
+    "claimAndCompound((address,uint256,address,address,address,(uint8,address,bytes,bool))[],uint256)": FunctionFragment;
     "claimOwnership()": FunctionFragment;
     "claimWithoutCompound()": FunctionFragment;
     "depositSy(uint256)": FunctionFragment;
-    "depositToken(address,(address,uint256,address,address,address,(uint8,address,bytes,bool)),uint256)": FunctionFragment;
+    "depositToken((address,uint256,address,address,address,(uint8,address,bytes,bool)),uint256)": FunctionFragment;
     "market()": FunctionFragment;
     "owner()": FunctionFragment;
     "pendingOwner()": FunctionFragment;
     "readBotState()": FunctionFragment;
-    "readMarketExtState(address)": FunctionFragment;
+    "readMarketExtState()": FunctionFragment;
+    "router()": FunctionFragment;
     "swapCallback(int256,int256,bytes)": FunctionFragment;
     "transferOwnership(address,bool,bool)": FunctionFragment;
     "withdrawFunds(address,uint256)": FunctionFragment;
@@ -167,9 +176,10 @@ export interface BotActionCallbackInterface extends utils.Interface {
     functionFragment: "approveInf",
     values: [ITradingBotBase.MultiApprovalStruct[]]
   ): string;
+  encodeFunctionData(functionFragment: "buyBins", values?: undefined): string;
   encodeFunctionData(
     functionFragment: "claimAndCompound",
-    values: [string, TokenInputStruct[], BigNumberish]
+    values: [TokenInputStruct[], BigNumberish]
   ): string;
   encodeFunctionData(
     functionFragment: "claimOwnership",
@@ -185,7 +195,7 @@ export interface BotActionCallbackInterface extends utils.Interface {
   ): string;
   encodeFunctionData(
     functionFragment: "depositToken",
-    values: [string, TokenInputStruct, BigNumberish]
+    values: [TokenInputStruct, BigNumberish]
   ): string;
   encodeFunctionData(functionFragment: "market", values?: undefined): string;
   encodeFunctionData(functionFragment: "owner", values?: undefined): string;
@@ -199,8 +209,9 @@ export interface BotActionCallbackInterface extends utils.Interface {
   ): string;
   encodeFunctionData(
     functionFragment: "readMarketExtState",
-    values: [string]
+    values?: undefined
   ): string;
+  encodeFunctionData(functionFragment: "router", values?: undefined): string;
   encodeFunctionData(
     functionFragment: "swapCallback",
     values: [BigNumberish, BigNumberish, BytesLike]
@@ -219,6 +230,7 @@ export interface BotActionCallbackInterface extends utils.Interface {
   decodeFunctionResult(functionFragment: "SY", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "YT", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "approveInf", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "buyBins", data: BytesLike): Result;
   decodeFunctionResult(
     functionFragment: "claimAndCompound",
     data: BytesLike
@@ -250,6 +262,7 @@ export interface BotActionCallbackInterface extends utils.Interface {
     functionFragment: "readMarketExtState",
     data: BytesLike
   ): Result;
+  decodeFunctionResult(functionFragment: "router", data: BytesLike): Result;
   decodeFunctionResult(
     functionFragment: "swapCallback",
     data: BytesLike
@@ -359,8 +372,9 @@ export interface BotActionCallback extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
+    buyBins(overrides?: CallOverrides): Promise<[BigNumber]>;
+
     claimAndCompound(
-      router: string,
       inps: TokenInputStruct[],
       minSyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
@@ -380,7 +394,6 @@ export interface BotActionCallback extends BaseContract {
     ): Promise<ContractTransaction>;
 
     depositToken(
-      router: string,
       inp: TokenInputStruct,
       minSyOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
@@ -397,10 +410,11 @@ export interface BotActionCallback extends BaseContract {
     ): Promise<[BotStateStructOutput] & { botState: BotStateStructOutput }>;
 
     readMarketExtState(
-      router: string,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
+    router(overrides?: CallOverrides): Promise<[string]>;
+
     swapCallback(
       ptToAccount: BigNumberish,
       syToAccount: BigNumberish,
@@ -435,8 +449,9 @@ export interface BotActionCallback extends BaseContract {
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
+  buyBins(overrides?: CallOverrides): Promise<BigNumber>;
+
   claimAndCompound(
-    router: string,
     inps: TokenInputStruct[],
     minSyOut: BigNumberish,
     overrides?: Overrides & { from?: string | Promise<string> }
@@ -456,7 +471,6 @@ export interface BotActionCallback extends BaseContract {
   ): Promise<ContractTransaction>;
 
   depositToken(
-    router: string,
     inp: TokenInputStruct,
     minSyOut: BigNumberish,
     overrides?: PayableOverrides & { from?: string | Promise<string> }
@@ -471,10 +485,11 @@ export interface BotActionCallback extends BaseContract {
   readBotState(overrides?: CallOverrides): Promise<BotStateStructOutput>;
 
   readMarketExtState(
-    router: string,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
+  router(overrides?: CallOverrides): Promise<string>;
+
   swapCallback(
     ptToAccount: BigNumberish,
     syToAccount: BigNumberish,
@@ -509,8 +524,9 @@ export interface BotActionCallback extends BaseContract {
       overrides?: CallOverrides
     ): Promise<void>;
 
+    buyBins(overrides?: CallOverrides): Promise<BigNumber>;
+
     claimAndCompound(
-      router: string,
       inps: TokenInputStruct[],
       minSyOut: BigNumberish,
       overrides?: CallOverrides
@@ -527,7 +543,6 @@ export interface BotActionCallback extends BaseContract {
     depositSy(netSyIn: BigNumberish, overrides?: CallOverrides): Promise<void>;
 
     depositToken(
-      router: string,
       inp: TokenInputStruct,
       minSyOut: BigNumberish,
       overrides?: CallOverrides
@@ -542,10 +557,11 @@ export interface BotActionCallback extends BaseContract {
     readBotState(overrides?: CallOverrides): Promise<BotStateStructOutput>;
 
     readMarketExtState(
-      router: string,
       overrides?: CallOverrides
     ): Promise<MarketExtStateStructOutput>;
 
+    router(overrides?: CallOverrides): Promise<string>;
+
     swapCallback(
       ptToAccount: BigNumberish,
       syToAccount: BigNumberish,
@@ -625,8 +641,9 @@ export interface BotActionCallback extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
+    buyBins(overrides?: CallOverrides): Promise<BigNumber>;
+
     claimAndCompound(
-      router: string,
       inps: TokenInputStruct[],
       minSyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
@@ -646,7 +663,6 @@ export interface BotActionCallback extends BaseContract {
     ): Promise<BigNumber>;
 
     depositToken(
-      router: string,
       inp: TokenInputStruct,
       minSyOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
@@ -661,10 +677,11 @@ export interface BotActionCallback extends BaseContract {
     readBotState(overrides?: CallOverrides): Promise<BigNumber>;
 
     readMarketExtState(
-      router: string,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
+    router(overrides?: CallOverrides): Promise<BigNumber>;
+
     swapCallback(
       ptToAccount: BigNumberish,
       syToAccount: BigNumberish,
@@ -700,8 +717,9 @@ export interface BotActionCallback extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
+    buyBins(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     claimAndCompound(
-      router: string,
       inps: TokenInputStruct[],
       minSyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
@@ -721,7 +739,6 @@ export interface BotActionCallback extends BaseContract {
     ): Promise<PopulatedTransaction>;
 
     depositToken(
-      router: string,
       inp: TokenInputStruct,
       minSyOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
@@ -736,10 +753,11 @@ export interface BotActionCallback extends BaseContract {
     readBotState(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
     readMarketExtState(
-      router: string,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
+    router(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     swapCallback(
       ptToAccount: BigNumberish,
       syToAccount: BigNumberish,