@pendle/core-v2 3.0.0 → 4.0.1

package/contracts/interfaces/{IPActionSwapPT.sol → IPActionSwapPTV3.sol}

@@ -2,9 +2,9 @@
 pragma solidity ^0.8.0;
 
 import "../router/base/MarketApproxLib.sol";
-import "../router/base/ActionBaseMintRedeem.sol";
+import "./IPAllActionTypeV3.sol";
 
-interface IPActionSwapPT {
+interface IPActionSwapPTV3 {
     event SwapPtAndSy(
         address indexed caller,
         address indexed market,
@@ -19,51 +19,41 @@ interface IPActionSwapPT {
         address indexed token,
         address receiver,
         int256 netPtToAccount,
-        int256 netTokenToAccount
+        int256 netTokenToAccount,
+        uint256 netSyInterm
     );
 
-    function swapExactPtForSy(
-        address receiver,
-        address market,
-        uint256 exactPtIn,
-        uint256 minSyOut
-    ) external returns (uint256 netSyOut, uint256 netSyFee);
-
-    function swapPtForExactSy(
-        address receiver,
-        address market,
-        uint256 exactSyOut,
-        uint256 maxPtIn,
-        ApproxParams calldata guessPtIn
-    ) external returns (uint256 netPtIn, uint256 netSyFee);
-
-    function swapSyForExactPt(
+    function swapExactTokenForPt(
         address receiver,
         address market,
-        uint256 exactPtOut,
-        uint256 maxSyIn
-    ) external returns (uint256 netSyIn, uint256 netSyFee);
+        uint256 minPtOut,
+        ApproxParams calldata guessPtOut,
+        TokenInput calldata input,
+        LimitOrderData calldata limit
+    ) external payable returns (uint256 netPtOut, uint256 netSyFee, uint256 netSyInterm);
 
     function swapExactSyForPt(
         address receiver,
         address market,
         uint256 exactSyIn,
         uint256 minPtOut,
-        ApproxParams calldata guessPtOut
+        ApproxParams calldata guessPtOut,
+        LimitOrderData calldata limit
     ) external returns (uint256 netPtOut, uint256 netSyFee);
 
-    function swapExactTokenForPt(
+    function swapExactPtForToken(
         address receiver,
         address market,
-        uint256 minPtOut,
-        ApproxParams calldata guessPtOut,
-        TokenInput calldata input
-    ) external payable returns (uint256 netPtOut, uint256 netSyFee);
+        uint256 exactPtIn,
+        TokenOutput calldata output,
+        LimitOrderData calldata limit
+    ) external returns (uint256 netTokenOut, uint256 netSyFee, uint256 netSyInterm);
 
-    function swapExactPtForToken(
+    function swapExactPtForSy(
         address receiver,
         address market,
         uint256 exactPtIn,
-        TokenOutput calldata output
-    ) external returns (uint256 netTokenOut, uint256 netSyFee);
+        uint256 minSyOut,
+        LimitOrderData calldata limit
+    ) external returns (uint256 netSyOut, uint256 netSyFee);
 }

package/contracts/interfaces/{IPActionSwapYT.sol → IPActionSwapYTV3.sol}

@@ -2,9 +2,9 @@
 pragma solidity ^0.8.0;
 
 import "../router/base/MarketApproxLib.sol";
-import "../router/base/ActionBaseMintRedeem.sol";
+import "./IPAllActionTypeV3.sol";
 
-interface IPActionSwapYT {
+interface IPActionSwapYTV3 {
     event SwapYtAndSy(
         address indexed caller,
         address indexed market,
@@ -19,7 +19,8 @@ interface IPActionSwapYT {
         address indexed token,
         address receiver,
         int256 netYtToAccount,
-        int256 netTokenToAccount
+        int256 netTokenToAccount,
+        uint256 netSyInterm
     );
 
     event SwapPtAndYt(
@@ -30,50 +31,39 @@ interface IPActionSwapYT {
         int256 netYtToAccount
     );
 
+    function swapExactTokenForYt(
+        address receiver,
+        address market,
+        uint256 minYtOut,
+        ApproxParams calldata guessYtOut,
+        TokenInput calldata input,
+        LimitOrderData calldata limit
+    ) external payable returns (uint256 netYtOut, uint256 netSyFee, uint256 netSyInterm);
+
     function swapExactSyForYt(
         address receiver,
         address market,
         uint256 exactSyIn,
         uint256 minYtOut,
-        ApproxParams calldata guessYtOut
+        ApproxParams calldata guessYtOut,
+        LimitOrderData calldata limit
     ) external returns (uint256 netYtOut, uint256 netSyFee);
 
-    function swapExactYtForSy(
+    function swapExactYtForToken(
         address receiver,
         address market,
         uint256 exactYtIn,
-        uint256 minSyOut
-    ) external returns (uint256 netSyOut, uint256 netSyFee);
-
-    function swapSyForExactYt(
-        address receiver,
-        address market,
-        uint256 exactYtOut,
-        uint256 maxSyIn
-    ) external returns (uint256 netSyIn, uint256 netSyFee);
+        TokenOutput calldata output,
+        LimitOrderData calldata limit
+    ) external returns (uint256 netTokenOut, uint256 netSyFee, uint256 netSyInterm);
 
-    function swapYtForExactSy(
-        address receiver,
-        address market,
-        uint256 exactSyOut,
-        uint256 maxYtIn,
-        ApproxParams calldata guessYtIn
-    ) external returns (uint256 netYtIn, uint256 netSyFee);
-
-    function swapExactTokenForYt(
-        address receiver,
-        address market,
-        uint256 minYtOut,
-        ApproxParams calldata guessYtOut,
-        TokenInput calldata input
-    ) external payable returns (uint256 netYtOut, uint256 netSyFee);
-
-    function swapExactYtForToken(
+    function swapExactYtForSy(
         address receiver,
         address market,
-        uint256 netYtIn,
-        TokenOutput calldata output
-    ) external returns (uint256 netTokenOut, uint256 netSyFee);
+        uint256 exactYtIn,
+        uint256 minSyOut,
+        LimitOrderData calldata limit
+    ) external returns (uint256 netSyOut, uint256 netSyFee);
 
     function swapExactPtForYt(
         address receiver,
@@ -88,6 +78,6 @@ interface IPActionSwapYT {
         address market,
         uint256 exactYtIn,
         uint256 minPtOut,
-        ApproxParams calldata guessTotalPtSwapped
+        ApproxParams calldata guessTotalPtFromSwap
     ) external returns (uint256 netPtOut, uint256 netSyFee);
 }

package/contracts/interfaces/IPAllActionTypeV3.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.0;
+
+import "../router/swap-aggregator/IPSwapAggregator.sol";
+import "./IPLimitRouter.sol";
+
+struct TokenInput {
+    // Token/Sy data
+    address tokenIn;
+    uint256 netTokenIn;
+    address tokenMintSy;
+    // aggregator data
+    address pendleSwap;
+    SwapData swapData;
+}
+
+struct TokenOutput {
+    // Token/Sy data
+    address tokenOut;
+    uint256 minTokenOut;
+    address tokenRedeemSy;
+    // aggregator data
+    address pendleSwap;
+    SwapData swapData;
+}
+
+struct LimitOrderData {
+    address limitRouter;
+    uint256 epsSkipMarket; // only used for swap operations, will be ignored otherwise
+    FillOrderParams[] normalFills;
+    FillOrderParams[] flashFills;
+    bytes optData;
+}

package/contracts/interfaces/IPAllActionV3.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.0;
+
+import "./IPActionAddRemoveLiqV3.sol";
+import "./IPActionSwapPTV3.sol";
+import "./IPActionSwapYTV3.sol";
+import "./IPActionMiscV3.sol";
+import "./IPActionCallbackV3.sol";
+import "./IDiamondLoupe.sol";
+
+interface IPAllActionV3 is
+    IPActionAddRemoveLiqV3,
+    IPActionSwapPTV3,
+    IPActionSwapYTV3,
+    IPActionMiscV3,
+    IPActionCallbackV3,
+    IDiamondLoupe
+{}

package/contracts/interfaces/IPBulkSeller.sol

@@ -1,7 +1,13 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import "../core/BulkSeller/BulkSellerMathCore.sol";
+struct BulkSellerState {
+    uint256 rateTokenToSy;
+    uint256 rateSyToToken;
+    uint256 totalToken;
+    uint256 totalSy;
+    uint256 feeRate;
+}
 
 interface IPBulkSeller {
     event SwapExactTokenForSy(address receiver, uint256 netTokenIn, uint256 netSyOut);

package/contracts/interfaces/IPLimitRouter.sol

@@ -0,0 +1,120 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "../core/StandardizedYield/PYIndex.sol";
+
+interface IPLimitOrderType {
+    enum OrderType {
+        SY_FOR_PT,
+        PT_FOR_SY,
+        SY_FOR_YT,
+        YT_FOR_SY
+    }
+
+    // Fixed-size order part with core information
+    struct StaticOrder {
+        uint256 salt;
+        uint256 expiry;
+        uint256 nonce;
+        OrderType orderType;
+        address token;
+        address YT;
+        address maker;
+        address receiver;
+        uint256 makingAmount;
+        uint256 lnImpliedRate;
+        uint256 failSafeRate;
+    }
+
+    struct FillResults {
+        uint256 totalMaking;
+        uint256 totalTaking;
+        uint256 totalFee;
+        uint256 totalNotionalVolume;
+        uint256[] netMakings;
+        uint256[] netTakings;
+        uint256[] netFees;
+        uint256[] notionalVolumes;
+    }
+}
+
+struct Order {
+    uint256 salt;
+    uint256 expiry;
+    uint256 nonce;
+    IPLimitOrderType.OrderType orderType;
+    address token;
+    address YT;
+    address maker;
+    address receiver;
+    uint256 makingAmount;
+    uint256 lnImpliedRate;
+    uint256 failSafeRate;
+    bytes permit;
+}
+
+struct FillOrderParams {
+    Order order;
+    bytes signature;
+    uint256 makingAmount;
+}
+
+interface IPLimitRouterCallback is IPLimitOrderType {
+    function limitRouterCallback(
+        uint256 actualMaking,
+        uint256 actualTaking,
+        uint256 totalFee,
+        bytes memory data
+    ) external returns (bytes memory);
+}
+
+interface IPLimitRouter is IPLimitOrderType {
+    struct OrderStatus {
+        uint128 filledAmount;
+        uint128 remaining;
+    }
+
+    event OrderCanceled(address indexed maker, bytes32 indexed orderHash);
+
+    event OrderFilledV2(
+        bytes32 indexed orderHash,
+        OrderType indexed orderType,
+        address indexed YT,
+        address token,
+        uint256 netInputFromMaker,
+        uint256 netOutputToMaker,
+        uint256 feeAmount,
+        uint256 notionalVolume,
+        address maker,
+        address taker
+    );
+
+    // @dev actualMaking, actualTaking are in the SY form
+    function fill(
+        FillOrderParams[] memory params,
+        address receiver,
+        uint256 maxTaking,
+        bytes calldata optData,
+        bytes calldata callback
+    ) external returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee, bytes memory callbackReturn);
+
+    function feeRecipient() external view returns (address);
+
+    function hashOrder(Order memory order) external view returns (bytes32);
+
+    function cancelSingle(Order calldata order) external;
+
+    function cancelBatch(Order[] calldata orders) external;
+
+    function orderStatusesRaw(
+        bytes32[] memory orderHashes
+    ) external view returns (uint256[] memory remainingsRaw, uint256[] memory filledAmounts);
+
+    function orderStatuses(
+        bytes32[] memory orderHashes
+    ) external view returns (uint256[] memory remainings, uint256[] memory filledAmounts);
+
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+
+    function simulate(address target, bytes calldata data) external payable;
+}

package/contracts/interfaces/IPRouterHelper.sol

@@ -2,13 +2,13 @@
 pragma solidity ^0.8.0;
 
 import "../router/base/MarketApproxLib.sol";
-import "../router/base/ActionBaseMintRedeem.sol";
+import "../interfaces/IPAllActionTypeV3.sol";
 
 interface IPRouterHelper {
     /**
      * @param output This output struct should be filled the same way as the normal removeLiquiditySingleToken
-     operation (This means all BulkSeller, PendleSwap still works the same way). Note that the
-     output.tokenOut will also be used as the input token for the addLiquidity
+     *  operation (This means PendleSwap still works the same way). Note that the
+     *  output.tokenOut will also be used as the input token for the addLiquidity
      */
     struct RemoveLiquiditySingleTokenStruct {
         address market;
@@ -19,10 +19,10 @@ interface IPRouterHelper {
 
     /**
      * @param guessNetTokenIn the predicted amount of tokenIn that will be used to add liquidity. This
-     should be the same amount that was used to generate guessPtReceivedFromSy (if any).
+     *  should be the same amount that was used to generate guessPtReceivedFromSy (if any).
      * @param guessPtReceivedFromSy the same guess struct in the normal addLiquiditySingleToken operation.
-     Again, note that this struct, if not empty (i.e. if guessOffchain == 0), should be generated
-     using `guessNetTokenIn` amount of tokenIn
+     *  Again, note that this struct, if not empty (i.e. if guessOffchain == 0), should be generated
+     *  using `guessNetTokenIn` amount of tokenIn
      * @dev tokenIn is the output.tokenOut of the removeLiquiditySingleTokenStruct
      */
     struct AddLiquiditySingleTokenStruct {
@@ -30,7 +30,6 @@ interface IPRouterHelper {
         uint256 minLpOut;
         uint256 guessNetTokenIn;
         ApproxParams guessPtReceivedFromSy;
-        address bulk;
     }
 
     /**
@@ -40,7 +39,6 @@ interface IPRouterHelper {
         address market;
         uint256 minLpOut;
         uint256 minYtOut;
-        address bulk;
     }
 
     struct RemoveLiquiditySingleSyStruct {

package/contracts/limit/LimitMathCore.sol

@@ -0,0 +1,158 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import "../interfaces/IPLimitRouter.sol";
+import "../core/Market/MarketMathCore.sol";
+import "../interfaces/IPMarketFactory.sol";
+
+library LimitMathCore {
+    using PYIndexLib for PYIndex;
+    using PYIndexLib for IPYieldToken;
+    using PMath for uint256;
+    using PMath for int256;
+
+    function calcBatch(
+        FillOrderParams[] memory params,
+        address YT,
+        uint256 lnFeeRateRoot
+    ) internal returns (IPLimitOrderType.FillResults memory out) {
+        return
+            calcBatch(
+                params,
+                IPYieldToken(YT).expiry() - block.timestamp,
+                IPYieldToken(YT).pyIndexCurrent(),
+                lnFeeRateRoot
+            );
+    }
+
+    // --- PURE FUNCTIONS ---
+    function calcBatch(
+        FillOrderParams[] memory params,
+        uint256 timeToExpiry,
+        uint256 pyIndex,
+        uint256 lnFeeRateRoot
+    ) internal pure returns (IPLimitOrderType.FillResults memory out) {
+        uint256 len = params.length;
+        out.netMakings = new uint256[](len);
+        out.netTakings = new uint256[](len);
+        out.netFees = new uint256[](len);
+        out.notionalVolumes = new uint256[](len);
+
+        function(uint256, uint256, PYIndex, uint256)
+            internal
+            pure
+            returns (uint256, uint256, uint256) calc = getCalcFunctions(params[0].order.orderType);
+
+        uint256 feeRate = impliedRateToExchangeRate(lnFeeRateRoot, timeToExpiry);
+
+        for (uint256 i = 0; i < len; i++) {
+            FillOrderParams memory param = params[i];
+            if (param.makingAmount == 0) continue; // nothing changes
+
+            uint256 exchangeRate = impliedRateToExchangeRate(param.order.lnImpliedRate, timeToExpiry);
+
+            out.netMakings[i] = param.makingAmount;
+            (out.netTakings[i], out.netFees[i], out.notionalVolumes[i]) = calc(
+                out.netMakings[i],
+                exchangeRate,
+                PYIndex.wrap(pyIndex),
+                feeRate
+            );
+
+            require(out.netTakings[i] > 0, "LOP: can't swap 0 amount");
+
+            out.totalMaking += out.netMakings[i];
+            out.totalTaking += out.netTakings[i];
+            out.totalFee += out.netFees[i];
+            out.totalNotionalVolume += out.notionalVolumes[i];
+        }
+    }
+
+    function calcSyForPt(
+        uint256 makeSy,
+        uint256 r,
+        PYIndex index,
+        uint256 f
+    ) internal pure returns (uint256 takePt, uint256 fee, uint256 notionalVolume) {
+        // takePt = makeSy * index * r
+        // fee = makeSy * (f - 1) / f
+        // notionalVolume = makeSy
+
+        takePt = index.syToAsset(makeSy).mulDown(r);
+        fee = (makeSy * (f - PMath.ONE)) / f;
+        notionalVolume = makeSy;
+    }
+
+    function calcPtForSy(
+        uint256 makePt,
+        uint256 r,
+        PYIndex index,
+        uint256 f
+    ) internal pure returns (uint256 takeSy, uint256 fee, uint256 notionalVolume) {
+        // takeAsset = make / r
+        // takeSy = takeAsset / index
+        // fee = takeSy * (f-1)
+        // notionalVolume = takeSy
+
+        takeSy = index.assetToSy(makePt.divDown(r));
+        fee = takeSy.mulDown(f - PMath.ONE);
+        notionalVolume = takeSy;
+    }
+
+    function calcSyForYt(
+        uint256 makeSy,
+        uint256 r,
+        PYIndex index,
+        uint256 f
+    ) internal pure returns (uint256 takeYt, uint256 fee, uint256 notionalVolume) {
+        // pt = makeSy * index * r
+        // yt = pt / (r-1)
+        // fee = makeSy * (f-1) / (r-1)
+        // notionalVolume = makeSy / (r-1)
+        uint256 pt_yt_ratio = r - PMath.ONE;
+
+        takeYt = (index.syToAsset(makeSy) * r) / pt_yt_ratio;
+        fee = (makeSy * (f - PMath.ONE)) / pt_yt_ratio;
+        notionalVolume = makeSy.divDown(pt_yt_ratio);
+    }
+
+    function calcYtForSy(
+        uint256 makeYt,
+        uint256 r,
+        PYIndex index,
+        uint256 f
+    ) internal pure returns (uint256 takeSy, uint256 fee, uint256 notionalVolume) {
+        // pt = yt * (r-1)
+        // takeSy = pt / r / index
+        // feeSy = takeSy * (f-1) / f / (r-1)
+        // notionalVolume = takeSy / (r-1)
+        uint256 pt_yt_ratio = r - PMath.ONE;
+
+        takeSy = index.assetToSy((makeYt * pt_yt_ratio) / r);
+        fee = ((takeSy * (f - PMath.ONE)) / f).divDown(pt_yt_ratio);
+        notionalVolume = takeSy.divDown(pt_yt_ratio);
+    }
+
+    function impliedRateToExchangeRate(uint256 lnRate, uint256 timeToExpiry) internal pure returns (uint256) {
+        return MarketMathCore._getExchangeRateFromImpliedRate(lnRate, timeToExpiry).Uint();
+    }
+
+    function getCalcFunctions(
+        IPLimitOrderType.OrderType t
+    )
+        internal
+        pure
+        returns (function(uint256, uint256, PYIndex, uint256) internal pure returns (uint256, uint256, uint256) calc)
+    {
+        if (t == IPLimitOrderType.OrderType.SY_FOR_PT) {
+            return (calcSyForPt);
+        } else if (t == IPLimitOrderType.OrderType.PT_FOR_SY) {
+            return (calcPtForSy);
+        } else if (t == IPLimitOrderType.OrderType.SY_FOR_YT) {
+            return (calcSyForYt);
+        } else {
+            return (calcYtForSy);
+        }
+    }
+}