@pendle/core-v2 6.3.1 → 6.3.2-pendle-merkle-transfer

package/contracts/core/YieldContracts/PendleYieldContractFactoryUpg.sol

@@ -28,11 +28,11 @@ import "../../interfaces/IPYieldContractFactory.sol";
 import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 
-import "../libraries/BaseSplitCodeFactory.sol";
-import "../libraries/BoringOwnableUpgradeableV2.sol";
-import "../libraries/Errors.sol";
 import "../libraries/ExpiryUtilsLib.sol";
+import "../libraries/BaseSplitCodeFactory.sol";
 import "../libraries/MiniHelpers.sol";
+import "../libraries/Errors.sol";
+import "../libraries/BoringOwnableUpgradeableV2.sol";
 import "../libraries/StringLib.sol";
 
 import "./PendlePrincipalToken.sol";
@@ -105,19 +105,18 @@ contract PendleYieldContractFactoryUpg is BoringOwnableUpgradeableV2, IPYieldCon
      * @notice Create a pair of (PT, YT) from any SY and valid expiry. Anyone can create a yield contract
      * @dev It's intentional to make expiry an uint32 to guard against fat fingers. uint32.max is year 2106
      */
-    function createYieldContract(address SY, uint32 expiry, bool doCacheIndexSameBlock)
-        external
-        returns (address PT, address YT)
-    {
-        if (MiniHelpers.isTimeInThePast(expiry) || expiry % expiryDivisor != 0) {
-            revert Errors.YCFactoryInvalidExpiry();
-        }
+    function createYieldContract(
+        address SY,
+        uint32 expiry,
+        bool doCacheIndexSameBlock
+    ) external returns (address PT, address YT) {
+        if (MiniHelpers.isTimeInThePast(expiry) || expiry % expiryDivisor != 0) revert Errors.YCFactoryInvalidExpiry();
 
         if (getPT[SY][expiry] != address(0)) revert Errors.YCFactoryYieldContractExisted();
 
         IStandardizedYield _SY = IStandardizedYield(SY);
 
-        (,, uint8 assetDecimals) = _SY.assetInfo();
+        (, , uint8 assetDecimals) = _SY.assetInfo();
 
         string memory syCoreName = _SY.name().stripPrefix(SY_NAME_PREF);
         string memory syCoreSymbol = _SY.symbol().stripPrefix(SY_SYMBOL_PREF);
@@ -173,18 +172,16 @@ contract PendleYieldContractFactoryUpg is BoringOwnableUpgradeableV2, IPYieldCon
     }
 
     function setInterestFeeRate(uint128 newInterestFeeRate) public onlyOwner {
-        if (newInterestFeeRate > maxInterestFeeRate) {
+        if (newInterestFeeRate > maxInterestFeeRate)
             revert Errors.YCFactoryInterestFeeRateTooHigh(newInterestFeeRate, maxInterestFeeRate);
-        }
 
         interestFeeRate = newInterestFeeRate;
         emit SetInterestFeeRate(newInterestFeeRate);
     }
 
     function setRewardFeeRate(uint128 newRewardFeeRate) public onlyOwner {
-        if (newRewardFeeRate > maxRewardFeeRate) {
+        if (newRewardFeeRate > maxRewardFeeRate)
             revert Errors.YCFactoryRewardFeeRateTooHigh(newRewardFeeRate, maxRewardFeeRate);
-        }
 
         rewardFeeRate = newRewardFeeRate;
         emit SetRewardFeeRate(newRewardFeeRate);

package/contracts/core/YieldContracts/PendleYieldToken.sol

@@ -3,26 +3,26 @@ pragma solidity ^0.8.17;
 
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
-import "../../interfaces/IPPrincipalToken.sol";
-import "../../interfaces/IPYieldToken.sol";
 import "../../interfaces/IStandardizedYield.sol";
+import "../../interfaces/IPYieldToken.sol";
+import "../../interfaces/IPPrincipalToken.sol";
 
+import "../libraries/math/PMath.sol";
+import "../libraries/ArrayLib.sol";
 import "../../interfaces/IPYieldContractFactory.sol";
 import "../StandardizedYield/SYUtils.sol";
-import "../libraries/ArrayLib.sol";
 import "../libraries/Errors.sol";
 import "../libraries/MiniHelpers.sol";
-import "../libraries/math/PMath.sol";
 
 import "../RewardManager/RewardManagerAbstract.sol";
 import "../erc20/PendleERC20.sol";
 import "./InterestManagerYT.sol";
 
 /**
- * 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
- */
+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 PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, InterestManagerYT {
     using PMath for uint256;
     using SafeERC20 for IERC20;
@@ -87,13 +87,10 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
      * @notice Tokenize SY into PT + YT of equal qty. Every unit of asset of SY will create 1 PT + 1 YT
      * @dev SY must be transferred to this contract prior to calling
      */
-    function mintPY(address receiverPT, address receiverYT)
-        external
-        nonReentrant
-        notExpired
-        updateData
-        returns (uint256 amountPYOut)
-    {
+    function mintPY(
+        address receiverPT,
+        address receiverYT
+    ) external nonReentrant notExpired updateData returns (uint256 amountPYOut) {
         address[] memory receiverPTs = new address[](1);
         address[] memory receiverYTs = new address[](1);
         uint256[] memory amountSyToMints = new uint256[](1);
@@ -116,9 +113,8 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
         if (receiverYTs.length != length || amountSyToMints.length != length) revert Errors.ArrayLengthMismatch();
 
         uint256 totalSyToMint = amountSyToMints.sum();
-        if (totalSyToMint > _getFloatingSyAmount()) {
+        if (totalSyToMint > _getFloatingSyAmount())
             revert Errors.YieldContractInsufficientSy(totalSyToMint, _getFloatingSyAmount());
-        }
 
         amountPYOuts = _mintPY(receiverPTs, receiverYTs, amountSyToMints);
     }
@@ -144,12 +140,10 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
      * @dev PT/YT must be transferred to this contract prior to calling
      * @dev fails if unable to redeem the total PY amount in `amountPYToRedeems`
      */
-    function redeemPYMulti(address[] calldata receivers, uint256[] calldata amountPYToRedeems)
-        external
-        nonReentrant
-        updateData
-        returns (uint256[] memory amountSyOuts)
-    {
+    function redeemPYMulti(
+        address[] calldata receivers,
+        uint256[] calldata amountPYToRedeems
+    ) external nonReentrant updateData returns (uint256[] memory amountSyOuts) {
         if (receivers.length != amountPYToRedeems.length) revert Errors.ArrayLengthMismatch();
         if (receivers.length == 0) revert Errors.ArrayEmpty();
         amountSyOuts = _redeemPY(receivers, amountPYToRedeems);
@@ -165,12 +159,11 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
      * time, unless users redeem their dueInterest or redeemPY. Due to this, it is required to
      * update users' accruedReward STRICTLY BEFORE transferring out their interest.
      */
-    function redeemDueInterestAndRewards(address user, bool redeemInterest, bool redeemRewards)
-        external
-        nonReentrant
-        updateData
-        returns (uint256 interestOut, uint256[] memory rewardsOut)
-    {
+    function redeemDueInterestAndRewards(
+        address user,
+        bool redeemInterest,
+        bool redeemRewards
+    ) external nonReentrant updateData returns (uint256 interestOut, uint256[] memory rewardsOut) {
         if (!redeemInterest && !redeemRewards) revert Errors.YCNothingToRedeem();
 
         // if redeemRewards == true, this line must be here for obvious reason
@@ -281,9 +274,7 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
             uint256[] memory userRewardOwed
         )
     {
-        if (postExpiry.firstPYIndex == 0) {
-            revert Errors.YCPostExpiryDataNotSet();
-        }
+        if (postExpiry.firstPYIndex == 0) revert Errors.YCPostExpiryDataNotSet();
 
         firstPYIndex = postExpiry.firstPYIndex;
         totalSyInterestForTreasury = postExpiry.totalSyInterestForTreasury;
@@ -298,10 +289,11 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
         }
     }
 
-    function _mintPY(address[] memory receiverPTs, address[] memory receiverYTs, uint256[] memory amountSyToMints)
-        internal
-        returns (uint256[] memory amountPYOuts)
-    {
+    function _mintPY(
+        address[] memory receiverPTs,
+        address[] memory receiverYTs,
+        uint256[] memory amountSyToMints
+    ) internal returns (uint256[] memory amountPYOuts) {
         amountPYOuts = new uint256[](amountSyToMints.length);
 
         uint256 index = _pyIndexCurrent();
@@ -320,10 +312,10 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
         return MiniHelpers.isCurrentlyExpired(expiry);
     }
 
-    function _redeemPY(address[] memory receivers, uint256[] memory amountPYToRedeems)
-        internal
-        returns (uint256[] memory amountSyOuts)
-    {
+    function _redeemPY(
+        address[] memory receivers,
+        uint256[] memory amountPYToRedeems
+    ) internal returns (uint256[] memory amountSyOuts) {
         uint256 totalAmountPYToRedeem = amountPYToRedeems.sum();
         IPPrincipalToken(PT).burnByYT(address(this), totalAmountPYToRedeem);
         if (!isExpired()) _burn(address(this), totalAmountPYToRedeem);
@@ -350,11 +342,10 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
         return SYUtils.syToAsset(indexCurrent, amountSy);
     }
 
-    function _calcSyRedeemableFromPY(uint256 amountPY, uint256 indexCurrent)
-        internal
-        view
-        returns (uint256 syToUser, uint256 syInterestPostExpiry)
-    {
+    function _calcSyRedeemableFromPY(
+        uint256 amountPY,
+        uint256 indexCurrent
+    ) internal view returns (uint256 syToUser, uint256 syInterestPostExpiry) {
         syToUser = SYUtils.assetToSy(indexCurrent, amountPY);
         if (isExpired()) {
             uint256 totalSyRedeemable = SYUtils.assetToSy(postExpiry.firstPYIndex, amountPY);
@@ -424,12 +415,10 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
         return IStandardizedYield(SY).getRewardTokens();
     }
 
-    function _doTransferOutRewards(address user, address receiver)
-        internal
-        virtual
-        override
-        returns (uint256[] memory rewardAmounts)
-    {
+    function _doTransferOutRewards(
+        address user,
+        address receiver
+    ) internal virtual override returns (uint256[] memory rewardAmounts) {
         address[] memory tokens = getRewardTokens();
 
         if (isExpired()) {
@@ -493,9 +482,7 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
         tokens = getRewardTokens();
         if (isExpired()) {
             indexes = new uint256[](tokens.length);
-            for (uint256 i = 0; i < tokens.length; i++) {
-                indexes[i] = postExpiry.firstRewardIndex[tokens[i]];
-            }
+            for (uint256 i = 0; i < tokens.length; i++) indexes[i] = postExpiry.firstRewardIndex[tokens[i]];
         } else {
             indexes = IStandardizedYield(SY).rewardIndexesCurrent();
         }

package/contracts/core/erc20/PendleERC20.sol

@@ -160,13 +160,11 @@ contract PendleERC20 is Context, IERC20, IERC20Metadata {
      * - 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)
-    {
+    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);
@@ -206,8 +204,7 @@ contract PendleERC20 is Context, IERC20, IERC20Metadata {
         _afterTokenTransfer(from, to, amount);
     }
 
-    /**
-     * @dev Creates `amount` tokens and assigns them to `account`, increasing
+    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
      * the total supply.
      *
      * Emits a {Transfer} event with `from` set to the zero address.

package/contracts/core/libraries/ArrayLib.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.8.0;
 library ArrayLib {
     function sum(uint256[] memory input) internal pure returns (uint256) {
         uint256 value = 0;
-        for (uint256 i = 0; i < input.length;) {
+        for (uint256 i = 0; i < input.length; ) {
             value += input[i];
             unchecked {
                 i++;
@@ -16,7 +16,7 @@ library ArrayLib {
     /// @notice return index of the element if found, else return uint256.max
     function find(address[] memory array, address element) internal pure returns (uint256 index) {
         uint256 length = array.length;
-        for (uint256 i = 0; i < length;) {
+        for (uint256 i = 0; i < length; ) {
             if (array[i] == element) return i;
             unchecked {
                 i++;
@@ -28,7 +28,7 @@ library ArrayLib {
     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;) {
+        for (uint256 i = 0; i < length; ) {
             out[i] = inp[i];
             unchecked {
                 i++;
@@ -41,7 +41,7 @@ library ArrayLib {
         uint256 length = inp.length;
         out = new address[](length + 1);
         out[0] = element;
-        for (uint256 i = 1; i <= length;) {
+        for (uint256 i = 1; i <= length; ) {
             out[i] = inp[i - 1];
             unchecked {
                 i++;
@@ -82,7 +82,7 @@ library ArrayLib {
     // various version of contains
     function contains(address[] memory array, address element) internal pure returns (bool) {
         uint256 length = array.length;
-        for (uint256 i = 0; i < length;) {
+        for (uint256 i = 0; i < length; ) {
             if (array[i] == element) return true;
             unchecked {
                 i++;
@@ -93,7 +93,7 @@ library ArrayLib {
 
     function contains(bytes4[] memory array, bytes4 element) internal pure returns (bool) {
         uint256 length = array.length;
-        for (uint256 i = 0; i < length;) {
+        for (uint256 i = 0; i < length; ) {
             if (array[i] == element) return true;
             unchecked {
                 i++;
@@ -128,11 +128,13 @@ library ArrayLib {
         res[3] = d;
     }
 
-    function create(address a, address b, address c, address d, address e)
-        internal
-        pure
-        returns (address[] memory res)
-    {
+    function create(
+        address a,
+        address b,
+        address c,
+        address d,
+        address e
+    ) internal pure returns (address[] memory res) {
         res = new address[](5);
         res[0] = a;
         res[1] = b;

package/contracts/core/libraries/BaseSplitCodeFactory.sol

@@ -87,7 +87,9 @@ library CodeDeployer {
 }
 
 library BaseSplitCodeFactory {
-    function setCreationCode(bytes memory creationCode)
+    function setCreationCode(
+        bytes memory creationCode
+    )
         internal
         returns (
             address creationCodeContractA,
@@ -102,8 +104,8 @@ library BaseSplitCodeFactory {
 
             // We are going to deploy two contracts: one with approximately the first half of `creationCode`'s contents
             // (A), and another with the remaining half (B).
-            // We store the lengths in both immutable and stack variables, since immutable variables cannot be read
-            // during construction.
+            // We store the lengths in both immutable and stack variables, since immutable variables cannot be read during
+            // construction.
             creationCodeSizeA = creationCodeSize / 2;
 
             creationCodeSizeB = creationCodeSize - creationCodeSizeA;
@@ -114,8 +116,8 @@ library BaseSplitCodeFactory {
 
             // Memory: [ code length ] [ A.data ] [ B.data ]
 
-            // Creating A's array is simple: we simply replace `creationCode`'s length with A's length. We'll later
-            // restore the original length.
+            // Creating A's array is simple: we simply replace `creationCode`'s length with A's length. We'll later restore
+            // the original length.
 
             bytes memory creationCodeA;
             assembly {
@@ -128,9 +130,8 @@ library BaseSplitCodeFactory {
 
             creationCodeContractA = CodeDeployer.deploy(creationCodeA);
 
-            // Creating B's array is a bit more involved: since we cannot move B's contents, we are going to create a
-            // 'new' memory array starting at A's last 32 bytes, which will be replaced with B's length. We'll back-up
-            // this last
+            // Creating B's array is a bit more involved: since we cannot move B's contents, we are going to create a 'new'
+            // memory array starting at A's last 32 bytes, which will be replaced with B's length. We'll back-up this last
             // byte to later restore it.
 
             bytes memory creationCodeB;
@@ -149,8 +150,7 @@ library BaseSplitCodeFactory {
 
             creationCodeContractB = CodeDeployer.deploy(creationCodeB);
 
-            // We now restore the original contents of `creationCode` by writing back the original length and A's last
-            // byte.
+            // We now restore the original contents of `creationCode` by writing back the original length and A's last byte.
             assembly {
                 mstore(creationCodeA, creationCodeSize)
                 mstore(creationCodeB, lastByteA)
@@ -167,9 +167,14 @@ library BaseSplitCodeFactory {
         address creationCodeContractB,
         uint256 creationCodeSizeB
     ) internal view returns (bytes memory) {
-        return _getCreationCodeWithArgs(
-            "", creationCodeContractA, creationCodeSizeA, creationCodeContractB, creationCodeSizeB
-        );
+        return
+            _getCreationCodeWithArgs(
+                "",
+                creationCodeContractA,
+                creationCodeSizeA,
+                creationCodeContractB,
+                creationCodeSizeB
+            );
     }
 
     /**
@@ -183,11 +188,10 @@ library BaseSplitCodeFactory {
         uint256 creationCodeSizeB
     ) private view returns (bytes memory code) {
         unchecked {
-            // This function exists because `abi.encode()` cannot be instructed to place its result at a specific
-            // address. We need for the ABI-encoded constructor arguments to be located immediately after the creation
-            // code, but
-            // cannot rely on `abi.encodePacked()` to perform concatenation as that would involve copying the creation
-            // code, which would be prohibitively expensive.
+            // This function exists because `abi.encode()` cannot be instructed to place its result at a specific address.
+            // We need for the ABI-encoded constructor arguments to be located immediately after the creation code, but
+            // cannot rely on `abi.encodePacked()` to perform concatenation as that would involve copying the creation code,
+            // which would be prohibitively expensive.
             // Instead, we compute the creation code in a pre-allocated array that is large enough to hold *both* the
             // creation code and the constructor arguments, and then copy the ABI-encoded arguments (which should not be
             // overly long) right after the end of the creation code.
@@ -200,9 +204,8 @@ library BaseSplitCodeFactory {
             uint256 codeSize = creationCodeSize + constructorArgsSize;
 
             assembly {
-                // First, we allocate memory for `code` by retrieving the free memory pointer and then moving it ahead
-                // of `code` by the size of the creation code plus constructor arguments, and 32 bytes for the array
-                // length.
+                // First, we allocate memory for `code` by retrieving the free memory pointer and then moving it ahead of
+                // `code` by the size of the creation code plus constructor arguments, and 32 bytes for the array length.
                 code := mload(0x40)
                 mstore(0x40, add(code, add(codeSize, 32)))
 
@@ -243,7 +246,11 @@ library BaseSplitCodeFactory {
     ) internal returns (address) {
         unchecked {
             bytes memory creationCode = _getCreationCodeWithArgs(
-                constructorArgs, creationCodeContractA, creationCodeSizeA, creationCodeContractB, creationCodeSizeB
+                constructorArgs,
+                creationCodeContractA,
+                creationCodeSizeA,
+                creationCodeContractB,
+                creationCodeSizeB
             );
             return Create2.deploy(amount, salt, creationCode);
         }

package/contracts/core/libraries/BoringOwnableUpgradeableV2.sol

@@ -19,8 +19,7 @@ abstract contract BoringOwnableUpgradeableV2 is BoringOwnableUpgradeableData, In
     /// Can only be invoked by the current `owner`.
     /// @param newOwner Address of the new owner.
     /// @param direct True if `newOwner` should be set immediately. False if `newOwner` needs to use `claimOwnership`.
-    /// @param renounce Allows the `newOwner` to be `address(0)` if `direct` and `renounce` is True. Has no effect
-    /// otherwise.
+    /// @param renounce Allows the `newOwner` to be `address(0)` if `direct` and `renounce` is True. Has no effect otherwise.
     function transferOwnership(address newOwner, bool direct, bool renounce) public onlyOwner {
         if (direct) {
             // Checks

package/contracts/core/libraries/Errors.sol

@@ -19,7 +19,10 @@ library Errors {
     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

package/contracts/core/libraries/ExpiryUtilsLib.sol

@@ -8,9 +8,9 @@ library ExpiryUtils {
         uint8 day;
     }
 
-    uint256 private constant DAY_IN_SECONDS = 86_400;
-    uint256 private constant YEAR_IN_SECONDS = 31_536_000;
-    uint256 private constant LEAP_YEAR_IN_SECONDS = 31_622_400;
+    uint256 private constant DAY_IN_SECONDS = 86400;
+    uint256 private constant YEAR_IN_SECONDS = 31536000;
+    uint256 private constant LEAP_YEAR_IN_SECONDS = 31622400;
     uint16 private constant ORIGIN_YEAR = 1970;
 
     /**
@@ -21,13 +21,13 @@ library ExpiryUtils {
      * @param _expiry The expiry in epoch time.
      * @param _delimiter Can be any delimiter, but usually "-" or " ".
      * @return result Returns the concatenated string.
-     *
-     */
-    function concat(string memory _bt, string memory _yt, uint256 _expiry, string memory _delimiter)
-        internal
-        pure
-        returns (string memory result)
-    {
+     **/
+    function concat(
+        string memory _bt,
+        string memory _yt,
+        uint256 _expiry,
+        string memory _delimiter
+    ) internal pure returns (string memory result) {
         result = string(abi.encodePacked(_bt, _delimiter, _yt, _delimiter, toRFC2822String(_expiry)));
     }
 

package/contracts/core/libraries/StringLib.sol

@@ -471,11 +471,12 @@ library StringLib {
 
     // Returns the memory address of the first byte of the first occurrence of
     // `needle` in `self`, or the first byte after `self` if not found.
-    function findPtr(uint256 selflen, uint256 selfptr, uint256 needlelen, uint256 needleptr)
-        private
-        pure
-        returns (uint256)
-    {
+    function findPtr(
+        uint256 selflen,
+        uint256 selfptr,
+        uint256 needlelen,
+        uint256 needleptr
+    ) private pure returns (uint256) {
         uint256 ptr = selfptr;
         uint256 idx;
 
@@ -527,11 +528,12 @@ library StringLib {
 
     // Returns the memory address of the first byte after the last occurrence of
     // `needle` in `self`, or the address of `self` if not found.
-    function rfindPtr(uint256 selflen, uint256 selfptr, uint256 needlelen, uint256 needleptr)
-        private
-        pure
-        returns (uint256)
-    {
+    function rfindPtr(
+        uint256 selflen,
+        uint256 selfptr,
+        uint256 needlelen,
+        uint256 needleptr
+    ) private pure returns (uint256) {
         uint256 ptr;
 
         if (needlelen <= selflen) {
@@ -736,9 +738,7 @@ library StringLib {
         if (parts.length == 0) return "";
 
         uint256 length = self._len * (parts.length - 1);
-        for (uint256 i = 0; i < parts.length; i++) {
-            length += parts[i]._len;
-        }
+        for (uint256 i = 0; i < parts.length; i++) length += parts[i]._len;
 
         string memory ret = new string(length);
         uint256 retptr;

package/contracts/core/libraries/TokenHelper.sol

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import "../../interfaces/IWETH.sol";
 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;
@@ -23,7 +23,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);
@@ -33,7 +33,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++;