@pendle/core-v2 2.19.0 → 2.19.1-tradingbot

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

@@ -0,0 +1,310 @@
+// 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 MarketApproxPtOutLib 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 = addLiqDual(marketExt, netSyIn - netSyToPt, netYtOut);
+    }
+
+    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 = addLiqDual(marketExt, netSyToAdd, netPtFromSwap);
+        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 = addLiqDual(marketExt, netSyToAdd, netPtToAdd);
+    }
+
+    /// @dev Simulates PendleRouter's removeLiquidityDualSyAndPt then swapExactPtForYt
+    function removeLiqToYt(
+        MarketExtState memory marketExt,
+        uint256 netLpToRemove,
+        ApproxParams memory approxParams
+    ) internal pure returns (uint256 netYtOut, uint256 totalPtToSwap) {
+        (uint256 netSyRemoved, uint256 netPtRemoved) = removeLiqDual(marketExt, netLpToRemove);
+
+        uint256 netYtFromSy = marketExt.index.syToAsset(netSyRemoved);
+        uint256 netPtToSwap = netPtRemoved + netYtFromSy;
+
+        uint256 netYtFromSwap;
+        (netYtFromSwap, totalPtToSwap, ) = marketExt.state.approxSwapExactPtForYt(
+            marketExt.index,
+            netPtToSwap,
+            marketExt.blockTime,
+            clone(approxParams)
+        );
+
+        marketExt.state.swapExactPtForSy(marketExt.index, totalPtToSwap, marketExt.blockTime);
+
+        netYtOut = netYtFromSy + netYtFromSwap;
+    }
+
+    /// @dev Simplified version of MarketMathCore's addLiquidity
+    function addLiqDual(
+        MarketExtState memory marketExt,
+        uint256 netSyIn,
+        uint256 netPtIn
+    ) internal pure returns (uint256 /*netLpOut*/) {
+        require(
+            !MiniHelpers.isExpired(marketExt.state.expiry, marketExt.blockTime),
+            "MarketExtLib: expired market"
+        );
+        require(marketExt.state.totalLp > 0, "MarketExtLib: LP < 0");
+
+        int256 syDesired = netSyIn.Int();
+        int256 ptDesired = netPtIn.Int();
+        int256 lpToAccount;
+        int256 ptUsed;
+        int256 syUsed;
+
+        int256 netLpByPt = (ptDesired * marketExt.state.totalLp) / marketExt.state.totalPt;
+        int256 netLpBySy = (syDesired * marketExt.state.totalLp) / marketExt.state.totalSy;
+        if (netLpByPt < netLpBySy) {
+            lpToAccount = netLpByPt;
+            ptUsed = ptDesired;
+            syUsed = (marketExt.state.totalSy * lpToAccount) / marketExt.state.totalLp;
+        } else {
+            lpToAccount = netLpBySy;
+            syUsed = syDesired;
+            ptUsed = (marketExt.state.totalPt * lpToAccount) / marketExt.state.totalLp;
+        }
+
+        marketExt.state.totalSy += syUsed;
+        marketExt.state.totalPt += ptUsed;
+        marketExt.state.totalLp += lpToAccount;
+
+        return lpToAccount.Uint();
+    }
+
+    /// @dev Simplified version of MarketMathCore's removeLiquidity
+    function removeLiqDual(
+        MarketExtState memory marketExt,
+        uint256 netLpToRemove
+    ) internal pure returns (uint256 /*netSyToAccount*/, uint256 /*netPtToAccount*/) {
+        int256 lpToRemove = netLpToRemove.Int();
+
+        int256 netSyToAccount = (lpToRemove * marketExt.state.totalSy) / marketExt.state.totalLp;
+        int256 netPtToAccount = (lpToRemove * marketExt.state.totalPt) / marketExt.state.totalLp;
+
+        marketExt.state.totalLp = marketExt.state.totalLp.subNoNeg(lpToRemove);
+        marketExt.state.totalPt = marketExt.state.totalPt.subNoNeg(netPtToAccount);
+        marketExt.state.totalSy = marketExt.state.totalSy.subNoNeg(netSyToAccount);
+
+        return (netSyToAccount.Uint(), netPtToAccount.Uint());
+    }
+
+    function swapPtToYt(
+        MarketExtState memory marketExt,
+        uint256 exactPtIn,
+        ApproxParams memory approxParams
+    ) internal pure returns (uint256 netYtOut, uint256 totalPtToSwap) {
+        (netYtOut, totalPtToSwap,) = marketExt.state.approxSwapExactPtForYt(
+            marketExt.index,
+            exactPtIn,
+            marketExt.blockTime,
+            approxParams
+        );
+
+        marketExt.state.swapExactPtForSy(marketExt.index, totalPtToSwap, marketExt.blockTime);
+    }
+
+    function swapYtToPt(
+        MarketExtState memory marketExt,
+        uint256 exactYtIn,
+        ApproxParams memory approxParams
+    ) internal pure returns (uint256 netPtOut, uint256 totalPtSwapped) {
+        (netPtOut, totalPtSwapped,) = marketExt.state.approxSwapExactYtForPt(
+            marketExt.index,
+            exactYtIn,
+            marketExt.blockTime,
+            approxParams
+        );
+
+        marketExt.state.swapSyForExactPt(marketExt.index, totalPtSwapped, marketExt.blockTime);
+    }
+
+    function previewPyToSy(
+        MarketExtState memory marketExt,
+        uint256 netPYToRedeem
+    ) internal pure returns (uint256) {
+        return marketExt.index.assetToSy(netPYToRedeem);
+    }
+
+    /// @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/libraries/SpecSegmentLib.sol

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../../interfaces/TradingBot/IBotDecisionHelper.sol";
+import "../../libraries/math/Math.sol";
+
+library SpecSegmentLib {
+    using Math for uint256;
+    using Math for int256;
+
+    function getSegLength(TradingSpecs memory specs) internal pure returns (uint256) {
+        return (specs.sellYtIy - specs.buyYtIy) / (2 * specs.numOfBins);
+    }
+
+    function getMidIyOfSeg(
+        TradingSpecs memory specs,
+        uint256 segId
+    ) internal pure returns (uint256) {
+        assert(segId != 0 && segId != specs.numOfBins * 2);
+        uint256 length = getSegLength(specs);
+        return specs.buyYtIy + length * (segId - 1) + length / 2;
+    }
+
+    function getSegIdForIy(
+        TradingSpecs memory specs,
+        uint256 iy
+    ) internal pure returns (uint256) {
+        if (iy < specs.buyYtIy) {
+            return 0;
+        }
+        if (iy > specs.sellYtIy) {
+            return 2 * specs.numOfBins + 1;
+        }
+        return (iy - specs.buyYtIy) / getSegLength(specs) + 1;
+    }
+
+    function convertSegIdToBinId(
+        BotState memory botState,
+        uint256 segId
+    ) internal pure returns (int256) {
+        int256 binId = segId.Int() - botState.buyBins.Int();
+        if (binId >= 1) binId--;
+        return binId;
+    }
+
+    function convertBinIdToSegId(
+        BotState memory botState,
+        int256 binId
+    ) internal pure returns (uint256) {
+        assert(binId != 0);
+        if (binId >= 1) binId++;
+        return (binId + botState.buyBins.Int()).Uint();
+    }
+
+    function getBinIdForIy(
+        TradingSpecs memory specs,
+        BotState memory botState,
+        uint256 iy
+    ) internal pure returns (int256) {
+        return convertSegIdToBinId(botState, getSegIdForIy(specs, iy));
+    }
+}

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/IPActionInfoStatic.sol

@@ -1,4 +1,3 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
 interface IPActionInfoStatic {
@@ -29,16 +28,16 @@ interface IPActionInfoStatic {
     function getPY(address py) external view returns (address pt, address yt);
 
     /// can be SY, PY or Market
-    function getTokensInOut(address token)
-        external
-        view
-        returns (address[] memory tokensIn, address[] memory tokensOut);
+    function getTokensInOut(
+        address token
+    ) external view returns (address[] memory tokensIn, address[] memory tokensOut);
 
     function getUserSYInfo(address sy, address user) external returns (UserSYInfo memory res);
 
     function getUserPYInfo(address py, address user) external returns (UserPYInfo memory res);
 
-    function getUserMarketInfo(address market, address user)
-        external
-        returns (UserMarketInfo memory res);
+    function getUserMarketInfo(
+        address market,
+        address user
+    ) external returns (UserMarketInfo memory res);
 }

package/contracts/interfaces/IPActionMarketAuxStatic.sol

@@ -3,15 +3,16 @@ pragma solidity ^0.8.17;
 import "./IPMarket.sol";
 
 interface IPActionMarketAuxStatic {
-    function calcPriceImpactPY(address market, int256 netPtOut) external view returns (uint256);
+    function calcPriceImpactPY(address market, int256 netPtOut) external returns (uint256);
 
-    function calcPriceImpactPt(address market, int256 netPtOut) external view returns (uint256);
+    function calcPriceImpactPt(address market, int256 netPtOut) external returns (uint256);
 
-    function calcPriceImpactYt(address market, int256 netPtOut) external view returns (uint256);
+    function calcPriceImpactYt(address market, int256 netPtOut) external returns (uint256);
 
-    function getMarketState(address market)
+    function getMarketState(
+        address market
+    )
         external
-        view
         returns (
             address pt,
             address yt,
@@ -21,21 +22,13 @@ interface IPActionMarketAuxStatic {
             MarketState memory state
         );
 
-    function getTradeExchangeRateExcludeFee(address market, MarketState memory state)
-        external
-        view
-        returns (uint256);
-
-    function getTradeExchangeRateIncludeFee(address market, int256 netPtOut)
-        external
-        view
-        returns (uint256);
-
-    function getLpToSyRate(address market) external view returns (uint256);
-
-    function getPtToSyRate(address market) external view returns (uint256);
-
-    function getLpToAssetRate(address market) external view returns (uint256);
+    function getTradeExchangeRateExcludeFee(
+        address market,
+        MarketState memory state
+    ) external returns (uint256);
 
-    function getPtToAssetRate(address market) external view returns (uint256);
+    function getTradeExchangeRateIncludeFee(
+        address market,
+        int256 netPtOut
+    ) external returns (uint256);
 }