@pendle/core-v2 2.29.4 → 2.30.1

package/contracts/core/YieldContractsV2/InterestManagerYTV2.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../../interfaces/IPYieldToken.sol";
 import "../../interfaces/IPPrincipalToken.sol";
@@ -44,27 +44,18 @@ abstract contract InterestManagerYTV2 is TokenHelper, IPInterestManagerYTV2 {
     function _updateAndDistributeInterestForTwo(address user1, address user2) internal virtual {
         (uint256 index, uint256 pyIndex) = _updateInterestIndex();
 
-        if (user1 != address(0) && user1 != address(this))
-            _distributeInterestPrivate(user1, index, pyIndex);
-        if (user2 != address(0) && user2 != address(this))
-            _distributeInterestPrivate(user2, index, pyIndex);
+        if (user1 != address(0) && user1 != address(this)) _distributeInterestPrivate(user1, index, pyIndex);
+        if (user2 != address(0) && user2 != address(this)) _distributeInterestPrivate(user2, index, pyIndex);
     }
 
-    function _doTransferOutInterest(
-        address user,
-        address SY
-    ) internal returns (uint256 interestAmount) {
+    function _doTransferOutInterest(address user, address SY) internal returns (uint256 interestAmount) {
         interestAmount = userInterest[user].accrued;
         userInterest[user].accrued = 0;
         _transferOut(SY, user, interestAmount);
     }
 
     // should only be callable from `_distributeInterestForTwo` & make sure user != address(0) && user != address(this)
-    function _distributeInterestPrivate(
-        address user,
-        uint256 currentIndex,
-        uint256 pyIndex
-    ) private {
+    function _distributeInterestPrivate(address user, uint256 currentIndex, uint256 pyIndex) private {
         assert(user != address(0) && user != address(this));
 
         uint256 prevIndex = userInterest[user].index;

package/contracts/core/YieldContractsV2/PendlePrincipalTokenV2.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../../interfaces/IPPrincipalToken.sol";
 import "../../interfaces/IPYieldToken.sol";

package/contracts/core/YieldContractsV2/PendleYieldContractFactoryV2.sol

@@ -21,7 +21,7 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  */
 
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../../interfaces/IPYieldContractFactory.sol";
 
@@ -106,8 +106,7 @@ contract PendleYieldContractFactoryV2 is BoringOwnableUpgradeable, IPYieldContra
         uint32 expiry,
         bool doCacheIndexSameBlock
     ) external returns (address PT, address YT) {
-        if (MiniHelpers.isTimeInThePast(expiry) || expiry % expiryDivisor != 0)
-            revert Errors.YCFactoryInvalidExpiry();
+        if (MiniHelpers.isTimeInThePast(expiry) || expiry % expiryDivisor != 0) revert Errors.YCFactoryInvalidExpiry();
 
         if (getPT[SY][expiry] != address(0)) revert Errors.YCFactoryYieldContractExisted();
 

package/contracts/core/YieldContractsV2/PendleYieldTokenV2.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
@@ -23,12 +23,7 @@ Invariance to maintain:
 - address(0) & address(this) should never have any rewards & activeBalance accounting done. This is
     guaranteed by address(0) & address(this) check in each updateForTwo function
 */
-contract PendleYieldTokenV2 is
-    IPYieldTokenV2,
-    PendleERC20Permit,
-    RewardManager,
-    InterestManagerYTV2
-{
+contract PendleYieldTokenV2 is IPYieldTokenV2, PendleERC20Permit, RewardManager, InterestManagerYTV2 {
     using PMath for uint256;
     using SafeERC20 for IERC20;
     using ArrayLib for uint256[];
@@ -97,11 +92,7 @@ contract PendleYieldTokenV2 is
         address[] memory receiverYTs = new address[](1);
         uint256[] memory amountSyToMints = new uint256[](1);
 
-        (receiverPTs[0], receiverYTs[0], amountSyToMints[0]) = (
-            receiverPT,
-            receiverYT,
-            _getFloatingSyAmount()
-        );
+        (receiverPTs[0], receiverYTs[0], amountSyToMints[0]) = (receiverPT, receiverYT, _getFloatingSyAmount());
 
         uint256[] memory amountPYOuts = _mintPY(receiverPTs, receiverYTs, amountSyToMints);
         amountPYOut = amountPYOuts[0];
@@ -116,8 +107,7 @@ contract PendleYieldTokenV2 is
         uint256 length = receiverPTs.length;
 
         if (length == 0) revert Errors.ArrayEmpty();
-        if (receiverYTs.length != length || amountSyToMints.length != length)
-            revert Errors.ArrayLengthMismatch();
+        if (receiverYTs.length != length || amountSyToMints.length != length) revert Errors.ArrayLengthMismatch();
 
         uint256 totalSyToMint = amountSyToMints.sum();
         if (totalSyToMint > _getFloatingSyAmount())
@@ -131,9 +121,7 @@ contract PendleYieldTokenV2 is
      * same time
      * @dev PT/YT must be transferred to this contract prior to calling
      */
-    function redeemPY(
-        address receiver
-    ) external nonReentrant updateData returns (uint256 amountSyOut) {
+    function redeemPY(address receiver) external nonReentrant updateData returns (uint256 amountSyOut) {
         address[] memory receivers = new address[](1);
         uint256[] memory amounts = new uint256[](1);
         (receivers[0], amounts[0]) = (receiver, _getAmountPYToRedeem());
@@ -264,13 +252,7 @@ contract PendleYieldTokenV2 is
             _mint(receiverYTs[i], amountPYOuts[i]);
             IPPrincipalToken(PT).mintByYT(receiverPTs[i], amountPYOuts[i]);
 
-            emit Mint(
-                msg.sender,
-                receiverPTs[i],
-                receiverYTs[i],
-                amountSyToMints[i],
-                amountPYOuts[i]
-            );
+            emit Mint(msg.sender, receiverPTs[i], receiverYTs[i], amountSyToMints[i], amountPYOuts[i]);
         }
     }
 
@@ -296,10 +278,7 @@ contract PendleYieldTokenV2 is
 
         for (uint256 i = 0; i < receivers.length; i++) {
             uint256 syInterestPostExpiry;
-            (amountSyOuts[i], syInterestPostExpiry) = _calcSyRedeemableFromPY(
-                amountPYToRedeems[i],
-                index
-            );
+            (amountSyOuts[i], syInterestPostExpiry) = _calcSyRedeemableFromPY(amountPYToRedeems[i], index);
             _transferOut(SY, receivers[i], amountSyOuts[i]);
             totalSyInterestPostExpiry += syInterestPostExpiry;
 
@@ -310,10 +289,7 @@ contract PendleYieldTokenV2 is
         _transferOut(SY, treasury, totalSyInterestPostExpiry);
     }
 
-    function _calcPYToMint(
-        uint256 amountSy,
-        uint256 indexCurrent
-    ) internal pure returns (uint256 amountPY) {
+    function _calcPYToMint(uint256 amountSy, uint256 indexCurrent) internal pure returns (uint256 amountPY) {
         // doesn't matter before or after expiry, since mintPY is only allowed before expiry
         return SYUtils.syToAsset(indexCurrent, amountSy);
     }
@@ -359,23 +335,16 @@ contract PendleYieldTokenV2 is
     //////////////////////////////////////////////////////////////*/
 
     function _pyIndexCurrent() internal returns (uint256 currentIndex) {
-        if (doCacheIndexSameBlock && pyIndexLastUpdatedBlock == block.number)
-            return _pyIndexStored;
+        if (doCacheIndexSameBlock && pyIndexLastUpdatedBlock == block.number) return _pyIndexStored;
 
-        uint128 index128 = PMath
-            .max(IStandardizedYield(SY).exchangeRate(), _pyIndexStored)
-            .Uint128();
+        uint128 index128 = PMath.max(IStandardizedYield(SY).exchangeRate(), _pyIndexStored).Uint128();
 
         currentIndex = index128;
         _pyIndexStored = index128;
         pyIndexLastUpdatedBlock = uint128(block.number);
     }
 
-    function _collectInterest()
-        internal
-        override
-        returns (uint256 accuredAmount, uint256 currentIndex)
-    {
+    function _collectInterest() internal override returns (uint256 accuredAmount, uint256 currentIndex) {
         uint256 prevIndex = _lastCollectedInterestIndex;
         currentIndex = _pyIndexCurrent();
 
@@ -398,11 +367,7 @@ contract PendleYieldTokenV2 is
         _lastCollectedInterestIndex = currentIndex;
     }
 
-    function _calcInterest(
-        uint256 principal,
-        uint256 prevIndex,
-        uint256 currentIndex
-    ) internal pure returns (uint256) {
+    function _calcInterest(uint256 principal, uint256 prevIndex, uint256 currentIndex) internal pure returns (uint256) {
         return (principal * (currentIndex - prevIndex)).divDown(prevIndex * currentIndex);
     }
 

package/contracts/core/erc20/PendleERC20.sol

@@ -103,10 +103,7 @@ contract PendleERC20 is Context, IERC20, IERC20Metadata {
      * - `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) {
+    function transfer(address to, uint256 amount) external virtual override nonReentrant returns (bool) {
         address owner = _msgSender();
         _transfer(owner, to, amount);
         return true;
@@ -115,10 +112,7 @@ contract PendleERC20 is Context, IERC20, IERC20Metadata {
     /**
      * @dev See {IERC20-allowance}.
      */
-    function allowance(
-        address owner,
-        address spender
-    ) public view virtual override returns (uint256) {
+    function allowance(address owner, address spender) public view virtual override returns (uint256) {
         return _allowances[owner][spender];
     }
 

package/contracts/core/erc20/PendleERC20Permit.sol

@@ -20,9 +20,7 @@ contract PendleERC20Permit is PendleERC20, IERC20Permit, EIP712 {
 
     // solhint-disable-next-line var-name-mixedcase
     bytes32 private constant _PERMIT_TYPEHASH =
-        keccak256(
-            "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
-        );
+        keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
 
     constructor(
         string memory name_,
@@ -44,9 +42,7 @@ contract PendleERC20Permit is PendleERC20, IERC20Permit, EIP712 {
     ) public virtual override {
         require(block.timestamp <= deadline, "ERC20Permit: expired deadline");
 
-        bytes32 structHash = keccak256(
-            abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline)
-        );
+        bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));
 
         bytes32 hash = _hashTypedDataV4(structHash);
 

package/contracts/core/erc20/PendleERC20PermitUpg.sol

@@ -23,10 +23,7 @@ abstract contract PendleERC20PermitUpg is PendleERC20Upg, IERC20Permit, EIP712Up
 
     // solhint-disable-next-line var-name-mixedcase
     bytes32 private constant _PERMIT_TYPEHASH =
-        keccak256(
-            "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
-        );
-
+        keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
 
     function __ERC20PermitUpg_init(string memory name_, string memory symbol_) internal onlyInitializing {
         __ERC20Upg_init(name_, symbol_);
@@ -47,9 +44,7 @@ abstract contract PendleERC20PermitUpg is PendleERC20Upg, IERC20Permit, EIP712Up
     ) public virtual override {
         require(block.timestamp <= deadline, "ERC20Permit: expired deadline");
 
-        bytes32 structHash = keccak256(
-            abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline)
-        );
+        bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));
 
         bytes32 hash = _hashTypedDataV4(structHash);
 

package/contracts/core/erc20/PendleERC20Upg.sol

@@ -62,7 +62,7 @@ abstract contract PendleERC20Upg is Context, Initializable, IERC20, IERC20Metada
      * All three of these values are immutable: they can only be set once during
      * construction.
      */
-    constructor(uint8 decimals_)  {
+    constructor(uint8 decimals_) {
         decimals = decimals_;
     }
 
@@ -118,10 +118,7 @@ abstract contract PendleERC20Upg is Context, Initializable, IERC20, IERC20Metada
      * - `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) {
+    function transfer(address to, uint256 amount) external virtual override nonReentrant returns (bool) {
         address owner = _msgSender();
         _transfer(owner, to, amount);
         return true;
@@ -130,10 +127,7 @@ abstract contract PendleERC20Upg is Context, Initializable, IERC20, IERC20Metada
     /**
      * @dev See {IERC20-allowance}.
      */
-    function allowance(
-        address owner,
-        address spender
-    ) public view virtual override returns (uint256) {
+    function allowance(address owner, address spender) public view virtual override returns (uint256) {
         return _allowances[owner][spender];
     }
 

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);

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

@@ -49,10 +49,7 @@ library Errors {
     error MarketFactoryMarketExists();
 
     error MarketFactoryLnFeeRateRootTooHigh(uint80 lnFeeRateRoot, uint256 maxLnFeeRateRoot);
-    error MarketFactoryReserveFeePercentTooHigh(
-        uint8 reserveFeePercent,
-        uint8 maxReserveFeePercent
-    );
+    error MarketFactoryReserveFeePercentTooHigh(uint8 reserveFeePercent, uint8 maxReserveFeePercent);
     error MarketFactoryZeroTreasury();
     error MarketFactoryInitialAnchorTooLow(int256 initialAnchor, int256 minInitialAnchor);
 

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

@@ -21,7 +21,7 @@ abstract contract TokenHelper {
     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);
@@ -50,9 +50,7 @@ abstract contract TokenHelper {
     /// @notice Approves the stipulated contract to spend the given allowance in the given token
     /// @dev PLS PAY ATTENTION to tokens that requires the approval to be set to 0 before changing it
     function _safeApprove(address token, address to, uint256 value) internal {
-        (bool success, bytes memory data) = token.call(
-            abi.encodeWithSelector(IERC20.approve.selector, to, value)
-        );
+        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.approve.selector, to, value));
         require(success && (data.length == 0 || abi.decode(data, (bool))), "Safe Approve");
     }
 
@@ -65,7 +63,7 @@ abstract contract TokenHelper {
     }
 
     function _wrap_unwrap_ETH(address tokenIn, address tokenOut, uint256 netTokenIn) internal {
-        if (tokenIn == NATIVE) IWETH(tokenOut).deposit{ value: netTokenIn }();
+        if (tokenIn == NATIVE) IWETH(tokenOut).deposit{value: netTokenIn}();
         else IWETH(tokenIn).withdraw(netTokenIn);
     }
 }

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);
 

package/contracts/interfaces/Balancer/IERC4626LinearPool.sol

@@ -56,11 +56,7 @@ interface IERC4626LinearPool {
     function getPausedState()
         external
         view
-        returns (
-            bool paused,
-            uint256 pauseWindowEndTime,
-            uint256 bufferPeriodEndTime
-        );
+        returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
 
     function getPoolId() external view returns (bytes32);
 
@@ -169,11 +165,7 @@ interface IERC4626LinearPool {
 
     function transfer(address recipient, uint256 amount) external returns (bool);
 
-    function transferFrom(
-        address sender,
-        address recipient,
-        uint256 amount
-    ) external returns (bool);
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
 
     function unpause() external;
 

package/contracts/interfaces/Balancer/IMetaStablePool.sol

@@ -4,19 +4,11 @@ pragma solidity ^0.8.0;
 import "./IBasePool.sol";
 
 interface IMetaStablePool is IBasePool {
-    function getLastInvariant()
-        external
-        view
-        returns (uint256 lastInvariant, uint256 lastInvariantAmp);
+    function getLastInvariant() external view returns (uint256 lastInvariant, uint256 lastInvariantAmp);
 
-    function getAmplificationParameter()
-        external
-        view
-        returns (uint256 value, bool isUpdating, uint256 precision);
+    function getAmplificationParameter() external view returns (uint256 value, bool isUpdating, uint256 precision);
 
     function getSwapFeePercentage() external view returns (uint256);
 
-    function getPriceRateCache(
-        IERC20 token
-    ) external view returns (uint256 rate, uint256 duration, uint256 expires);
+    function getPriceRateCache(IERC20 token) external view returns (uint256 rate, uint256 duration, uint256 expires);
 }

package/contracts/interfaces/Balancer/IVault.sol

@@ -89,14 +89,9 @@ interface IVault {
         uint256 deadline
     ) external payable returns (uint256);
 
-    function getPoolTokens(bytes32 poolId)
-        external
-        view
-        returns (
-            IERC20[] memory tokens,
-            uint256[] memory balances,
-            uint256 lastChangeBlock
-        );
+    function getPoolTokens(
+        bytes32 poolId
+    ) external view returns (IERC20[] memory tokens, uint256[] memory balances, uint256 lastChangeBlock);
 
     function WETH() external view returns (IERC20);
 

package/contracts/interfaces/BinanceEth/IWBETH.sol

@@ -6,4 +6,4 @@ interface IWBETH {
     function deposit(uint256 amount, address referral) external;
 
     function exchangeRate() external view returns (uint256 _exchangeRate);
-}
+}

package/contracts/interfaces/Camelot/ICamelotNFTFactory.sol

@@ -1,4 +1,3 @@
-
 pragma solidity >=0.8.0;
 
 interface ICamelotNFTFactory {
@@ -7,5 +6,4 @@ interface ICamelotNFTFactory {
     function grailToken() external view returns (address);
 
     function xGrailToken() external view returns (address);
-
-}
+}