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

package/contracts/limit/PendleOrderMixin.sol

@@ -1,533 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity ^0.8.17;
-
-import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-import "@openzeppelin/contracts/utils/Address.sol";
-import "@openzeppelin/contracts-upgradeable/utils/cryptography/draft-EIP712Upgradeable.sol";
-import "../interfaces/IPLimitRouter.sol";
-import "../core/libraries/BoringOwnableUpgradeable.sol";
-import "../core/libraries/TokenHelper.sol";
-import "../interfaces/IStandardizedYield.sol";
-import "./helpers/Permitable.sol";
-import "./helpers/NonceManager.sol";
-import "./helpers/ArgumentsDecoder.sol";
-import "../interfaces/IWETH.sol";
-import {LimitMathCore as LimitMath} from "./LimitMathCore.sol";
-
-abstract contract PendleOrderMixin is
-    EIP712Upgradeable,
-    IPOrderMixin,
-    Permitable,
-    BoringOwnableUpgradeable,
-    NonceManager,
-    TokenHelper
-{
-    using SafeERC20 for IERC20;
-    using PYIndexLib for PYIndex;
-    using PMath for uint256;
-    using PMath for int256;
-    using PYIndexLib for IPYieldToken;
-    using ArgumentsDecoder for bytes;
-    using Address for address payable;
-
-    bytes32 internal constant LIMIT_ORDER_TYPEHASH = keccak256(
-        "Order(uint256 salt,uint256 expiry,uint256 nonce,uint8 orderType,address token,address YT,address maker,address receiver,uint256 makingAmount,uint256 lnImpliedRate,uint256 failSafeRate,bytes permit)"
-    );
-
-    uint128 internal constant _ORDER_DOES_NOT_EXIST = 0;
-    uint128 internal constant _ORDER_FILLED = 1;
-
-    address public feeRecipient;
-    uint96 public lnFeeRateRoot;
-
-    address private immutable WNATIVE;
-
-    mapping(bytes32 => OrderStatus) internal _status;
-
-    uint256[100] private __gap;
-
-    constructor(address _WNATIVE) {
-        WNATIVE = _WNATIVE;
-    }
-
-    // solhint-disable-next-line no-empty-blocks
-    receive() external payable {}
-
-    function initialize(address _feeRecipient, uint96 _lnFeeRateRoot) external initializer {
-        __BoringOwnable_init();
-        __EIP712_init("Pendle Limit Order Protocol", "1");
-        setFees(_feeRecipient, _lnFeeRateRoot);
-    }
-
-    function normalFill(FillOrderParams[] memory params, address receiver, uint256 maxTaking, bytes memory callback)
-        external
-        returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee)
-    {
-        _validateOrdersSkipSig(params);
-        OrderType orderType = params[0].order.orderType;
-        if (orderType == OrderType.SY_FOR_PT || orderType == OrderType.SY_FOR_YT) {
-            return normalFillTokenForPY(Args(orderType, params, receiver, maxTaking, callback));
-        } else {
-            return normalFillPYForToken(Args(orderType, params, receiver, maxTaking, callback));
-        }
-    }
-
-    function flashFill(FillOrderParams[] memory params, address receiver, uint256 maxInput, bytes memory callback)
-        external
-        returns (uint256 netOutputToTaker, uint256 netInputFromTaker, uint256 totalFee)
-    {
-        _validateOrdersSkipSig(params);
-        OrderType orderType = params[0].order.orderType;
-        if (orderType == OrderType.SY_FOR_PT || orderType == OrderType.SY_FOR_YT) {
-            return flashFillTokenForPY(Args(orderType, params, receiver, maxInput, callback));
-        } else {
-            return flashFillPYForToken(Args(orderType, params, receiver, maxInput, callback));
-        }
-    }
-
-    // ----------------- Core logic -----------------
-
-    // solhint-disable-next-line
-    struct Args {
-        OrderType orderType;
-        FillOrderParams[] params;
-        address receiver;
-        uint256 maxTaking; // or maxInput
-        bytes callback;
-    }
-
-    function normalFillTokenForPY(Args memory a)
-        internal
-        returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee)
-    {
-        (address SY, address PT, address YT, bytes32[] memory orderHashes) =
-            _checkSig_doPermit_updMakingAndRemaining(a.params);
-
-        // Token => This
-        uint256[] memory fromMakers = _transferFromMakers_mintSy_updMakings(SY, a.params);
-
-        NormalResults memory out = LimitMath.calcNormalBatch(a.params, YT, lnFeeRateRoot);
-        (actualMaking, actualTaking, totalFee) = (out.totalMaking - out.totalFee, out.totalTaking, out.totalFee);
-
-        require(actualTaking <= a.maxTaking, "LOP: maxTaking exceeded");
-
-        // This => Taker
-        _transferOut(SY, a.receiver, actualMaking);
-
-        // callback to Taker
-        if (a.callback.length > 0) {
-            ILimitOrderCallee(msg.sender).normalFillCall(a.orderType, actualMaking, actualTaking, totalFee, a.callback);
-        }
-
-        // Taker => Makers
-        address pyToMaker = (a.orderType == OrderType.SY_FOR_PT) ? PT : YT;
-        _transferToMakers(IERC20(pyToMaker), msg.sender, a.params, out.netTakings);
-
-        // This => Fee
-        _transferOut(SY, feeRecipient, totalFee);
-
-        // toMakers == netTakings
-        _checkSafety_emitEvents(a.params, orderHashes, fromMakers, out.netTakings, out.netFees, out.notionalVolumes);
-    }
-
-    function normalFillPYForToken(Args memory a)
-        internal
-        returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee)
-    {
-        (address SY, address PT, address YT, bytes32[] memory orderHashes) =
-            _checkSig_doPermit_updMakingAndRemaining(a.params);
-
-        NormalResults memory out = LimitMath.calcNormalBatch(a.params, YT, lnFeeRateRoot);
-        (actualMaking, actualTaking, totalFee) = (out.totalMaking, out.totalTaking + out.totalFee, out.totalFee);
-
-        require(actualTaking <= a.maxTaking, "LOP: maxTaking exceeded");
-
-        // Makers => Taker
-        address pyFromMaker = (a.orderType == OrderType.PT_FOR_SY) ? PT : YT;
-        _transferFromMakers(IERC20(pyFromMaker), a.params, a.receiver, out.netMakings);
-
-        // callback to Taker
-        if (a.callback.length > 0) {
-            ILimitOrderCallee(msg.sender).normalFillCall(a.orderType, actualMaking, actualTaking, totalFee, a.callback);
-        }
-
-        // Taker => This
-        _transferFrom(IERC20(SY), msg.sender, address(this), actualTaking);
-
-        // This => Makers
-        uint256[] memory toMakers = _redeemSy_transferToMakers(SY, a.params, out.netTakings);
-
-        // This => Fee
-        _transferOut(SY, feeRecipient, totalFee);
-
-        // fromMakers == netMakings
-        _checkSafety_emitEvents(a.params, orderHashes, out.netMakings, toMakers, out.netFees, out.notionalVolumes);
-    }
-
-    // ----------------- Flash functions -----------------
-
-    function flashFillTokenForPY(Args memory a)
-        internal
-        returns (uint256 totalPYToTaker, uint256 totalSyFromTaker, uint256 totalFee)
-    {
-        (address SY, address PT, address YT, bytes32[] memory orderHashes) =
-            _checkSig_doPermit_updMakingAndRemaining(a.params);
-
-        // Token => This
-        uint256[] memory fromMakers = _transferFromMakers_mintSy_updMakings(SY, a.params);
-
-        NormalResults memory out;
-        (totalSyFromTaker, totalPYToTaker, totalFee, out) = LimitMath.calcFlashBatch(a.params, YT, lnFeeRateRoot);
-
-        require(totalSyFromTaker <= a.maxTaking, "LOP: maxInput exceeded");
-
-        // callback to Taker
-        if (a.callback.length > 0) {
-            ILimitOrderCallee(msg.sender).flashFillCall(
-                a.orderType, totalPYToTaker, totalSyFromTaker, totalFee, a.callback
-            );
-        }
-
-        // Taker => This
-        _transferFrom(IERC20(SY), msg.sender, address(this), totalSyFromTaker);
-
-        // This => YT
-        _transferOut(SY, YT, totalSyFromTaker + out.totalMaking - out.totalFee);
-
-        bool isPtToMaker = (a.orderType == OrderType.SY_FOR_PT);
-        address pyToMaker = isPtToMaker ? PT : YT;
-        {
-            address receiverPt = isPtToMaker ? address(this) : a.receiver;
-            address receiverYt = isPtToMaker ? a.receiver : address(this);
-
-            // PT => receiverPt, YT => receiverYt
-            IPYieldToken(YT).mintPY(receiverPt, receiverYt);
-        }
-
-        // This => Makers
-        _transferToMakers(IERC20(pyToMaker), address(this), a.params, out.netTakings);
-
-        // This => Fee
-        _transferOut(SY, feeRecipient, totalFee);
-
-        // toMakers == netTakings
-        _checkSafety_emitEvents(a.params, orderHashes, fromMakers, out.netTakings, out.netFees, out.notionalVolumes);
-    }
-
-    function flashFillPYForToken(Args memory a)
-        internal
-        returns (uint256 totalSyToTaker, uint256 totalPYFromTaker, uint256 totalFee)
-    {
-        (address SY, address PT, address YT, bytes32[] memory orderHashes) =
-            _checkSig_doPermit_updMakingAndRemaining(a.params);
-
-        NormalResults memory out;
-        (totalPYFromTaker, totalSyToTaker, totalFee, out) = LimitMath.calcFlashBatch(a.params, YT, lnFeeRateRoot);
-
-        require(totalPYFromTaker <= a.maxTaking, "LOP: maxInput exceeded");
-
-        // callback to Taker
-        if (a.callback.length > 0) {
-            ILimitOrderCallee(msg.sender).flashFillCall(
-                a.orderType, totalSyToTaker, totalPYFromTaker, totalFee, a.callback
-            );
-        }
-
-        bool ptFromTaker = (a.orderType == OrderType.YT_FOR_SY);
-        address pyFromTaker = ptFromTaker ? PT : YT;
-        address pyFromMaker = ptFromTaker ? YT : PT;
-
-        // Taker => YT
-        _transferFrom(IERC20(pyFromTaker), msg.sender, YT, totalPYFromTaker);
-        // Maker => YT
-        _transferFromMakers(IERC20(pyFromMaker), a.params, YT, out.netMakings);
-
-        // YT => This
-        IPYieldToken(YT).redeemPY(address(this));
-
-        // This => Taker
-        _transferOut(SY, a.receiver, totalSyToTaker);
-
-        // This => Makers
-        uint256[] memory toMakers = _redeemSy_transferToMakers(SY, a.params, out.netTakings);
-
-        // This => Fee
-        _transferOut(SY, feeRecipient, totalFee);
-
-        // fromMakers == netMakings
-        _checkSafety_emitEvents(a.params, orderHashes, out.netMakings, toMakers, out.netFees, out.notionalVolumes);
-    }
-
-    // ----------------- verify & convert functions -----------------
-    function _validateOrdersSkipSig(FillOrderParams[] memory params) internal view {
-        uint256 len = params.length;
-        require(len != 0, "LOP: empty batch");
-
-        (address YT, OrderType orderType) = (params[0].order.YT, params[0].order.orderType);
-
-        uint256 expiry = IPYieldToken(YT).expiry();
-        require(block.timestamp < expiry, "LOP: PY expired");
-
-        for (uint256 i = 0; i < len; i = _inc1(i)) {
-            Order memory order = params[i].order;
-
-            require(order.orderType == orderType, "LOP: not same orderType");
-            require(order.YT == YT, "LOP: not same YT");
-            require(block.timestamp < order.expiry, "LOP: order expired");
-            require(order.nonce >= nonce[order.maker], "LOP: order invalidated");
-        }
-    }
-
-    function _checkSig_doPermit_updMakingAndRemaining(FillOrderParams[] memory params)
-        internal
-        returns (address SY, address PT, address YT, bytes32[] memory orderHashes)
-    {
-        uint256 len = params.length;
-        orderHashes = new bytes32[](len);
-
-        for (uint256 i = 0; i < len; i = _inc1(i)) {
-            FillOrderParams memory param = params[i];
-
-            (bytes32 orderHash, uint256 remainingMakerAmount, uint256 filledMakerAmount) =
-                _checkSig_doPermit(param.order, param.signature);
-            uint256 netMaking = PMath.min(param.makingAmount, remainingMakerAmount);
-
-            unchecked {
-                remainingMakerAmount = remainingMakerAmount - netMaking;
-                _status[orderHash] = OrderStatus({
-                    remaining: (remainingMakerAmount + 1).Uint128(),
-                    filledAmount: (filledMakerAmount + netMaking).Uint128()
-                });
-            }
-
-            param.makingAmount = netMaking;
-
-            orderHashes[i] = orderHash;
-        }
-
-        YT = params[0].order.YT;
-        SY = IPYieldToken(YT).SY();
-        PT = IPYieldToken(YT).PT();
-    }
-
-    function _checkSafety_emitEvents(
-        FillOrderParams[] memory params,
-        bytes32[] memory hashes,
-        uint256[] memory fromMakers,
-        uint256[] memory toMakers,
-        uint256[] memory netFees,
-        uint256[] memory notionalVolumes
-    ) internal {
-        uint256 len = hashes.length;
-
-        for (uint256 i = 0; i < len; i = _inc1(i)) {
-            require(fromMakers[i].mulDown(params[i].order.failSafeRate) <= toMakers[i], "LOP: fail safe");
-        }
-
-        for (uint256 i = 0; i < len; i = _inc1(i)) {
-            Order memory order = params[i].order;
-            emit OrderFilled(
-                hashes[i],
-                order.orderType,
-                order.YT,
-                order.token,
-                fromMakers[i],
-                toMakers[i],
-                netFees[i],
-                notionalVolumes[i]
-            );
-        }
-    }
-
-    function _checkSig_doPermit(Order memory order, bytes memory signature)
-        internal
-        returns (
-            bytes32,
-            /*orderHash*/
-            uint256,
-            /*remainingMakerAmount*/
-            uint256 /*filledMakerAmount*/
-        )
-    {
-        bytes32 orderHash = hashOrder(order);
-        OrderStatus memory status = _status[orderHash];
-        (uint256 remainingMakerAmount, uint256 filledMakerAmount) = (status.remaining, status.filledAmount);
-
-        if (remainingMakerAmount == _ORDER_FILLED) return (orderHash, 0, filledMakerAmount);
-
-        if (remainingMakerAmount == _ORDER_DOES_NOT_EXIST) {
-            require(SignatureChecker.isValidSignatureNow(order.maker, orderHash, signature), "LOP: bad signature");
-
-            remainingMakerAmount = order.makingAmount;
-
-            // permit if there is such
-            if (order.permit.length >= 20) {
-                // proceed only if permit length is enough to store address
-                (address token, bytes memory permit) = order.permit.decodeTargetAndCalldata();
-                _permitMemory(token, permit);
-                require(_status[orderHash].remaining == _ORDER_DOES_NOT_EXIST, "LOP: reentrancy detected");
-            }
-        } else {
-            unchecked {
-                remainingMakerAmount -= 1;
-            }
-        }
-
-        return (orderHash, remainingMakerAmount, filledMakerAmount);
-    }
-
-    // ----------------- simple helper functions functions -----------------
-
-    function _transferFromMakers_mintSy_updMakings(address SY, FillOrderParams[] memory params)
-        internal
-        returns (uint256[] memory fromMakers)
-    {
-        uint256 len = params.length;
-        fromMakers = new uint256[](len);
-
-        for ((uint256 l, uint256 r) = (0, 0); l < len; l = r) {
-            address sharedToken = params[l].order.token;
-            uint256 totalMaking = 0;
-            for (; r < len && params[r].order.token == sharedToken; r = _inc1(r)) {
-                _transferIn(sharedToken, params[r].order.maker, params[r].makingAmount);
-                totalMaking += params[r].makingAmount;
-                fromMakers[r] = params[r].makingAmount;
-            }
-
-            if (sharedToken == SY || totalMaking == 0) continue;
-
-            uint256 totalSy = __mintSy_Single(SY, sharedToken, totalMaking);
-            for (uint256 i = l; i < r; i = _inc1(i)) {
-                params[i].makingAmount = (params[i].makingAmount * totalSy) / totalMaking;
-            }
-        }
-    }
-
-    function __mintSy_Single(address SY, address token, uint256 netTokenIn) private returns (uint256 netSyOut) {
-        if (token == WNATIVE && !IStandardizedYield(SY).isValidTokenIn(WNATIVE)) {
-            _wrap_unwrap_ETH(WNATIVE, NATIVE, netTokenIn);
-            token = NATIVE;
-        }
-        _safeApproveInf(token, SY);
-        return
-            IStandardizedYield(SY).deposit{value: token == NATIVE ? netTokenIn : 0}(address(this), token, netTokenIn, 0);
-    }
-
-    function _redeemSy_transferToMakers(address SY, FillOrderParams[] memory params, uint256[] memory netSyOuts)
-        internal
-        returns (uint256[] memory toMakers)
-    {
-        // netSyOuts all > 0, guarantee in LimitMath
-
-        uint256 len = params.length;
-        toMakers = new uint256[](len);
-
-        for ((uint256 l, uint256 r) = (0, 0); l < len; l = r) {
-            address sharedToken = params[l].order.token;
-            uint256 totalSy = 0;
-
-            for (; r < len && __stillShared(sharedToken, params[r].order.token); r = _inc1(r)) {
-                totalSy += netSyOuts[r];
-            }
-
-            if (sharedToken == SY) {
-                for (uint256 i = l; i < r; i = _inc1(i)) {
-                    _transferOut(SY, params[i].order.receiver, netSyOuts[i]);
-                    toMakers[i] = netSyOuts[i];
-                }
-                continue;
-            }
-
-            if (r - l == 1) {
-                toMakers[l] = __redeemSy_Single(params[l].order.receiver, SY, sharedToken, netSyOuts[l]);
-            } else {
-                uint256 totalToken = __redeemSy_Single(address(this), SY, sharedToken, totalSy);
-                for (uint256 i = l; i < r; i = _inc1(i)) {
-                    address token = params[i].order.token;
-                    toMakers[i] = (netSyOuts[i] * totalToken) / totalSy;
-                    if (sharedToken != token) {
-                        // WNATIVE case
-                        _wrap_unwrap_ETH(sharedToken, token, toMakers[i]);
-                    }
-                    _transferOut(token, params[i].order.receiver, toMakers[i]);
-                }
-            }
-        }
-    }
-
-    function __stillShared(address currentShared, address nextToken) private view returns (bool) {
-        return (currentShared == nextToken) || (currentShared == NATIVE && nextToken == WNATIVE)
-            || (currentShared == WNATIVE && nextToken == NATIVE);
-    }
-
-    function __redeemSy_Single(address receiver, address SY, address tokenOut, uint256 netSyIn)
-        private
-        returns (uint256 netTokenOut)
-    {
-        if (tokenOut == NATIVE || tokenOut == WNATIVE) {
-            address otherToken = tokenOut == NATIVE ? WNATIVE : NATIVE;
-            address tokenRedeemSy = IStandardizedYield(SY).isValidTokenOut(tokenOut) ? tokenOut : otherToken;
-
-            netTokenOut = IStandardizedYield(SY).redeem(address(this), netSyIn, tokenRedeemSy, 0, false);
-
-            if (tokenOut != tokenRedeemSy) {
-                _wrap_unwrap_ETH(tokenRedeemSy, tokenOut, netTokenOut);
-            }
-
-            if (receiver != address(this)) {
-                _transferOut(tokenOut, receiver, netTokenOut);
-            }
-        } else {
-            return IStandardizedYield(SY).redeem(receiver, netSyIn, tokenOut, 0, false);
-        }
-    }
-
-    function _inc1(uint256 i) internal pure returns (uint256) {
-        unchecked {
-            return i + 1;
-        }
-    }
-
-    // ! Allow self-fill of orders
-    function _transferFromMakers(IERC20 token, FillOrderParams[] memory params, address to, uint256[] memory netIn)
-        internal
-    {
-        uint256 len = params.length;
-        for (uint256 i = 0; i < len; i = _inc1(i)) {
-            if (params[i].order.maker == to) continue;
-            token.safeTransferFrom(params[i].order.maker, to, netIn[i]);
-        }
-    }
-
-    function _transferToMakers(IERC20 token, address payer, FillOrderParams[] memory params, uint256[] memory netOut)
-        internal
-    {
-        uint256 len = params.length;
-        if (payer == address(this)) {
-            for (uint256 i = 0; i < len; i = _inc1(i)) {
-                token.safeTransfer(params[i].order.receiver, netOut[i]);
-            }
-        } else {
-            for (uint256 i = 0; i < len; i = _inc1(i)) {
-                if (payer == params[i].order.receiver) continue;
-                token.safeTransferFrom(payer, params[i].order.receiver, netOut[i]);
-            }
-        }
-    }
-
-    function hashOrder(Order memory order) public view returns (bytes32) {
-        StaticOrder memory staticOrder;
-        assembly {
-            staticOrder := order
-        }
-        return _hashTypedDataV4(keccak256(abi.encode(LIMIT_ORDER_TYPEHASH, staticOrder, keccak256(order.permit))));
-    }
-
-    // ----------------- Owner -----------------
-    function setFees(address _feeRecipient, uint96 _lnFeeRateRoot) public onlyOwner {
-        feeRecipient = _feeRecipient;
-        lnFeeRateRoot = _lnFeeRateRoot;
-    }
-}

package/contracts/limit/helpers/ArgumentsDecoder.sol

@@ -1,47 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity ^0.8.0;
-
-/// @title Library with gas efficient alternatives to `abi.decode`
-library ArgumentsDecoder {
-    function decodeUint256(bytes memory data) internal pure returns (uint256) {
-        uint256 value;
-        assembly {
-            // solhint-disable-line no-inline-assembly
-            value := mload(add(data, 0x20))
-        }
-        return value;
-    }
-
-    function decodeBool(bytes memory data) internal pure returns (bool) {
-        bool value;
-        assembly {
-            // solhint-disable-line no-inline-assembly
-            value := eq(mload(add(data, 0x20)), 1)
-        }
-        return value;
-    }
-
-    function decodeTargetAndCalldata(bytes memory data) internal pure returns (address, bytes memory) {
-        address target;
-        bytes memory args;
-        assembly {
-            // solhint-disable-line no-inline-assembly
-            target := mload(add(data, 0x14))
-            args := add(data, 0x14)
-            mstore(args, sub(mload(data), 0x14))
-        }
-        return (target, args);
-    }
-
-    function decodeTargetAndData(bytes calldata data) internal pure returns (address, bytes calldata) {
-        address target;
-        bytes calldata args;
-        assembly {
-            // solhint-disable-line no-inline-assembly
-            target := shr(96, calldataload(data.offset))
-        }
-        args = data[20:];
-        return (target, args);
-    }
-}

package/contracts/limit/helpers/NonceManager.sol

@@ -1,30 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.0;
-
-/// @title A helper contract for managing nonce of tx sender
-
-contract NonceManager {
-    event NonceIncreased(address indexed maker, uint256 oldNonce, uint256 newNonce);
-
-    mapping(address => uint256) public nonce;
-
-    uint256[100] private __gap;
-
-    /// @notice Advances nonce by one
-    function increaseNonce() external {
-        advanceNonce(1);
-    }
-
-    /// @notice Advances nonce by specified amount
-    function advanceNonce(uint8 amount) public {
-        uint256 newNonce = nonce[msg.sender] + amount;
-        nonce[msg.sender] = newNonce;
-        emit NonceIncreased(msg.sender, newNonce - amount, newNonce);
-    }
-
-    /// @notice Checks if `makerAddress` has specified `makerNonce`
-    /// @return Result True if `makerAddress` has specified nonce. Otherwise, false
-    function nonceEquals(address makerAddress, uint256 makerNonce) external view returns (bool) {
-        return nonce[makerAddress] == makerNonce;
-    }
-}

package/contracts/limit/helpers/Permitable.sol

@@ -1,48 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity ^0.8.0;
-
-import "@openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol";
-import "./RevertReasonParser.sol";
-import "../../interfaces/IDailLikePermit.sol";
-
-/// @title Base contract with common permit handling logics
-abstract contract Permitable {
-    function _permit(address token, bytes calldata permit) internal {
-        if (permit.length > 0) {
-            bool success;
-            bytes memory result;
-            if (permit.length == 32 * 7) {
-                // solhint-disable-next-line avoid-low-level-calls
-                (success, result) = token.call(abi.encodePacked(IERC20Permit.permit.selector, permit));
-            } else if (permit.length == 32 * 8) {
-                // solhint-disable-next-line avoid-low-level-calls
-                (success, result) = token.call(abi.encodePacked(IDaiLikePermit.permit.selector, permit));
-            } else {
-                revert("Wrong permit length");
-            }
-            if (!success) {
-                revert(RevertReasonParser.parse(result, "Permit failed: "));
-            }
-        }
-    }
-
-    function _permitMemory(address token, bytes memory permit) internal {
-        if (permit.length > 0) {
-            bool success;
-            bytes memory result;
-            if (permit.length == 32 * 7) {
-                // solhint-disable-next-line avoid-low-level-calls
-                (success, result) = token.call(abi.encodePacked(IERC20Permit.permit.selector, permit));
-            } else if (permit.length == 32 * 8) {
-                // solhint-disable-next-line avoid-low-level-calls
-                (success, result) = token.call(abi.encodePacked(IDaiLikePermit.permit.selector, permit));
-            } else {
-                revert("Wrong permit length");
-            }
-            if (!success) {
-                revert(RevertReasonParser.parse(result, "Permit failed: "));
-            }
-        }
-    }
-}