@pendle/core-v2 3.0.0-beta-2 → 3.0.0-beta-3

package/contracts/interfaces/IPActionMisc.sol

@@ -97,14 +97,21 @@ interface IPActionMisc {
         address[] calldata markets
     ) external;
 
+    function swapTokenToToken(address receiver, uint256 minTokenOut, TokenInput calldata inp)
+        external
+        payable
+        returns (uint256 netTokenOut);
+
     function approveInf(MultiApproval[] calldata) external;
 
+    function marketsBoost(address[] memory markets) external;
+
     function multicall(Call3[] calldata calls) external payable returns (Result[] memory returnData);
 
-    function multicallRevert(uint256 gasLimit, Call3[] calldata calls)
+    function multicallRevert(uint256 gasLimit, bytes[] calldata callDatas)
         external
         payable
         returns (bytes[] memory res, uint256[] memory gasUsed);
 
-    function callThenRevert(address target, bytes memory callData) external payable;
+    function callThenRevert(bytes memory callData) external payable;
 }

package/contracts/interfaces/IPLimitRouter.sol

@@ -23,22 +23,18 @@ interface IPOrderMixinType {
         address receiver;
         uint256 makingAmount;
         uint256 lnImpliedRate;
+        uint256 failSafeRate;
     }
 
     struct NormalResults {
         uint256 totalMaking;
         uint256 totalTaking;
         uint256 totalFee;
+        uint256 totalNotionalVolume;
         uint256[] netMakings;
         uint256[] netTakings;
         uint256[] netFees;
-    }
-
-    struct OnchainParams {
-        uint256 timeToExpiry;
-        uint256 pyIndex;
-        address feeRecipient;
-        uint256 lnFeeRateRoot;
+        uint256[] notionalVolumes;
     }
 }
 
@@ -53,6 +49,7 @@ struct Order {
     address receiver;
     uint256 makingAmount;
     uint256 lnImpliedRate;
+    uint256 failSafeRate;
     bytes permit; // On first fill: permit.1.call(abi.encodePacked(permit.selector, permit.2))
 }
 
@@ -63,30 +60,17 @@ struct FillOrderParams {
 }
 
 interface IPOrderMixin is IPOrderMixinType {
-    event OrderCanceled(address indexed maker, bytes32 indexed orderHash, uint256 remaining);
+    event OrderCanceled(address indexed maker, bytes32 indexed orderHash);
 
-    event OrderRemainingUpdated(bytes32 indexed orderHash, uint256 remaining);
-
-    event NormalFill(
+    event OrderFilled(
+        bytes32 indexed orderHash,
         OrderType indexed orderType,
         address indexed YT,
-        address indexed taker,
-        uint256 actualMaking,
-        uint256 actualTaking,
-        uint256 totalFee,
-        uint256 rawTotalMaking,
-        uint256 rawTotalTaking
-    );
-
-    event FlashFill(
-        OrderType indexed orderType,
-        address indexed YT,
-        address indexed taker,
-        uint256 netOutputToTaker,
-        uint256 netInputFromTaker,
-        uint256 totalFee,
-        uint256 rawTotalMaking,
-        uint256 rawTotalTaking
+        address token,
+        uint256 netInputFromMaker,
+        uint256 netOutputToMaker,
+        uint256 feeAmount,
+        uint256 notionalVolume
     );
 
     /**
@@ -96,6 +80,7 @@ interface IPOrderMixin is IPOrderMixinType {
      * SY_FOR_YT: (SY, YT)
      * YT_FOR_SY: (YT, SY)
      */
+    // @dev actualMaking, actualTaking are in the SY form
     function normalFill(FillOrderParams[] memory params, address receiver, uint256 maxTaking, bytes calldata callback)
         external
         returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee);
@@ -107,6 +92,8 @@ interface IPOrderMixin is IPOrderMixinType {
      * SY_FOR_YT: (PT, SY)
      * YT_FOR_SY: (SY, PT)
      */
+
+    // @dev netOutputToTaker, netInputFromTaker are in the SY form
     function flashFill(FillOrderParams[] memory params, address receiver, uint256 maxInput, bytes calldata callback)
         external
         returns (uint256 netOutputToTaker, uint256 netInputFromTaker, uint256 totalFee);
@@ -116,8 +103,6 @@ interface IPOrderMixin is IPOrderMixinType {
     function lnFeeRateRoot() external view returns (uint96);
 
     function hashOrder(Order memory order) external view returns (bytes32);
-
-    function getOnchainParams(address YT) external returns (OnchainParams memory);
 }
 
 interface ILimitOrderCallee is IPOrderMixinType {

package/contracts/limit/LimitMathCore.sol

@@ -12,107 +12,130 @@ library LimitMathCore {
     using PMath for uint256;
     using PMath for int256;
 
-    function calcNormalBatch(FillOrderParams[] memory params, IPOrderMixinType.OnchainParams memory on)
+    function calcNormalBatch(FillOrderParams[] memory params, address YT, uint256 lnFeeRateRoot)
         internal
-        pure
         returns (IPOrderMixinType.NormalResults memory out)
     {
+        return calcNormalBatch(
+            params, IPYieldToken(YT).expiry() - block.timestamp, IPYieldToken(YT).pyIndexCurrent(), lnFeeRateRoot
+        );
+    }
+
+    function calcFlashBatch(FillOrderParams[] memory params, address YT, uint256 lnFeeRateRoot)
+        internal
+        returns (
+            uint256 netInputFromTaker,
+            uint256 netOutputToTaker,
+            uint256 netFee,
+            IPOrderMixinType.NormalResults memory out
+        )
+    {
+        (, function (uint256, uint256, uint256, PYIndex) internal pure returns (uint256, uint256) calcFlash) =
+            getCalcFunctions(params[0].order.orderType);
+
+        uint256 timeToExpiry = IPYieldToken(YT).expiry() - block.timestamp;
+        uint256 pyIndex = IPYieldToken(YT).pyIndexCurrent();
+
+        out = calcNormalBatch(params, timeToExpiry, pyIndex, lnFeeRateRoot);
+        (netInputFromTaker, netOutputToTaker) =
+            calcFlash(out.totalMaking, out.totalTaking, out.totalFee, PYIndex.wrap(pyIndex));
+        netFee = out.totalFee;
+    }
+
+    // --- PURE FUNCTIONS ---
+    function calcNormalBatch(
+        FillOrderParams[] memory params,
+        uint256 timeToExpiry,
+        uint256 pyIndex,
+        uint256 lnFeeRateRoot
+    ) internal pure returns (IPOrderMixinType.NormalResults 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) calcNormal,) =
+        (function (uint256, uint256, PYIndex, uint256) internal pure returns (uint256, uint256, uint256) calcNormal,) =
             getCalcFunctions(params[0].order.orderType);
 
-        uint256 feeRate = impliedRateToExchangeRate(on.lnFeeRateRoot, on.timeToExpiry);
+        uint256 feeRate = impliedRateToExchangeRate(lnFeeRateRoot, timeToExpiry);
 
         for (uint256 i = 0; i < len; i = inc1(i)) {
             FillOrderParams memory param = params[i];
             if (param.makingAmount == 0) continue; // nothing changes
 
-            uint256 exchangeRate = impliedRateToExchangeRate(param.order.lnImpliedRate, on.timeToExpiry);
+            uint256 exchangeRate = impliedRateToExchangeRate(param.order.lnImpliedRate, timeToExpiry);
 
             out.netMakings[i] = param.makingAmount;
-            (out.netTakings[i], out.netFees[i]) =
-                calcNormal(out.netMakings[i], exchangeRate, PYIndex.wrap(on.pyIndex), feeRate);
+            (out.netTakings[i], out.netFees[i], out.notionalVolumes[i]) =
+                calcNormal(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 calcFlashBatch(FillOrderParams[] memory params, IPOrderMixinType.OnchainParams memory onchain)
-        internal
-        pure
-        returns (
-            uint256 netInputFromTaker,
-            uint256 netOutputToTaker,
-            uint256 netFee,
-            IPOrderMixinType.NormalResults memory out
-        )
-    {
-        (, function (uint256, uint256, uint256, PYIndex) internal pure returns (uint256, uint256) calcFlash) =
-            getCalcFunctions(params[0].order.orderType);
-
-        out = calcNormalBatch(params, onchain);
-        (netInputFromTaker, netOutputToTaker) =
-            calcFlash(out.totalMaking, out.totalTaking, out.totalFee, PYIndex.wrap(onchain.pyIndex));
-        netFee = out.totalFee;
-    }
-
     function calcSyForPtNormal(uint256 makeSy, uint256 r, PYIndex index, uint256 f)
         internal
         pure
-        returns (uint256 takePt, uint256 fee)
+        returns (uint256 takePt, uint256 fee, uint256 notionalVolume)
     {
         // takePt = makeSy * index * r
         // fee = makeSy * (f - 1)
+        // notionalVolume = makeSy
 
         takePt = index.syToAsset(makeSy).mulDown(r);
         fee = makeSy.mulDown(f - PMath.ONE);
+        notionalVolume = makeSy;
     }
 
     function calcPtForSyNormal(uint256 makePt, uint256 r, PYIndex index, uint256 f)
         internal
         pure
-        returns (uint256 takeSy, uint256 fee)
+        returns (uint256 takeSy, uint256 fee, uint256 notionalVolume)
     {
         // takeAsset = make / r
         // takeSy = takeAsset / index
         // fee = takeSy * (f-1)/f
+        // notionalVolume = takeSy
 
         takeSy = index.assetToSyUp(makePt.divDown(r));
         fee = takeSy * (f - PMath.ONE) / f;
+        notionalVolume = takeSy;
     }
 
     function calcSyForYtNormal(uint256 makeSy, uint256 r, PYIndex index, uint256 f)
         internal
         pure
-        returns (uint256 takeYt, uint256 fee)
+        returns (uint256 takeYt, uint256 fee, uint256 notionalVolume)
     {
         // pt = makeSy * index * r
         // yt = pt / (r-1)
         // fee = makeSy * ((f-1) / f) / (r-1)
+        // notionalVolume = makeSy / (r-1)
 
         takeYt = index.syToAssetUp(makeSy) * r / (r - PMath.ONE);
         fee = (makeSy * (f - PMath.ONE) / f).divDown(r - PMath.ONE);
+        notionalVolume = makeSy.divDown(r - PMath.ONE);
     }
 
     function calcYtForSyNormal(uint256 makeYt, uint256 r, PYIndex index, uint256 f)
         internal
         pure
-        returns (uint256 takeSy, uint256 fee)
+        returns (uint256 takeSy, uint256 fee, uint256 notionalVolume)
     {
         // pt = yt * (r-1)
         // takeSy = pt / r / index
         // feeSy = takeSy * (f-1) / (r-1)
+        // notionalVolume = takeSy / (r-1)
 
         takeSy = index.assetToSyUp(makeYt * (r - PMath.ONE) / r);
         fee = takeSy * (f - PMath.ONE) / (r - PMath.ONE);
+        notionalVolume = takeSy.divDown(r - PMath.ONE);
     }
 
     // Proof of index.syToAsset(index.assetToSyUp(takePt)) >= takePt at end of this file
@@ -175,7 +198,7 @@ library LimitMathCore {
         internal
         pure
         returns (
-            function (uint256, uint256, PYIndex, uint256) internal pure returns (uint256, uint256) calcNormal,
+            function (uint256, uint256, PYIndex, uint256) internal pure returns (uint256, uint256, uint256) calcNormal,
             function (uint256, uint256, uint256, PYIndex) internal pure returns (uint256, uint256) calcFlash
         )
     {

package/contracts/limit/PendleLimitRouter.sol

@@ -39,10 +39,10 @@ contract PendleLimitRouter is PendleOrderMixin, IPLimitRouter {
         require(order.maker == msg.sender, "LOP: Access denied");
 
         bytes32 orderHash = hashOrder(order);
-        uint256 orderRemaining = _remaining[orderHash];
-        require(orderRemaining != _ORDER_FILLED, "LOP: already filled");
-        emit OrderCanceled(msg.sender, orderHash, orderRemaining);
+        require(_remaining[orderHash] != _ORDER_FILLED, "LOP: already filled");
         _remaining[orderHash] = _ORDER_FILLED;
+
+        emit OrderCanceled(msg.sender, orderHash);
     }
 
     function remaining(bytes32 orderHash) external view returns (uint256) {