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

package/contracts/core/erc20/PendleERC20Upg.sol

@@ -0,0 +1,334 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/ERC20.sol)
+
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import "@openzeppelin/contracts/utils/Context.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+
+/**
+ * @dev Pendle's ERC20 implementation, modified from @openzeppelin implementation
+ * Changes are:
+ * - comes with built-in reentrancy protection, storage-packed with totalSupply variable
+ * - delete increaseAllowance / decreaseAllowance
+ * - add nonReentrancy protection to transfer / transferFrom functions
+ * - allow decimals to be passed in
+ * - block self-transfer by default
+ */
+// solhint-disable
+abstract contract PendleERC20Upg is Context, Initializable, IERC20, IERC20Metadata {
+    uint8 private constant _NOT_ENTERED = 1;
+    uint8 private constant _ENTERED = 2;
+
+    mapping(address => uint256) private _balances;
+
+    mapping(address => mapping(address => uint256)) private _allowances;
+
+    uint248 private _totalSupply;
+    uint8 private _status;
+
+    string private _name;
+    string private _symbol;
+    uint8 public immutable decimals;
+
+    uint256[100] private __gap;
+
+    /**
+     * @dev Prevents a contract from calling itself, directly or indirectly.
+     * Calling a `nonReentrant` function from another `nonReentrant`
+     * function is not supported. It is possible to prevent this from happening
+     * by making the `nonReentrant` function external, and making it call a
+     * `private` function that does the actual work.
+     */
+    modifier nonReentrant() {
+        // On the first call to nonReentrant, _notEntered will be true
+        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
+
+        // Any calls to nonReentrant after this point will fail
+        _status = _ENTERED;
+
+        _;
+
+        // By storing the original value once again, a refund is triggered (see
+        // https://eips.ethereum.org/EIPS/eip-2200)
+        _status = _NOT_ENTERED;
+    }
+
+    /**
+     * @dev Sets the values for {name}, {symbol} and {decimals}.
+     *
+     * All three of these values are immutable: they can only be set once during
+     * construction.
+     */
+    constructor(uint8 decimals_) {
+        decimals = decimals_;
+    }
+
+    /**
+     * @dev Sets the values for {name} and {symbol}.
+     *
+     * The default value of {decimals} is 18. To select a different value for
+     * {decimals} you should overload it.
+     *
+     * All two of these values are immutable: they can only be set once during
+     * construction.
+     */
+    function __ERC20Upg_init(string memory name_, string memory symbol_) internal onlyInitializing {
+        _name = name_;
+        _symbol = symbol_;
+        _status = _NOT_ENTERED;
+    }
+
+    /**
+     * @dev Returns the name of the token.
+     */
+    function name() public view virtual override returns (string memory) {
+        return _name;
+    }
+
+    /**
+     * @dev Returns the symbol of the token, usually a shorter version of the
+     * name.
+     */
+    function symbol() public view virtual override returns (string memory) {
+        return _symbol;
+    }
+
+    /**
+     * @dev See {IERC20-totalSupply}.
+     */
+    function totalSupply() public view virtual override returns (uint256) {
+        return _totalSupply;
+    }
+
+    /**
+     * @dev See {IERC20-balanceOf}.
+     */
+    function balanceOf(address account) public view virtual override returns (uint256) {
+        return _balances[account];
+    }
+
+    /**
+     * @dev See {IERC20-transfer}.
+     *
+     * Requirements:
+     *
+     * - `to` cannot be the zero address.
+     * - the caller must have a balance of at least `amount`.
+     */
+    function transfer(address to, uint256 amount) external virtual override nonReentrant returns (bool) {
+        address owner = _msgSender();
+        _transfer(owner, to, amount);
+        return true;
+    }
+
+    /**
+     * @dev See {IERC20-allowance}.
+     */
+    function allowance(address owner, address spender) public view virtual override returns (uint256) {
+        return _allowances[owner][spender];
+    }
+
+    /**
+     * @dev See {IERC20-approve}.
+     *
+     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
+     * `transferFrom`. This is semantically equivalent to an infinite approval.
+     *
+     * Requirements:
+     *
+     * - `spender` cannot be the zero address.
+     */
+    function approve(address spender, uint256 amount) external virtual override returns (bool) {
+        address owner = _msgSender();
+        _approve(owner, spender, amount);
+        return true;
+    }
+
+    /**
+     * @dev See {IERC20-transferFrom}.
+     *
+     * Emits an {Approval} event indicating the updated allowance. This is not
+     * required by the EIP. See the note at the beginning of {ERC20}.
+     *
+     * NOTE: Does not update the allowance if the current allowance
+     * is the maximum `uint256`.
+     *
+     * Requirements:
+     *
+     * - `from` and `to` cannot be the zero address.
+     * - `from` must have a balance of at least `amount`.
+     * - the caller must have allowance for ``from``'s tokens of at least
+     * `amount`.
+     */
+    function transferFrom(
+        address from,
+        address to,
+        uint256 amount
+    ) external virtual override nonReentrant returns (bool) {
+        address spender = _msgSender();
+        _spendAllowance(from, spender, amount);
+        _transfer(from, to, amount);
+        return true;
+    }
+
+    /**
+     * @dev Moves `amount` of tokens from `sender` to `recipient`.
+     *
+     * This internal function is equivalent to {transfer}, and can be used to
+     * e.g. implement automatic token fees, slashing mechanisms, etc.
+     *
+     * Emits a {Transfer} event.
+     *
+     * Requirements:
+     *
+     * - `from` cannot be the zero address.
+     * - `to` cannot be the zero address.
+     * - `from` must have a balance of at least `amount`.
+     */
+    function _transfer(address from, address to, uint256 amount) internal virtual {
+        require(from != address(0), "ERC20: transfer from the zero address");
+        require(to != address(0), "ERC20: transfer to the zero address");
+        require(from != to, "ERC20: transfer to self");
+
+        _beforeTokenTransfer(from, to, amount);
+
+        uint256 fromBalance = _balances[from];
+        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
+        unchecked {
+            _balances[from] = fromBalance - amount;
+        }
+        _balances[to] += amount;
+
+        emit Transfer(from, to, amount);
+
+        _afterTokenTransfer(from, to, amount);
+    }
+
+    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
+     * the total supply.
+     *
+     * Emits a {Transfer} event with `from` set to the zero address.
+     *
+     * Requirements:
+     *
+     * - `account` cannot be the zero address.
+     */
+    function _mint(address account, uint256 amount) internal virtual {
+        require(account != address(0), "ERC20: mint to the zero address");
+
+        _beforeTokenTransfer(address(0), account, amount);
+
+        _totalSupply += toUint248(amount);
+        _balances[account] += amount;
+        emit Transfer(address(0), account, amount);
+
+        _afterTokenTransfer(address(0), account, amount);
+    }
+
+    /**
+     * @dev Destroys `amount` tokens from `account`, reducing the
+     * total supply.
+     *
+     * Emits a {Transfer} event with `to` set to the zero address.
+     *
+     * Requirements:
+     *
+     * - `account` cannot be the zero address.
+     * - `account` must have at least `amount` tokens.
+     */
+    function _burn(address account, uint256 amount) internal virtual {
+        require(account != address(0), "ERC20: burn from the zero address");
+
+        _beforeTokenTransfer(account, address(0), amount);
+
+        uint256 accountBalance = _balances[account];
+        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
+        unchecked {
+            _balances[account] = accountBalance - amount;
+        }
+        _totalSupply -= toUint248(amount);
+
+        emit Transfer(account, address(0), amount);
+
+        _afterTokenTransfer(account, address(0), amount);
+    }
+
+    /**
+     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
+     *
+     * This internal function is equivalent to `approve`, and can be used to
+     * e.g. set automatic allowances for certain subsystems, etc.
+     *
+     * Emits an {Approval} event.
+     *
+     * Requirements:
+     *
+     * - `owner` cannot be the zero address.
+     * - `spender` cannot be the zero address.
+     */
+    function _approve(address owner, address spender, uint256 amount) internal virtual {
+        require(owner != address(0), "ERC20: approve from the zero address");
+        require(spender != address(0), "ERC20: approve to the zero address");
+
+        _allowances[owner][spender] = amount;
+        emit Approval(owner, spender, amount);
+    }
+
+    /**
+     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.
+     *
+     * Does not update the allowance amount in case of infinite allowance.
+     * Revert if not enough allowance is available.
+     *
+     * Might emit an {Approval} event.
+     */
+    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
+        uint256 currentAllowance = allowance(owner, spender);
+        if (currentAllowance != type(uint256).max) {
+            require(currentAllowance >= amount, "ERC20: insufficient allowance");
+            unchecked {
+                _approve(owner, spender, currentAllowance - amount);
+            }
+        }
+    }
+
+    /**
+     * @dev Hook that is called before any transfer of tokens. This includes
+     * minting and burning.
+     *
+     * Calling conditions:
+     *
+     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
+     * will be transferred to `to`.
+     * - when `from` is zero, `amount` tokens will be minted for `to`.
+     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
+     * - `from` and `to` are never both zero.
+     *
+     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
+     */
+    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
+
+    /**
+     * @dev Hook that is called after any transfer of tokens. This includes
+     * minting and burning.
+     *
+     * Calling conditions:
+     *
+     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
+     * has been transferred to `to`.
+     * - when `from` is zero, `amount` tokens have been minted for `to`.
+     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
+     * - `from` and `to` are never both zero.
+     *
+     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
+     */
+    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
+
+    function toUint248(uint256 x) internal virtual returns (uint248) {
+        require(x <= type(uint248).max); // signed, lim = bit-1
+        return uint248(x);
+    }
+}

package/contracts/core/libraries/ArrayLib.sol

@@ -25,10 +25,7 @@ library ArrayLib {
         return type(uint256).max;
     }
 
-    function append(
-        address[] memory inp,
-        address element
-    ) internal pure returns (address[] memory out) {
+    function append(address[] memory inp, address element) internal pure returns (address[] memory out) {
         uint256 length = inp.length;
         out = new address[](length + 1);
         for (uint256 i = 0; i < length; ) {
@@ -46,10 +43,7 @@ library ArrayLib {
      * @param b array of addresses b
      * @return out Concatenation of a and b containing unidentical elements
      */
-    function merge(
-        address[] memory a,
-        address[] memory b
-    ) internal pure returns (address[] memory out) {
+    function merge(address[] memory a, address[] memory b) internal pure returns (address[] memory out) {
         unchecked {
             uint256 countUnidenticalB = 0;
             bool[] memory isUnidentical = new bool[](b.length);
@@ -106,4 +100,9 @@ library ArrayLib {
         res[0] = a;
         res[1] = b;
     }
+
+    function create(uint256 a) internal pure returns (uint256[] memory res) {
+        res = new uint256[](1);
+        res[0] = a;
+    }
 }

package/contracts/core/libraries/BaseSplitCodeFactory.sol

@@ -215,12 +215,7 @@ library BaseSplitCodeFactory {
                 // Next, we concatenate the creation code stored in A and B.
                 let dataStart := add(code, 32)
                 extcodecopy(creationCodeContractA, dataStart, 0, creationCodeSizeA)
-                extcodecopy(
-                    creationCodeContractB,
-                    add(dataStart, creationCodeSizeA),
-                    0,
-                    creationCodeSizeB
-                )
+                extcodecopy(creationCodeContractB, add(dataStart, creationCodeSizeA), 0, creationCodeSizeB)
             }
 
             // Finally, we copy the constructorArgs to the end of the array. Unfortunately there is no way to avoid this

package/contracts/core/libraries/Errors.sol

@@ -2,11 +2,27 @@
 pragma solidity ^0.8.0;
 
 library Errors {
+    // BulkSeller
+    error BulkInsufficientSyForTrade(uint256 currentAmount, uint256 requiredAmount);
+    error BulkInsufficientTokenForTrade(uint256 currentAmount, uint256 requiredAmount);
+    error BulkInSufficientSyOut(uint256 actualSyOut, uint256 requiredSyOut);
+    error BulkInSufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
+    error BulkInsufficientSyReceived(uint256 actualBalance, uint256 requiredBalance);
+    error BulkNotMaintainer();
+    error BulkNotAdmin();
+    error BulkSellerAlreadyExisted(address token, address SY, address bulk);
+    error BulkSellerInvalidToken(address token, address SY);
+    error BulkBadRateTokenToSy(uint256 actualRate, uint256 currentRate, uint256 eps);
+    error BulkBadRateSyToToken(uint256 actualRate, uint256 currentRate, uint256 eps);
+
     // APPROX
     error ApproxFail();
     error ApproxParamsInvalid(uint256 guessMin, uint256 guessMax, uint256 eps);
     error ApproxBinarySearchInputInvalid(
-        uint256 approxGuessMin, uint256 approxGuessMax, uint256 minGuessMin, uint256 maxGuessMax
+        uint256 approxGuessMin,
+        uint256 approxGuessMax,
+        uint256 minGuessMin,
+        uint256 maxGuessMax
     );
 
     // MARKET + MARKET MATH CORE
@@ -33,9 +49,11 @@ library Errors {
     error MarketFactoryMarketExists();
 
     error MarketFactoryLnFeeRateRootTooHigh(uint80 lnFeeRateRoot, uint256 maxLnFeeRateRoot);
+    error MarketFactoryOverriddenFeeTooHigh(uint80 overriddenFee, uint256 marketLnFeeRateRoot);
     error MarketFactoryReserveFeePercentTooHigh(uint8 reserveFeePercent, uint8 maxReserveFeePercent);
     error MarketFactoryZeroTreasury();
     error MarketFactoryInitialAnchorTooLow(int256 initialAnchor, int256 minInitialAnchor);
+    error MFNotPendleMarket(address addr);
 
     // ROUTER
     error RouterInsufficientLpOut(uint256 actualLpOut, uint256 requiredLpOut);
@@ -44,6 +62,9 @@ library Errors {
     error RouterInsufficientYtOut(uint256 actualYtOut, uint256 requiredYtOut);
     error RouterInsufficientPYOut(uint256 actualPYOut, uint256 requiredPYOut);
     error RouterInsufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
+    error RouterExceededLimitSyIn(uint256 actualSyIn, uint256 limitSyIn);
+    error RouterExceededLimitPtIn(uint256 actualPtIn, uint256 limitPtIn);
+    error RouterExceededLimitYtIn(uint256 actualYtIn, uint256 limitYtIn);
     error RouterInsufficientSyRepay(uint256 actualSyRepay, uint256 requiredSyRepay);
     error RouterInsufficientPtRepay(uint256 actualPtRepay, uint256 requiredPtRepay);
     error RouterNotAllSyUsed(uint256 netSyDesired, uint256 netSyUsed);
@@ -55,8 +76,6 @@ library Errors {
 
     error RouterKyberSwapDataZero();
 
-    error CallThenRevertError(bool success, bytes res);
-
     // YIELD CONTRACT
     error YCExpired();
     error YCNotExpired();

package/contracts/core/libraries/ExpiryUtilsLib.sol

@@ -28,9 +28,7 @@ library ExpiryUtils {
         uint256 _expiry,
         string memory _delimiter
     ) internal pure returns (string memory result) {
-        result = string(
-            abi.encodePacked(_bt, _delimiter, _yt, _delimiter, toRFC2822String(_expiry))
-        );
+        result = string(abi.encodePacked(_bt, _delimiter, _yt, _delimiter, toRFC2822String(_expiry)));
     }
 
     function toRFC2822String(uint256 _timestamp) internal pure returns (string memory s) {
@@ -42,15 +40,7 @@ library ExpiryUtils {
     }
 
     function getDaysInMonth(uint8 _month, uint16 _year) private pure returns (uint8) {
-        if (
-            _month == 1 ||
-            _month == 3 ||
-            _month == 5 ||
-            _month == 7 ||
-            _month == 8 ||
-            _month == 10 ||
-            _month == 12
-        ) {
+        if (_month == 1 || _month == 3 || _month == 5 || _month == 7 || _month == 8 || _month == 10 || _month == 12) {
             return 31;
         } else if (_month == 4 || _month == 6 || _month == 9 || _month == 11) {
             return 30;
@@ -94,20 +84,7 @@ library ExpiryUtils {
     }
 
     function monthName(Date memory d) private pure returns (string memory) {
-        string[12] memory months = [
-            "JAN",
-            "FEB",
-            "MAR",
-            "APR",
-            "MAY",
-            "JUN",
-            "JUL",
-            "AUG",
-            "SEP",
-            "OCT",
-            "NOV",
-            "DEC"
-        ];
+        string[12] memory months = ["JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"];
         return months[d.month - 1];
     }
 

package/contracts/core/libraries/StringLib.sol

@@ -621,11 +621,7 @@ library StringLib {
      * @param token An output parameter to which the first token is written.
      * @return `token`.
      */
-    function split(
-        slice memory self,
-        slice memory needle,
-        slice memory token
-    ) internal pure returns (slice memory) {
+    function split(slice memory self, slice memory needle, slice memory token) internal pure returns (slice memory) {
         uint256 ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
         token._ptr = self._ptr;
         token._len = ptr - self._ptr;
@@ -648,10 +644,7 @@ library StringLib {
      * @param needle The text to search for in `self`.
      * @return The part of `self` up to the first occurrence of `delim`.
      */
-    function split(
-        slice memory self,
-        slice memory needle
-    ) internal pure returns (slice memory token) {
+    function split(slice memory self, slice memory needle) internal pure returns (slice memory token) {
         split(self, needle, token);
     }
 
@@ -665,11 +658,7 @@ library StringLib {
      * @param token An output parameter to which the first token is written.
      * @return `token`.
      */
-    function rsplit(
-        slice memory self,
-        slice memory needle,
-        slice memory token
-    ) internal pure returns (slice memory) {
+    function rsplit(slice memory self, slice memory needle, slice memory token) internal pure returns (slice memory) {
         uint256 ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
         token._ptr = ptr;
         token._len = self._len - (ptr - self._ptr);
@@ -691,10 +680,7 @@ library StringLib {
      * @param needle The text to search for in `self`.
      * @return The part of `self` after the last occurrence of `delim`.
      */
-    function rsplit(
-        slice memory self,
-        slice memory needle
-    ) internal pure returns (slice memory token) {
+    function rsplit(slice memory self, slice memory needle) internal pure returns (slice memory token) {
         rsplit(self, needle, token);
     }
 
@@ -708,9 +694,7 @@ library StringLib {
         uint256 ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr) + needle._len;
         while (ptr <= self._ptr + self._len) {
             cnt++;
-            ptr =
-                findPtr(self._len - (ptr - self._ptr), ptr, needle._len, needle._ptr) +
-                needle._len;
+            ptr = findPtr(self._len - (ptr - self._ptr), ptr, needle._len, needle._ptr) + needle._len;
         }
     }
 

package/contracts/core/libraries/TokenHelper.sol

@@ -1,13 +1,11 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
-
 import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import "../../interfaces/IWETH.sol";
 
 abstract contract TokenHelper {
     using SafeERC20 for IERC20;
-
     address internal constant NATIVE = address(0);
     uint256 internal constant LOWER_BOUND_APPROVAL = type(uint96).max / 2; // some tokens use 96 bits for approval
 
@@ -17,13 +15,13 @@ abstract contract TokenHelper {
     }
 
     function _transferFrom(IERC20 token, address from, address to, uint256 amount) internal {
-        if (amount != 0 && from != address(this)) token.safeTransferFrom(from, to, amount);
+        if (amount != 0) token.safeTransferFrom(from, to, amount);
     }
 
     function _transferOut(address token, address to, uint256 amount) internal {
         if (amount == 0) return;
         if (token == NATIVE) {
-            (bool success,) = to.call{value: amount}("");
+            (bool success, ) = to.call{value: amount}("");
             require(success, "eth send failed");
         } else {
             IERC20(token).safeTransfer(to, amount);
@@ -33,7 +31,7 @@ abstract contract TokenHelper {
     function _transferOut(address[] memory tokens, address to, uint256[] memory amounts) internal {
         uint256 numTokens = tokens.length;
         require(numTokens == amounts.length, "length mismatch");
-        for (uint256 i = 0; i < numTokens;) {
+        for (uint256 i = 0; i < numTokens; ) {
             _transferOut(tokens[i], to, amounts[i]);
             unchecked {
                 i++;

package/contracts/core/libraries/math/LogExpMath.sol

@@ -281,10 +281,7 @@ library LogExpMath {
                 // bring y_int256 to 36 decimal places, as it might overflow. Instead, we perform two 18 decimal
                 // multiplications and add the results: one with the first 18 decimals of ln_36_x, and one with the
                 // (downscaled) last 18 decimals.
-                logx_times_y = ((ln_36_x / ONE_18) *
-                    y_int256 +
-                    ((ln_36_x % ONE_18) * y_int256) /
-                    ONE_18);
+                logx_times_y = ((ln_36_x / ONE_18) * y_int256 + ((ln_36_x % ONE_18) * y_int256) / ONE_18);
             } else {
                 logx_times_y = _ln(x_int256) * y_int256;
             }

package/contracts/core/libraries/math/PMath.sol

@@ -145,6 +145,11 @@ library PMath {
         return uint32(x);
     }
 
+    function Uint64(uint256 x) internal pure returns (uint64) {
+        require(x <= type(uint64).max);
+        return uint64(x);
+    }
+
     function Uint112(uint256 x) internal pure returns (uint112) {
         require(x <= type(uint112).max);
         return uint112(x);
@@ -160,27 +165,20 @@ library PMath {
         return uint128(x);
     }
 
-    function isAApproxB(
-        uint256 a,
-        uint256 b,
-        uint256 eps
-    ) internal pure returns (bool) {
+    function Uint192(uint256 x) internal pure returns (uint192) {
+        require(x <= type(uint192).max);
+        return uint192(x);
+    }
+
+    function isAApproxB(uint256 a, uint256 b, uint256 eps) internal pure returns (bool) {
         return mulDown(b, ONE - eps) <= a && a <= mulDown(b, ONE + eps);
     }
 
-    function isAGreaterApproxB(
-        uint256 a,
-        uint256 b,
-        uint256 eps
-    ) internal pure returns (bool) {
+    function isAGreaterApproxB(uint256 a, uint256 b, uint256 eps) internal pure returns (bool) {
         return a >= b && a <= mulDown(b, ONE + eps);
     }
 
-    function isASmallerApproxB(
-        uint256 a,
-        uint256 b,
-        uint256 eps
-    ) internal pure returns (bool) {
+    function isASmallerApproxB(uint256 a, uint256 b, uint256 eps) internal pure returns (bool) {
         return a <= b && a >= mulDown(b, ONE - eps);
     }
 }

package/contracts/interfaces/Balancer/IComposableStable.sol

@@ -16,10 +16,9 @@ interface IComposableStable is IBasePool {
 
     function isTokenExemptFromYieldProtocolFee(IERC20 token) external view returns (bool);
 
-    function getTokenRateCache(IERC20 token)
-        external
-        view
-        returns (uint256 rate, uint256 oldRate, uint256 duration, uint256 expires);
+    function getTokenRateCache(
+        IERC20 token
+    ) external view returns (uint256 rate, uint256 oldRate, uint256 duration, uint256 expires);
 
     function getRateProviders() external view returns (IRateProvider[] memory);