@pendle/core-v2 3.0.0-beta-10 → 3.0.0

package/contracts/interfaces/IPActionMiscV3.sol

@@ -1,120 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.0;
-
-import "../router/base/MarketApproxLib.sol";
-import "./IPAllActionTypeV3.sol";
-
-interface IPActionMiscV3 {
-    struct Call3 {
-        bool allowFailure;
-        bytes callData;
-    }
-
-    struct Result {
-        bool success;
-        bytes returnData;
-    }
-
-    event MintSyFromToken(
-        address indexed caller,
-        address indexed tokenIn,
-        address indexed SY,
-        address receiver,
-        uint256 netTokenIn,
-        uint256 netSyOut
-    );
-
-    event RedeemSyToToken(
-        address indexed caller,
-        address indexed tokenOut,
-        address indexed SY,
-        address receiver,
-        uint256 netSyIn,
-        uint256 netTokenOut
-    );
-
-    event MintPyFromSy(
-        address indexed caller, address indexed receiver, address indexed YT, uint256 netSyIn, uint256 netPyOut
-    );
-
-    event RedeemPyToSy(
-        address indexed caller, address indexed receiver, address indexed YT, uint256 netPyIn, uint256 netSyOut
-    );
-
-    event MintPyFromToken(
-        address indexed caller,
-        address indexed tokenIn,
-        address indexed YT,
-        address receiver,
-        uint256 netTokenIn,
-        uint256 netPyOut,
-        uint256 netSyInterm
-    );
-
-    event RedeemPyToToken(
-        address indexed caller,
-        address indexed tokenOut,
-        address indexed YT,
-        address receiver,
-        uint256 netPyIn,
-        uint256 netTokenOut,
-        uint256 netSyInterm
-    );
-
-    function mintSyFromToken(address receiver, address SY, uint256 minSyOut, TokenInput calldata input)
-        external
-        payable
-        returns (uint256 netSyOut);
-
-    function redeemSyToToken(address receiver, address SY, uint256 netSyIn, TokenOutput calldata output)
-        external
-        returns (uint256 netTokenOut);
-
-    function mintPyFromToken(address receiver, address YT, uint256 minPyOut, TokenInput calldata input)
-        external
-        payable
-        returns (uint256 netPyOut, uint256 netSyInterm);
-
-    function redeemPyToToken(address receiver, address YT, uint256 netPyIn, TokenOutput calldata output)
-        external
-        returns (uint256 netTokenOut, uint256 netSyInterm);
-
-    function mintPyFromSy(address receiver, address YT, uint256 netSyIn, uint256 minPyOut)
-        external
-        returns (uint256 netPyOut);
-
-    function redeemPyToSy(address receiver, address YT, uint256 netPyIn, uint256 minSyOut)
-        external
-        returns (uint256 netSyOut);
-
-    function redeemDueInterestAndRewards(
-        address user,
-        address[] calldata sys,
-        address[] calldata yts,
-        address[] calldata markets
-    ) external;
-
-    function swapTokenToToken(address receiver, uint256 minTokenOut, TokenInput calldata inp)
-        external
-        payable
-        returns (uint256 netTokenOut);
-
-    function swapTokenToTokenViaSy(
-        address receiver,
-        address SY,
-        TokenInput calldata input,
-        address tokenRedeemSy,
-        uint256 minTokenOut
-    ) external payable returns (uint256 netTokenOut, uint256 netSyInterm);
-
-    function boostMarkets(address[] memory markets) external;
-
-    function multicall(Call3[] calldata calls) external payable returns (Result[] memory res);
-
-    function multicallRevert(uint256 gasLimit, bytes[] calldata callDatas)
-        external
-        payable
-        returns (bytes[] memory res, uint256[] memory gasUsed);
-
-    function callThenRevert(bytes memory callData) external payable;
-}

package/contracts/interfaces/IPAllActionTypeV3.sol

@@ -1,33 +0,0 @@
-// 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;
-}

package/contracts/interfaces/IPAllActionV3.sol

@@ -1,19 +0,0 @@
-// 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 "./IPMarketSwapCallback.sol";
-import "./IDiamondLoupe.sol";
-
-interface IPAllActionV3 is
-    IPActionAddRemoveLiqV3,
-    IPActionSwapPTV3,
-    IPActionSwapYTV3,
-    IPActionMiscV3,
-    IPMarketSwapCallback,
-    IDiamondLoupe
-{}

package/contracts/interfaces/IPLimitRouter.sol

@@ -1,149 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.0;
-
-import "../core/StandardizedYield/PYIndex.sol";
-
-interface IPOrderMixinType {
-    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 NormalResults {
-        uint256 totalMaking;
-        uint256 totalTaking;
-        uint256 totalFee;
-        uint256 totalNotionalVolume;
-        uint256[] netMakings;
-        uint256[] netTakings;
-        uint256[] netFees;
-        uint256[] notionalVolumes;
-    }
-}
-
-struct Order {
-    uint256 salt;
-    uint256 expiry;
-    uint256 nonce;
-    IPOrderMixinType.OrderType orderType;
-    address token;
-    address YT;
-    address maker;
-    address receiver;
-    uint256 makingAmount;
-    uint256 lnImpliedRate;
-    uint256 failSafeRate;
-    bytes permit; // On first fill: permit.1.call(abi.encodePacked(permit.selector, permit.2))
-}
-
-struct FillOrderParams {
-    Order order;
-    bytes signature;
-    uint256 makingAmount;
-}
-
-interface IPOrderMixin is IPOrderMixinType {
-    struct OrderStatus {
-        uint128 filledAmount;
-        uint128 remaining;
-    }
-
-    event OrderCanceled(address indexed maker, bytes32 indexed orderHash);
-
-    event OrderFilled(
-        bytes32 indexed orderHash,
-        OrderType indexed orderType,
-        address indexed YT,
-        address token,
-        uint256 netInputFromMaker,
-        uint256 netOutputToMaker,
-        uint256 feeAmount,
-        uint256 notionalVolume
-    );
-
-    /**
-     * (making, taking)
-     * SY_FOR_PT: (SY, PT)
-     * PT_FOR_SY: (PT, SY)
-     * 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);
-
-    /**
-     * (output, input)
-     * SY_FOR_PT: (YT, SY)
-     * PT_FOR_SY: (SY, YT)
-     * 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);
-
-    function feeRecipient() external view returns (address);
-
-    function lnFeeRateRoot() external view returns (uint96);
-
-    function hashOrder(Order memory order) external view returns (bytes32);
-}
-
-interface ILimitOrderCallee is IPOrderMixinType {
-    /// Refer to normalFill
-    function normalFillCall(
-        OrderType orderType,
-        uint256 actualMaking,
-        uint256 actualTaking,
-        uint256 totalFee,
-        bytes memory data
-    ) external;
-
-    /// Refer to flashFill
-    function flashFillCall(
-        OrderType orderType,
-        uint256 netOutputToTaker,
-        uint256 netInputFromTaker,
-        uint256 totalFee,
-        bytes memory data
-    ) external;
-}
-
-interface IPLimitRouter is IPOrderMixin {
-    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);
-}

package/contracts/limit/LimitMathCore.sol

@@ -1,231 +0,0 @@
-// 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 calcNormalBatch(FillOrderParams[] memory params, address YT, uint256 lnFeeRateRoot)
-        internal
-        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, uint256) calcNormal,) =
-            getCalcFunctions(params[0].order.orderType);
-
-        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, timeToExpiry);
-
-            out.netMakings[i] = param.makingAmount;
-            (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 calcSyForPtNormal(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)
-        // 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, 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, 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, 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
-    function calcSyForPtFlash(uint256 makeSy, uint256 takePt, uint256 fee, PYIndex index)
-        internal
-        pure
-        returns (uint256 syFromTaker, uint256 ytToTaker)
-    {
-        uint256 syToMintPy = index.assetToSyUp(takePt);
-
-        syFromTaker = syToMintPy - (makeSy - fee);
-        ytToTaker = takePt;
-    }
-
-    function calcPtForSyFlash(uint256 makePt, uint256 takeSy, uint256 fee, PYIndex index)
-        internal
-        pure
-        returns (uint256 ytFromTaker, uint256 syToTaker)
-    {
-        uint256 syRedeemFromPy = index.assetToSy(makePt);
-        syToTaker = syRedeemFromPy - (takeSy + fee);
-
-        ytFromTaker = makePt;
-    }
-
-    function calcSyForYtFlash(uint256 makeSy, uint256 takeYt, uint256 fee, PYIndex index)
-        internal
-        pure
-        returns (uint256 syFromTaker, uint256 ptToTaker)
-    {
-        uint256 syToMintPy = index.assetToSyUp(takeYt);
-
-        syFromTaker = syToMintPy - (makeSy - fee);
-        ptToTaker = takeYt;
-    }
-
-    function calcYtForSyFlash(uint256 makeYt, uint256 takeSy, uint256 fee, PYIndex index)
-        internal
-        pure
-        returns (uint256 ptFromTaker, uint256 syToTaker)
-    {
-        uint256 syRedeemFromPy = index.assetToSy(makeYt);
-
-        syToTaker = syRedeemFromPy - (takeSy + fee);
-        ptFromTaker = makeYt;
-    }
-
-    function impliedRateToExchangeRate(uint256 lnRate, uint256 timeToExpiry) internal pure returns (uint256) {
-        return MarketMathCore._getExchangeRateFromImpliedRate(lnRate, timeToExpiry).Uint();
-    }
-
-    function inc1(uint256 i) internal pure returns (uint256) {
-        unchecked {
-            return i + 1;
-        }
-    }
-
-    /// @dev diff sig for calcNormal and calcFlash to avoid miscalling
-    function getCalcFunctions(IPOrderMixinType.OrderType t)
-        internal
-        pure
-        returns (
-            function (uint256, uint256, PYIndex, uint256) internal pure returns (uint256, uint256, uint256) calcNormal,
-            function (uint256, uint256, uint256, PYIndex) internal pure returns (uint256, uint256) calcFlash
-        )
-    {
-        if (t == IPOrderMixinType.OrderType.SY_FOR_PT) {
-            return (calcSyForPtNormal, calcSyForPtFlash);
-        } else if (t == IPOrderMixinType.OrderType.PT_FOR_SY) {
-            return (calcPtForSyNormal, calcPtForSyFlash);
-        } else if (t == IPOrderMixinType.OrderType.SY_FOR_YT) {
-            return (calcSyForYtNormal, calcSyForYtFlash);
-        } else {
-            return (calcYtForSyNormal, calcYtForSyFlash);
-        }
-    }
-}
-
-/*
-Proof of index.syToAsset(index.assetToSyUp(x)) >= x
-
-let y = index.assetToSyUp(x)
-=> y <= (x+index-1) * 1e18  / index < y+1 (since floor of the division == y)
-=> (x+index-1) * 1e18  / index < y+1
-=> x+index-1 < (y+1) * index / 1e18
-=> x < (y+1) * index / 1e18 - index + 1
-
-=> x < y * index / 1e18 + index / 1e18 - index + 1
-It's obvious that "index / 1e18 - index + 1" < 0 as long as index >= 2
-
-=> y * index / 1e18 + index / 1e18 - index + 1 <= y * index / 1e18
-=> x <= y * index / 1e18
-*/

package/contracts/limit/PendleLimitRouter.sol

@@ -1,67 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.17;
-
-import "./PendleOrderMixin.sol";
-import "./helpers/NonceManager.sol";
-import "../core/libraries/TokenHelper.sol";
-import "../interfaces/IAddressProvider.sol";
-
-contract PendleLimitRouter is PendleOrderMixin, IPLimitRouter {
-    using ArgumentsDecoder for bytes;
-    using Address for address;
-
-    constructor(address _WNATIVE) PendleOrderMixin(_WNATIVE) {
-        _disableInitializers();
-    }
-
-    /// @notice Cancels multiple orders by setting remaining amount to zero
-    function cancelBatch(Order[] calldata orders) external {
-        for (uint256 i = 0; i < orders.length; ++i) {
-            cancelSingle(orders[i]);
-        }
-    }
-
-    /// @notice Cancels order by setting remaining amount to zero
-    function cancelSingle(Order calldata order) public {
-        require(order.maker == msg.sender, "LOP: Access denied");
-
-        bytes32 orderHash = hashOrder(order);
-        require(_status[orderHash].remaining != _ORDER_FILLED, "LOP: already filled");
-        _status[orderHash].remaining = _ORDER_FILLED;
-
-        emit OrderCanceled(msg.sender, orderHash);
-    }
-
-    function orderStatusesRaw(bytes32[] memory orderHashes)
-        public
-        view
-        returns (uint256[] memory remainingsRaw, uint256[] memory filledAmounts)
-    {
-        uint256 len = orderHashes.length;
-        remainingsRaw = new uint256[](len);
-        filledAmounts = new uint256[](len);
-
-        for (uint256 i = 0; i < len; i++) {
-            OrderStatus memory status = _status[orderHashes[i]];
-            (remainingsRaw[i], filledAmounts[i]) = (status.remaining, status.filledAmount);
-        }
-    }
-
-    function orderStatuses(bytes32[] memory orderHashes)
-        external
-        view
-        returns (uint256[] memory remainings, uint256[] memory filledAmounts)
-    {
-        (remainings, filledAmounts) = orderStatusesRaw(orderHashes);
-        for (uint256 i = 0; i < remainings.length; i++) {
-            require(remainings[i] != _ORDER_DOES_NOT_EXIST, "LOP: Unknown order");
-            unchecked {
-                remainings[i] -= 1;
-            }
-        }
-    }
-
-    function DOMAIN_SEPARATOR() external view returns (bytes32) {
-        return _domainSeparatorV4();
-    }
-}