@pendle/core-v2 2.15.2 → 2.17.0-tradingbot

package/contracts/core/TradingBot/TradingBotOffchain.sol

@@ -0,0 +1,131 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./BotDecisionLib.sol";
+import "../libraries/TokenAmountLib.sol";
+
+contract TradingBotOffchain {
+    using TokenAmountLib for TokenAmount[];
+    using BotSimulationLib for BotState;
+    using MarketMathCore for MarketState;
+    using MarketApproxPtInLib for MarketState;
+    using PYIndexLib for PYIndex;
+
+    /// SY interest from YT is excluded
+    function claimForBot(
+        address bot,
+        address market
+    ) external returns (TokenAmount[] memory rewards) {
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
+
+        address[] memory ytRewardTokens = YT.getRewardTokens();
+        (, uint256[] memory ytRewardAmounts) = YT.redeemDueInterestAndRewards(bot, true, true);
+        rewards = rewards.add(ytRewardTokens, ytRewardAmounts);
+
+        address[] memory syRewardTokens = SY.getRewardTokens();
+        uint256[] memory syRewardAmounts = SY.claimRewards(bot);
+        rewards = rewards.add(syRewardTokens, syRewardAmounts);
+
+        address[] memory lpRewardTokens = IPMarket(market).getRewardTokens();
+        uint256[] memory lpRewardAmounts = IPMarket(market).redeemRewards(bot);
+        rewards = rewards.add(lpRewardTokens, lpRewardAmounts);
+    }
+
+    function simulateAction(
+        BotState calldata botCalldata,
+        MarketExtState calldata marketExtCalldata,
+        ActionType action,
+        uint256 botParam,
+        ApproxParams memory swapApproxParams
+    ) external pure returns (bool success, BotState memory bot, MarketExtState memory marketExt) {
+        bot = botCalldata;
+        marketExt = marketExtCalldata;
+
+        if (action == ActionType.SwapSyToYt) {
+            success = bot.swapSyToYt(marketExt, botParam);
+        } else if (action == ActionType.AddLiqKeepYt) {
+            success = bot.addLiqKeepYt(marketExt, botParam);
+        } else if (action == ActionType.AddLiqFromSy) {
+            success = bot.addLiqFromSy(marketExt, botParam);
+        } else if (action == ActionType.AddLiqFromYt) {
+            success = bot.addLiqFromYt(marketExt, botParam);
+        } else if (action == ActionType.RemoveLiqToYt) {
+            success = bot.removeLiqToYt(marketExt, botParam, swapApproxParams);
+        } else {
+            success = false;
+        }
+    }
+
+    function searchForBotParam(
+        BotState calldata bot,
+        MarketExtState calldata marketExt,
+        LongTradingSpecs calldata specs,
+        ActionType action,
+        StrategyState calldata initialState,
+        ApproxParams calldata botParams,
+        ApproxParams calldata intParams
+    ) external pure returns (uint256) {
+        return
+            BotDecisionLib.binarySearchUntilSwitchState(
+                bot,
+                marketExt,
+                specs,
+                action,
+                initialState,
+                botParams,
+                intParams
+            );
+    }
+
+    function searchForIntParam(
+        MarketExtState calldata marketExt,
+        ActionType action,
+        uint256 botParam,
+        ApproxParams calldata intParams
+    ) external pure returns (uint256) {
+        if (action == ActionType.RemoveLiqToYt) {
+            return _searchForIntParamRemoveLiqToYt(marketExt, botParam, intParams);
+        } else {
+            return 0;
+        }
+    }
+
+    function strategyState(
+        BotState calldata bot,
+        MarketExtState calldata marketExt,
+        LongTradingSpecs calldata specs
+    ) external pure returns (StrategyState memory) {
+        return BotDecisionLib.strategyState(bot, marketExt, specs);
+    }
+
+    function actionToTake(StrategyState memory currentState) external pure returns (ActionType) {
+        return BotDecisionLib.actionToTake(currentState);
+    }
+
+    function tvlInSy(
+        BotState calldata bot,
+        MarketExtState calldata marketExt
+    ) external pure returns (uint256) {
+        return BotSimulationLib.tvlInSy(bot, marketExt);
+    }
+
+    function _searchForIntParamRemoveLiqToYt(
+        MarketExtState memory marketExt,
+        uint256 netLpToRemove,
+        ApproxParams memory intParams
+    ) private pure returns (uint256 totalPtToSwap) {
+        (uint256 netSyRemoved, uint256 netPtRemoved) = marketExt.state.removeLiquidity(
+            netLpToRemove
+        );
+
+        uint256 netYtFromSy = marketExt.index.syToAsset(netSyRemoved);
+        uint256 netPtToSwap = netPtRemoved + netYtFromSy;
+
+        (, totalPtToSwap, ) = marketExt.state.approxSwapExactPtForYt(
+            marketExt.index,
+            netPtToSwap,
+            marketExt.blockTime,
+            intParams
+        );
+    }
+}

package/contracts/core/libraries/Errors.sol

@@ -177,4 +177,16 @@ library Errors {
     // Swap Aggregator
     error SAInsufficientTokenIn(address tokenIn, uint256 amountExpected, uint256 amountActual);
     error UnsupportedSelector(uint256 aggregatorType, bytes4 selector);
+
+    // Trading Bot
+    error BotBinarySearchInvalidRange(uint256 action, uint256 guessMin, uint256 guessMax);
+    error BotBinarySearchGuessMinInvalid(uint256 action, uint256 guessMin);
+    error BotBinarySearchFail();
+    error BotExceededLimitSyIn(uint256 actualSyIn, uint256 limitSyIn);
+    error BotExceededLimitYtIn(uint256 actualYtIn, uint256 limitYtIn);
+    error BotExceededLimitLpToRemove(uint256 actualLpToRemove, uint256 limitLpToRemove);
+    error BotInsufficientSyOut(uint256 actualSyOut, uint256 requiredSyOut);
+    error BotInsufficientYtOut(uint256 actualYtOut, uint256 requiredYtOut);
+    error BotInsufficientLpOut(uint256 actualLpOut, uint256 requiredLpOut);
+    error BotCallbackNotMarket(address caller);
 }

package/contracts/core/libraries/TokenAmountLib.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity >=0.8.0;
+
+struct TokenAmount {
+    address token;
+    uint256 amount;
+}
+
+library TokenAmountLib {
+    function add(
+        TokenAmount[] memory list,
+        address token,
+        uint256 amount
+    ) internal pure returns (TokenAmount[] memory newList) {
+        if (amount == 0) return list;
+
+        uint256 newTokenIndex = list.length;
+        for (uint256 i = 0; i < list.length; i++) {
+            if (list[i].token == token) {
+                newTokenIndex = i;
+                break;
+            }
+        }
+
+        newList = new TokenAmount[](list.length + (newTokenIndex == list.length ? 1 : 0));
+        for (uint256 i = 0; i < list.length; i++) {
+            newList[i] = list[i];
+        }
+        newList[newTokenIndex] = TokenAmount(
+            token,
+            (newTokenIndex == list.length ? 0 : list[newTokenIndex].amount) + amount
+        );
+    }
+
+    function add(
+        TokenAmount[] memory list,
+        address[] memory tokens,
+        uint256[] memory amounts
+    ) internal pure returns (TokenAmount[] memory newList) {
+        newList = list;
+        require(tokens.length == amounts.length, "TokenAmountLib: length mismatch");
+        for (uint256 i = 0; i < tokens.length; i++) {
+            newList = add(newList, tokens[i], amounts[i]);
+        }
+        return newList;
+    }
+}

package/contracts/interfaces/Balancer/IERC4626LinearPool.sol

@@ -0,0 +1,181 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface IERC4626LinearPool {
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    event PausedStateChanged(bool paused);
+    event RecoveryModeStateChanged(bool enabled);
+    event SwapFeePercentageChanged(uint256 swapFeePercentage);
+    event TargetsSet(address indexed token, uint256 lowerTarget, uint256 upperTarget);
+    event Transfer(address indexed from, address indexed to, uint256 value);
+
+    struct SwapRequest {
+        uint8 kind;
+        address tokenIn;
+        address tokenOut;
+        uint256 amount;
+        bytes32 poolId;
+        uint256 lastChangeBlock;
+        address from;
+        address to;
+        bytes userData;
+    }
+
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+
+    function allowance(address owner, address spender) external view returns (uint256);
+
+    function approve(address spender, uint256 amount) external returns (bool);
+
+    function balanceOf(address account) external view returns (uint256);
+
+    function decimals() external view returns (uint8);
+
+    function decreaseAllowance(address spender, uint256 amount) external returns (bool);
+
+    function disableRecoveryMode() external;
+
+    function enableRecoveryMode() external;
+
+    function getActionId(bytes4 selector) external view returns (bytes32);
+
+    function getAuthorizer() external view returns (address);
+
+    function getBptIndex() external pure returns (uint256);
+
+    function getDomainSeparator() external view returns (bytes32);
+
+    function getMainIndex() external view returns (uint256);
+
+    function getMainToken() external view returns (address);
+
+    function getNextNonce(address account) external view returns (uint256);
+
+    function getOwner() external view returns (address);
+
+    function getPausedState()
+        external
+        view
+        returns (
+            bool paused,
+            uint256 pauseWindowEndTime,
+            uint256 bufferPeriodEndTime
+        );
+
+    function getPoolId() external view returns (bytes32);
+
+    function getProtocolFeesCollector() external view returns (address);
+
+    function getRate() external view returns (uint256);
+
+    function getScalingFactors() external view returns (uint256[] memory);
+
+    function getSwapFeePercentage() external view returns (uint256);
+
+    function getTargets() external view returns (uint256 lowerTarget, uint256 upperTarget);
+
+    function getVault() external view returns (address);
+
+    function getVirtualSupply() external view returns (uint256);
+
+    function getWrappedIndex() external view returns (uint256);
+
+    function getWrappedToken() external view returns (address);
+
+    function getWrappedTokenRate() external view returns (uint256);
+
+    function inRecoveryMode() external view returns (bool);
+
+    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
+
+    function initialize() external;
+
+    function name() external view returns (string memory);
+
+    function nonces(address owner) external view returns (uint256);
+
+    function onExitPool(
+        bytes32 poolId,
+        address sender,
+        address,
+        uint256[] memory balances,
+        uint256,
+        uint256,
+        bytes memory userData
+    ) external returns (uint256[] memory amountsOut, uint256[] memory dueProtocolFees);
+
+    function onJoinPool(
+        bytes32 poolId,
+        address sender,
+        address recipient,
+        uint256[] memory balances,
+        uint256,
+        uint256,
+        bytes memory userData
+    ) external returns (uint256[] memory amountsIn, uint256[] memory dueProtocolFees);
+
+    function onSwap(
+        SwapRequest memory request,
+        uint256[] memory balances,
+        uint256 indexIn,
+        uint256 indexOut
+    ) external returns (uint256);
+
+    function onSwap(
+        SwapRequest memory request,
+        uint256 balanceTokenIn,
+        uint256 balanceTokenOut
+    ) external returns (uint256);
+
+    function pause() external;
+
+    function permit(
+        address owner,
+        address spender,
+        uint256 value,
+        uint256 deadline,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external;
+
+    function queryExit(
+        bytes32,
+        address sender,
+        address,
+        uint256[] memory balances,
+        uint256,
+        uint256,
+        bytes memory userData
+    ) external returns (uint256 bptIn, uint256[] memory amountsOut);
+
+    function queryJoin(
+        bytes32,
+        address sender,
+        address,
+        uint256[] memory balances,
+        uint256,
+        uint256,
+        bytes memory userData
+    ) external returns (uint256 bptOut, uint256[] memory amountsIn);
+
+    function setSwapFeePercentage(uint256 swapFeePercentage) external;
+
+    function setTargets(uint256 newLowerTarget, uint256 newUpperTarget) external;
+
+    function symbol() external view returns (string memory);
+
+    function totalSupply() external view returns (uint256);
+
+    function transfer(address recipient, uint256 amount) external returns (bool);
+
+    function transferFrom(
+        address sender,
+        address recipient,
+        uint256 amount
+    ) external returns (bool);
+
+    function unpause() external;
+
+    function version() external view returns (string memory);
+}

package/contracts/interfaces/Balancer/IVault.sol

@@ -27,6 +27,19 @@ interface IVault {
         bool fromInternalBalance;
     }
 
+    struct SwapRequest {
+        IVault.SwapKind kind;
+        IERC20 tokenIn;
+        IERC20 tokenOut;
+        uint256 amount;
+        // Misc data
+        bytes32 poolId;
+        uint256 lastChangeBlock;
+        address from;
+        address to;
+        bytes userData;
+    }
+
     function joinPool(
         bytes32 poolId,
         address sender,

package/contracts/interfaces/TradingBot/ILongYieldTradingBot.sol

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./ITradingBotBase.sol";
+import "../../core/TradingBot/BotDecisionLib.sol";
+
+interface ILongYieldTradingBot {
+    function setSpecs(LongTradingSpecs calldata _specs) external;
+
+    event SwapSyToYt(
+        StrategyState state,
+        ApproxParams botParams,
+        uint256 maxSyIn,
+        uint256 exactYtOut,
+        uint256 netSyIn
+    );
+
+    event AddLiqKeepYt(
+        StrategyState state,
+        ApproxParams botParams,
+        uint256 maxSyIn,
+        uint256 netSyIn,
+        uint256 netLpOut,
+        uint256 netYtOut
+    );
+
+    event AddLiqFromSy(
+        StrategyState state,
+        ApproxParams botParams,
+        uint256 maxSyIn,
+        uint256 netSyIn,
+        uint256 netLpOut
+    );
+
+    event AddLiqFromYt(
+        StrategyState state,
+        ApproxParams botParams,
+        uint256 maxYtIn,
+        uint256 netYtIn,
+        uint256 netLpOut
+    );
+
+    event RemoveLiqToYt(
+        StrategyState state,
+        ApproxParams botParams,
+        uint256 maxLpRemoved,
+        uint256 netLpIn,
+        uint256 netYtOut
+    );
+
+    function swapSyToYt(
+        address router,
+        StrategyState memory oldState,
+        ApproxParams calldata botParams,
+        uint256 minYtOut,
+        uint256 maxSyIn
+    ) external returns (uint256 exactYtOut, uint256 netSyIn);
+
+    function addLiqKeepYt(
+        address router,
+        StrategyState memory oldState,
+        ApproxParams calldata botParams,
+        uint256 maxSyIn,
+        uint256 minLpOut,
+        uint256 minYtOut
+    ) external returns (uint256 netSyIn, uint256 netLpOut, uint256 netYtOut);
+
+    function addLiqFromSy(
+        StrategyState memory oldState,
+        ApproxParams calldata botParams,
+        uint256 minLpOut,
+        uint256 maxSyIn
+    ) external returns (uint256 netLpOut, uint256 netSyIn);
+
+    function addLiqFromYt(
+        StrategyState memory oldState,
+        ApproxParams calldata botParams,
+        uint256 minLpOut,
+        uint256 maxYtIn
+    ) external returns (uint256 netLpOut, uint256 netYtIn);
+
+    function removeLiqToYt(
+        StrategyState memory oldState,
+        ApproxParams calldata botParams,
+        ApproxParams calldata guessTotalPtToSwap,
+        uint256 maxLpRemoved,
+        uint256 minYtOut
+    ) external returns (uint256 netLpRemoved, uint256 netYtOut);
+}

package/contracts/interfaces/TradingBot/ITradingBotBase.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../IPAllAction.sol";
+import "../../core/TradingBot/BotSimulationLib.sol";
+
+interface ITradingBotBase {
+    event DepositSy(uint256 netSyIn);
+
+    event DepositToken(address indexed token, uint256 netTokenIn);
+
+    event WithdrawFunds(address indexed token, uint256 amount);
+
+    event ClaimAndCompound(
+        uint256 netSyOut,
+        uint256 netPendleOut
+    );
+
+    function depositSy(uint256 netSyIn) external;
+
+    function depositToken(
+        address router,
+        TokenInput calldata inp,
+        uint256 minSyOut
+    ) external payable;
+
+    function withdrawFunds(address token, uint256 amount) external;
+
+    function approveInf(address token, address spender) external;
+
+    function claimAndCompound(
+        address router,
+        TokenInput[] calldata inps,
+        uint256 minSyOut
+    ) external returns (uint256 netSyOut, uint256 netPendleOut);
+
+    function readMarketExtState(address router) external returns (MarketExtState memory marketExt);
+
+    function readBotState() external view returns (BotState memory botState);
+}

package/contracts/offchain-helpers/BoringLpSeller.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+import "../interfaces/IPMarket.sol";
+
+abstract contract BoringLpSeller {
+    bytes internal constant EMPTY_BYTES = abi.encode();
+
+    constructor() {}
+
+    /// @dev slippage control should be done on a higher level with the returned parameter
+    /// @param market market address
+    /// @param netLpIn amount of Lp to sell
+    /// @param tokenOut should be included in SY.getTokensOut()
+    /// @return netTokenOut amount of token out
+    function _sellLpForToken(
+        address market,
+        uint256 netLpIn,
+        address tokenOut
+    ) internal returns (uint256 netTokenOut) {
+        (IStandardizedYield SY, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market)
+            .readTokens();
+
+        IPMarket(market).transfer(market, netLpIn);
+
+        uint256 netSyToRedeem;
+
+        if (PT.isExpired()) {
+            (uint256 netSyRemoved, ) = IPMarket(market).burn(address(SY), address(YT), netLpIn);
+            uint256 netSyFromPt = YT.redeemPY(address(SY));
+            netSyToRedeem = netSyRemoved + netSyFromPt;
+        } else {
+            (uint256 netSyRemoved, uint256 netPtRemoved) = IPMarket(market).burn(
+                address(SY),
+                market,
+                netLpIn
+            );
+            (uint256 netSySwappedOut, ) = IPMarket(market).swapExactPtForSy(
+                address(SY),
+                netPtRemoved,
+                EMPTY_BYTES
+            );
+            netSyToRedeem = netSyRemoved + netSySwappedOut;
+        }
+
+        netTokenOut = SY.redeem(address(this), netSyToRedeem, tokenOut, 0, true);
+    }
+}

package/contracts/oracles/samples/PendleLpGlpOracle.sol

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../PendleLpOracleLib.sol";
+import "../../interfaces/IPPtOracle.sol";
+import "../../interfaces/GMX/IGlpManager.sol";
+import "../../core/libraries/math/Math.sol";
+
+/**
+ * @notice The LP/GLP price gotten from the market using the LpOracleLib is multiplied with the USD price of GLP read from
+ * GLPManager contract
+ */
+contract PendleLpGlpOracle {
+    using PendleLpOracleLib for IPMarket;
+
+    uint32 public immutable twapDuration;
+    address public immutable market;
+    address public immutable glpManager;
+    error OracleNotReady(bool increaseCardinalityRequired, bool oldestObservationSatisfied);
+
+    constructor(
+        address _ptOracle,
+        uint32 _twapDuration,
+        address _market,
+        address _glpManager
+    ) {
+        twapDuration = _twapDuration;
+        market = _market;
+        glpManager = _glpManager;
+
+        (bool increaseCardinalityRequired, , bool oldestObservationSatisfied) = IPPtOracle(
+            _ptOracle
+        ).getOracleState(market, twapDuration);
+
+        if (increaseCardinalityRequired || !oldestObservationSatisfied) {
+            revert OracleNotReady(increaseCardinalityRequired, oldestObservationSatisfied);
+        }
+    }
+
+    function getLpPrice() external view virtual returns (uint256) {
+        uint256 lpRate = IPMarket(market).getLpToAssetRate(twapDuration);
+        uint256 assetPrice = IGlpManager(glpManager).getPrice(true);
+        return (assetPrice * lpRate) / (10 ** 30);
+    }
+
+    function decimals() external pure virtual returns (uint8) {
+        return 18;
+    }
+}

package/deployments/1-markets/BALANCER-LP-AURA-BBAWETHSWETH-SEP-26-2024.json

@@ -0,0 +1,10 @@
+{
+    "name": "SY swETH-BbAWeth_BalancerLP Aura",
+    "SY": "0xCb611D0BD02a74C491B75d51D6EA5558f1887Da3",
+    "YT": "0x9ddc69eB24329365e96Cdca508e37dDf1CD4478d",
+    "PT": "0xe82db015E01E93381991d14b5bAA30fE73bb3240",
+    "market": "0x8225dD26DdFaaa321E5388e0F4C090Ba16217c21",
+    "expiry": 1727308800,
+    "scalarRoot": "47978000000000000000",
+    "initAnchor": "1074162000000000000"
+}

package/deployments/1-markets/STETH-DEC2027.json

@@ -0,0 +1,10 @@
+{
+    "name": "SY stETH",
+    "SY": "0xcbC72d92b2dc8187414F6734718563898740C0BC",
+    "YT": "0x04B7Fa1e727d7290D6E24fA9b426d0c940283a95",
+    "PT": "0xb253Eff1104802b97aC7E3aC9FdD73AecE295a2c",
+    "market": "0x34280882267ffa6383B363E278B027Be083bBe3b",
+    "expiry": 1830124800,
+    "scalarRoot": "86364560000000000000",
+    "initAnchor": "1262028000000000000"
+}