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

package/contracts/limit/PendleOrderMixin.sol

@@ -0,0 +1,526 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.21;
+
+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,bytes permit)"
+    );
+
+    uint256 internal constant _ORDER_DOES_NOT_EXIST = 0;
+    uint256 internal constant _ORDER_FILLED = 1;
+
+    address public feeRecipient;
+    uint96 public lnFeeRateRoot;
+
+    address private immutable WNATIVE;
+
+    mapping(bytes32 => uint256) internal _remaining;
+
+    constructor(address _WNATIVE) {
+        WNATIVE = _WNATIVE;
+    }
+
+    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)
+    {
+        OrderType orderType = params[0].order.orderType;
+        _validateOrdersSkipSig(params);
+        if (orderType == OrderType.SY_FOR_PT || orderType == OrderType.SY_FOR_YT) {
+            return normalFillTokenForPY(params, receiver, maxTaking, callback);
+        } else {
+            return normalFillPYForToken(params, receiver, maxTaking, callback);
+        }
+    }
+
+    function flashFill(FillOrderParams[] memory params, address receiver, uint256 maxInput, bytes memory callback)
+        external
+        returns (uint256 netOutputToTaker, uint256 netInputFromTaker, uint256 totalFee)
+    {
+        OrderType orderType = params[0].order.orderType;
+        _validateOrdersSkipSig(params);
+        if (orderType == OrderType.SY_FOR_PT || orderType == OrderType.SY_FOR_YT) {
+            return flashFillTokenForPY(params, receiver, maxInput, callback);
+        } else {
+            return flashFillPYForToken(params, receiver, maxInput, callback);
+        }
+    }
+
+    // ----------------- Core logic -----------------
+
+    struct Args {
+        FillOrderParams[] params;
+        address receiver;
+        uint256 maxTaking; // or maxInput
+        bytes callback;
+    }
+
+    function normalFillTokenForPY(
+        FillOrderParams[] memory _params,
+        address _receiver,
+        uint256 _maxTaking,
+        bytes memory _callback
+    ) internal returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee) {
+        Args memory a = Args(_params, _receiver, _maxTaking, _callback);
+
+        OrderType orderType = a.params[0].order.orderType;
+
+        // Token => This
+        (address SY, address PT, address YT, OnchainParams memory onchain) = _prep(a.params, true);
+
+        NormalResults memory out = LimitMath.calcNormalBatch(a.params, onchain);
+        (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(orderType, actualMaking, actualTaking, totalFee, a.callback);
+        }
+
+        // Taker => Makers
+        address pyToMaker = (orderType == OrderType.SY_FOR_PT) ? PT : YT;
+        _transferFromMulti(IERC20(pyToMaker), msg.sender, a.params, out.netTakings);
+
+        // This => Fee
+        _transferOut(SY, onchain.feeRecipient, totalFee);
+
+        emit NormalFill(
+            orderType, YT, msg.sender, actualMaking, actualTaking, totalFee, out.totalMaking, out.totalTaking
+        );
+    }
+
+    function normalFillPYForToken(
+        FillOrderParams[] memory _params,
+        address _receiver,
+        uint256 _maxTaking,
+        bytes memory _callback
+    ) internal returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee) {
+        Args memory a = Args(_params, _receiver, _maxTaking, _callback);
+
+        OrderType orderType = a.params[0].order.orderType;
+
+        (address SY, address PT, address YT, OnchainParams memory onchain) = _prep(a.params, false);
+
+        NormalResults memory out = LimitMath.calcNormalBatch(a.params, onchain);
+        (actualMaking, actualTaking, totalFee) = (out.totalMaking, out.totalTaking + out.totalFee, out.totalFee);
+
+        require(actualTaking <= a.maxTaking, "LOP: maxTaking exceeded");
+
+        // Makers => Taker
+        address pyFromMaker = (orderType == OrderType.PT_FOR_SY) ? PT : YT;
+        _transferFromMulti(IERC20(pyFromMaker), a.params, a.receiver, out.netMakings);
+
+        // callback to Taker
+        if (a.callback.length > 0) {
+            ILimitOrderCallee(msg.sender).normalFillCall(orderType, actualMaking, actualTaking, totalFee, a.callback);
+        }
+
+        // Taker => This
+        _transferFrom(IERC20(SY), msg.sender, address(this), actualTaking);
+
+        // This => Makers
+        _redeemSy_transferOut(SY, a.params, out.totalTaking, out.netTakings);
+
+        // This => Fee
+        _transferOut(SY, onchain.feeRecipient, totalFee);
+
+        emit NormalFill(
+            orderType, YT, msg.sender, actualMaking, actualTaking, totalFee, out.totalMaking, out.totalTaking
+        );
+    }
+
+    // ----------------- Flash functions -----------------
+
+    function flashFillTokenForPY(
+        FillOrderParams[] memory _params,
+        address _receiver,
+        uint256 _maxInput,
+        bytes memory _callback
+    ) internal returns (uint256 totalPYToTaker, uint256 totalSyFromTaker, uint256 totalFee) {
+        Args memory a = Args(_params, _receiver, _maxInput, _callback);
+
+        OrderType orderType = a.params[0].order.orderType;
+
+        // Token => This
+        (address SY, address PT, address YT, OnchainParams memory onchain) = _prep(a.params, true);
+
+        NormalResults memory out;
+        (totalSyFromTaker, totalPYToTaker, totalFee, out) = LimitMath.calcFlashBatch(a.params, onchain);
+
+        require(totalSyFromTaker <= a.maxTaking, "LOP: maxInput exceeded");
+
+        // callback to Taker
+        if (a.callback.length > 0) {
+            ILimitOrderCallee(msg.sender).flashFillCall(
+                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 = (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
+        _transferFromMulti(IERC20(pyToMaker), address(this), a.params, out.netTakings);
+
+        // This => Fee
+        _transferOut(SY, onchain.feeRecipient, out.totalFee);
+
+        emit FlashFill(
+            orderType, YT, msg.sender, totalPYToTaker, totalSyFromTaker, totalFee, out.totalMaking, out.totalTaking
+        );
+    }
+
+    function flashFillPYForToken(
+        FillOrderParams[] memory _params,
+        address _receiver,
+        uint256 _maxInput,
+        bytes memory _callback
+    ) internal returns (uint256 totalSyToTaker, uint256 totalPYFromTaker, uint256 totalFee) {
+        Args memory a = Args(_params, _receiver, _maxInput, _callback);
+
+        OrderType orderType = a.params[0].order.orderType;
+
+        (address SY, address PT, address YT, OnchainParams memory onchain) = _prep(a.params, false);
+
+        NormalResults memory out;
+        (totalPYFromTaker, totalSyToTaker, totalFee, out) = LimitMath.calcFlashBatch(a.params, onchain);
+
+        require(totalPYFromTaker <= a.maxTaking, "LOP: maxInput exceeded");
+
+        // callback to Taker
+        if (a.callback.length > 0) {
+            ILimitOrderCallee(msg.sender).flashFillCall(
+                orderType, totalSyToTaker, totalPYFromTaker, totalFee, a.callback
+            );
+        }
+
+        bool ptFromTaker = (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
+        _transferFromMulti(IERC20(pyFromMaker), a.params, YT, out.netMakings);
+
+        // YT => This
+        IPYieldToken(YT).redeemPY(address(this));
+
+        // This => Taker
+        _transferOut(SY, a.receiver, totalSyToTaker);
+
+        // This => Makers
+        _redeemSy_transferOut(SY, a.params, out.totalTaking, out.netTakings);
+
+        // This => Fee
+        _transferOut(SY, onchain.feeRecipient, out.totalFee);
+
+        emit FlashFill(
+            orderType, YT, msg.sender, totalSyToTaker, totalPYFromTaker, totalFee, out.totalMaking, out.totalTaking
+        );
+    }
+
+    // ----------------- 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);
+        bool isTokenOut = (orderType == OrderType.PT_FOR_SY || orderType == OrderType.YT_FOR_SY);
+
+        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");
+
+            if (isTokenOut) require(order.token != WNATIVE, "LOP: invalid tokenOut");
+            // else assert(order.token!=NATIVE) // always true
+        }
+    }
+
+    function _prep(FillOrderParams[] memory params, bool tokenToSy)
+        internal
+        returns (address SY, address PT, address YT, OnchainParams memory onchain)
+    {
+        _checkSig_doPermit_updMakingAndRemaining(params); // state changes to avoid reentrancy
+
+        YT = params[0].order.YT;
+        SY = IPYieldToken(YT).SY();
+        PT = IPYieldToken(YT).PT();
+
+        if (tokenToSy) {
+            _transferIn_mintSy(SY, params);
+        }
+
+        onchain = getOnchainParams(YT);
+    }
+
+    function _checkSig_doPermit_updMakingAndRemaining(FillOrderParams[] memory params) internal {
+        uint256 len = params.length;
+        for (uint256 i = 0; i < len; i = _inc1(i)) {
+            FillOrderParams memory param = params[i];
+
+            (bytes32 orderHash, uint256 remainingMakerAmount) = _checkSig_doPermit(param.order, param.signature);
+            uint256 netMaking = PMath.min(param.makingAmount, remainingMakerAmount);
+
+            unchecked {
+                remainingMakerAmount = remainingMakerAmount - netMaking;
+                _remaining[orderHash] = remainingMakerAmount + 1;
+
+                emit OrderRemainingUpdated(orderHash, remainingMakerAmount);
+            }
+
+            param.makingAmount = netMaking;
+        }
+    }
+
+    function _checkSig_doPermit(Order memory order, bytes memory signature)
+        internal
+        returns (bytes32, /*orderHash*/ uint256 /*remainingMakerAmount*/ )
+    {
+        bytes32 orderHash = hashOrder(order);
+        uint256 remainingMakerAmount = _remaining[orderHash];
+
+        if (remainingMakerAmount == _ORDER_FILLED) return (orderHash, 0);
+
+        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(_remaining[orderHash] == _ORDER_DOES_NOT_EXIST, "LOP: reentrancy detected");
+            }
+        } else {
+            unchecked {
+                remainingMakerAmount -= 1;
+            }
+        }
+
+        return (orderHash, remainingMakerAmount);
+    }
+
+    // ----------------- simple helper functions functions -----------------
+
+    function _transferIn_mintSy(address SY, FillOrderParams[] memory params) internal {
+        uint256 len = params.length;
+        (bool isSame, address commonToken) = _isSameTokens(params);
+        uint256 totalMakingCommon = 0;
+
+        for (uint256 i = 0; i < len; i = _inc1(i)) {
+            FillOrderParams memory param = params[i];
+            if (param.makingAmount == 0) continue;
+
+            _transferIn(param.order.token, param.order.maker, param.makingAmount);
+            if (isSame) totalMakingCommon += param.makingAmount;
+        }
+
+        if (isSame) {
+            if (commonToken == SY || totalMakingCommon == 0) return;
+            uint256 totalSy = __mintSy_Single(SY, commonToken, totalMakingCommon);
+            for (uint256 i = 0; i < len; i = _inc1(i)) {
+                params[i].makingAmount = params[i].makingAmount * totalSy / totalMakingCommon;
+            }
+        } else {
+            for (uint256 i = 0; i < len; i = _inc1(i)) {
+                FillOrderParams memory param = params[i];
+                if (param.makingAmount == 0 || param.order.token == SY) continue;
+                param.makingAmount = __mintSy_Single(SY, param.order.token, param.makingAmount);
+            }
+        }
+    }
+
+    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;
+        }
+        return
+            IStandardizedYield(SY).deposit{value: token == NATIVE ? netTokenIn : 0}(address(this), token, netTokenIn, 0);
+    }
+
+    function _redeemSy_transferOut(
+        address SY,
+        FillOrderParams[] memory params,
+        uint256 totalSyOut,
+        uint256[] memory netSyOuts
+    ) internal {
+        uint256 len = params.length;
+        (bool isSame, address commonToken) = _isSameTokens(params);
+
+        if (isSame) {
+            if (commonToken == SY) {
+                _transferFromMulti(IERC20(SY), address(this), params, netSyOuts);
+                return;
+            }
+
+            uint256 totalTokenOut = __redeemSy_Single(address(this), SY, commonToken, totalSyOut);
+            for (uint256 i = 0; i < len; i = _inc1(i)) {
+                Order memory order = params[i].order;
+                uint256 netOut = netSyOuts[i] * totalTokenOut / totalSyOut;
+                if (order.token == NATIVE) payable(order.receiver).sendValue(netOut);
+                else IERC20(order.token).safeTransfer(order.receiver, netOut);
+            }
+        } else {
+            for (uint256 i = 0; i < len; i = _inc1(i)) {
+                Order memory order = params[i].order;
+                if (order.token == SY) {
+                    _transferOut(SY, order.receiver, netSyOuts[i]);
+                } else {
+                    __redeemSy_Single(order.receiver, SY, order.token, netSyOuts[i]);
+                }
+            }
+        }
+    }
+
+    function __redeemSy_Single(address receiver, address SY, address tokenOut, uint256 netSyIn)
+        private
+        returns (uint256 netTokenOut)
+    {
+        if (tokenOut == NATIVE) {
+            address tokenRedeemSy = IStandardizedYield(SY).isValidTokenOut(tokenOut) ? tokenOut : WNATIVE;
+            netTokenOut = IStandardizedYield(SY).redeem(address(this), netSyIn, tokenRedeemSy, 0, false);
+
+            if (tokenRedeemSy == WNATIVE) {
+                _wrap_unwrap_ETH(WNATIVE, NATIVE, netTokenOut);
+            }
+            payable(receiver).sendValue(netTokenOut);
+        } else {
+            return IStandardizedYield(SY).redeem(receiver, netSyIn, tokenOut, 0, false);
+        }
+    }
+
+    function _isSameTokens(FillOrderParams[] memory params)
+        internal
+        pure
+        returns (bool, /*isSame*/ address /*commonToken*/ )
+    {
+        uint256 len = params.length;
+        address commonToken = params[0].order.token;
+        for (uint256 i = 1; i < len; i = _inc1(i)) {
+            if (params[i].order.token != commonToken) return (false, address(0));
+        }
+        return (true, commonToken);
+    }
+
+    function _inc1(uint256 i) internal pure returns (uint256) {
+        unchecked {
+            return i + 1;
+        }
+    }
+
+    function _transferFromMulti(IERC20 token, FillOrderParams[] memory params, address to, uint256[] memory netIn)
+        internal
+    {
+        uint256 len = params.length;
+        for (uint256 i = 0; i < len; i = _inc1(i)) {
+            token.safeTransferFrom(params[i].order.maker, to, netIn[i]);
+        }
+    }
+
+    function _transferFromMulti(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)) {
+                token.safeTransferFrom(payer, params[i].order.receiver, netOut[i]);
+            }
+        }
+    }
+
+    // ----------------- Getters -----------------
+    function getOnchainParams(address YT) public returns (OnchainParams memory) {
+        uint256 timeToExpiry = IPYieldToken(YT).expiry() - block.timestamp;
+        return OnchainParams({
+            timeToExpiry: timeToExpiry,
+            pyIndex: IPYieldToken(YT).pyIndexCurrent(),
+            feeRecipient: feeRecipient,
+            lnFeeRateRoot: lnFeeRateRoot
+        });
+    }
+
+    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

@@ -0,0 +1,47 @@
+// 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

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

@@ -0,0 +1,48 @@
+// 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: "));
+            }
+        }
+    }
+}