@pendle/core-v2 6.3.0-beta → 6.3.0-sweedtest

package/contracts/interfaces/IPYieldTokenV2.sol

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
-import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
-import "./IRewardManager.sol";
 import "./IPInterestManagerYTV2.sol";
+import "./IRewardManager.sol";
+import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 
 interface IPYieldTokenV2 is IERC20Metadata, IRewardManager, IPInterestManagerYTV2 {
     event Mint(
@@ -29,16 +29,13 @@ interface IPYieldTokenV2 is IERC20Metadata, IRewardManager, IPInterestManagerYTV
 
     function redeemPY(address receiver) external returns (uint256 amountSyOut);
 
-    function redeemPYMulti(
-        address[] calldata receivers,
-        uint256[] calldata amountPYToRedeems
-    ) external returns (uint256[] memory amountSyOuts);
+    function redeemPYMulti(address[] calldata receivers, uint256[] calldata amountPYToRedeems)
+        external
+        returns (uint256[] memory amountSyOuts);
 
-    function redeemDueInterestAndRewards(
-        address user,
-        bool redeemInterest,
-        bool redeemRewards
-    ) external returns (uint256 interestOut, uint256[] memory rewardsOut);
+    function redeemDueInterestAndRewards(address user, bool redeemInterest, bool redeemRewards)
+        external
+        returns (uint256 interestOut, uint256[] memory rewardsOut);
 
     function rewardIndexesCurrent() external returns (uint256[] memory);
 

package/contracts/interfaces/IStandardizedYield.sol

@@ -64,12 +64,10 @@ interface IStandardizedYield is IERC20Metadata {
      * Requirements:
      * - (`tokenIn`) must be a valid base token.
      */
-    function deposit(
-        address receiver,
-        address tokenIn,
-        uint256 amountTokenToDeposit,
-        uint256 minSharesOut
-    ) external payable returns (uint256 amountSharesOut);
+    function deposit(address receiver, address tokenIn, uint256 amountTokenToDeposit, uint256 minSharesOut)
+        external
+        payable
+        returns (uint256 amountSharesOut);
 
     /**
      * @notice redeems an amount of base tokens by burning some shares
@@ -95,9 +93,9 @@ interface IStandardizedYield is IERC20Metadata {
     /**
      * @notice exchangeRate * syBalance / 1e18 must return the asset balance of the account
      * @notice vice-versa, if a user uses some amount of tokens equivalent to X asset, the amount of sy
-     he can mint must be X * exchangeRate / 1e18
+     * exchangeRate / 1e18
      * @dev SYUtils's assetToSy & syToAsset should be used instead of raw multiplication
-     & division
+     *  & division
      */
     function exchangeRate() external view returns (uint256 res);
 
@@ -146,20 +144,21 @@ interface IStandardizedYield is IERC20Metadata {
 
     function isValidTokenOut(address token) external view returns (bool);
 
-    function previewDeposit(
-        address tokenIn,
-        uint256 amountTokenToDeposit
-    ) external view returns (uint256 amountSharesOut);
+    function previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        external
+        view
+        returns (uint256 amountSharesOut);
 
-    function previewRedeem(
-        address tokenOut,
-        uint256 amountSharesToRedeem
-    ) external view returns (uint256 amountTokenOut);
+    function previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        external
+        view
+        returns (uint256 amountTokenOut);
 
     /**
      * @notice This function contains information to interpret what the asset is
      * @return assetType the type of the asset (0 for ERC20 tokens, 1 for AMM liquidity tokens,
-        2 for bridged yield bearing tokens like wstETH, rETH on Arbi whose the underlying asset doesn't exist on the chain)
+     *     2 for bridged yield bearing tokens like wstETH, rETH on Arbi whose the underlying asset doesn't exist on the
+     * chain)
      * @return assetAddress the address of the asset
      * @return assetDecimals the decimals of the asset
      */

package/contracts/limit/LimitMathCore.sol

@@ -2,8 +2,8 @@
 
 pragma solidity ^0.8.0;
 
-import "../interfaces/IPLimitRouter.sol";
 import "../core/Market/MarketMathCore.sol";
+import "../interfaces/IPLimitRouter.sol";
 import "../interfaces/IPMarketFactory.sol";
 
 library LimitMathCore {
@@ -12,37 +12,29 @@ library LimitMathCore {
     using PMath for uint256;
     using PMath for int256;
 
-    function calcBatch(
-        FillOrderParams[] memory params,
-        address YT,
-        uint256 lnFeeRateRoot
-    ) internal returns (IPLimitOrderType.FillResults memory out) {
-        return
-            calcBatch(
-                params,
-                IPYieldToken(YT).expiry() - block.timestamp,
-                IPYieldToken(YT).pyIndexCurrent(),
-                lnFeeRateRoot
-            );
+    function calcBatch(FillOrderParams[] memory params, address YT, uint256 lnFeeRateRoot)
+        internal
+        returns (IPLimitOrderType.FillResults memory out)
+    {
+        return calcBatch(
+            params, IPYieldToken(YT).expiry() - block.timestamp, IPYieldToken(YT).pyIndexCurrent(), lnFeeRateRoot
+        );
     }
 
     // --- PURE FUNCTIONS ---
-    function calcBatch(
-        FillOrderParams[] memory params,
-        uint256 timeToExpiry,
-        uint256 pyIndex,
-        uint256 lnFeeRateRoot
-    ) internal pure returns (IPLimitOrderType.FillResults memory out) {
+    function calcBatch(FillOrderParams[] memory params, uint256 timeToExpiry, uint256 pyIndex, uint256 lnFeeRateRoot)
+        internal
+        pure
+        returns (IPLimitOrderType.FillResults memory out)
+    {
         uint256 len = params.length;
         out.netMakings = new uint256[](len);
         out.netTakings = new uint256[](len);
         out.netFees = new uint256[](len);
         out.notionalVolumes = new uint256[](len);
 
-        function(uint256, uint256, PYIndex, uint256)
-            internal
-            pure
-            returns (uint256, uint256, uint256) calc = getCalcFunctions(params[0].order.orderType);
+        function(uint256, uint256, PYIndex, uint256) internal pure returns (uint256, uint256, uint256) calc =
+            getCalcFunctions(params[0].order.orderType);
 
         uint256 feeRate = impliedRateToExchangeRate(lnFeeRateRoot, timeToExpiry);
 
@@ -53,12 +45,8 @@ library LimitMathCore {
             uint256 exchangeRate = impliedRateToExchangeRate(param.order.lnImpliedRate, timeToExpiry);
 
             out.netMakings[i] = param.makingAmount;
-            (out.netTakings[i], out.netFees[i], out.notionalVolumes[i]) = calc(
-                out.netMakings[i],
-                exchangeRate,
-                PYIndex.wrap(pyIndex),
-                feeRate
-            );
+            (out.netTakings[i], out.netFees[i], out.notionalVolumes[i]) =
+                calc(out.netMakings[i], exchangeRate, PYIndex.wrap(pyIndex), feeRate);
 
             require(out.netTakings[i] > 0, "LOP: can't swap 0 amount");
 
@@ -69,12 +57,11 @@ library LimitMathCore {
         }
     }
 
-    function calcSyForPt(
-        uint256 makeSy,
-        uint256 r,
-        PYIndex index,
-        uint256 f
-    ) internal pure returns (uint256 takePt, uint256 fee, uint256 notionalVolume) {
+    function calcSyForPt(uint256 makeSy, uint256 r, PYIndex index, uint256 f)
+        internal
+        pure
+        returns (uint256 takePt, uint256 fee, uint256 notionalVolume)
+    {
         // takePt = makeSy * index * r
         // fee = makeSy * (f - 1) / f
         // notionalVolume = makeSy
@@ -84,12 +71,11 @@ library LimitMathCore {
         notionalVolume = makeSy;
     }
 
-    function calcPtForSy(
-        uint256 makePt,
-        uint256 r,
-        PYIndex index,
-        uint256 f
-    ) internal pure returns (uint256 takeSy, uint256 fee, uint256 notionalVolume) {
+    function calcPtForSy(uint256 makePt, uint256 r, PYIndex index, uint256 f)
+        internal
+        pure
+        returns (uint256 takeSy, uint256 fee, uint256 notionalVolume)
+    {
         // takeAsset = make / r
         // takeSy = takeAsset / index
         // fee = takeSy * (f-1)
@@ -100,12 +86,11 @@ library LimitMathCore {
         notionalVolume = takeSy;
     }
 
-    function calcSyForYt(
-        uint256 makeSy,
-        uint256 r,
-        PYIndex index,
-        uint256 f
-    ) internal pure returns (uint256 takeYt, uint256 fee, uint256 notionalVolume) {
+    function calcSyForYt(uint256 makeSy, uint256 r, PYIndex index, uint256 f)
+        internal
+        pure
+        returns (uint256 takeYt, uint256 fee, uint256 notionalVolume)
+    {
         // pt = makeSy * index * r
         // yt = pt / (r-1)
         // fee = makeSy * (f-1) / (r-1)
@@ -117,12 +102,11 @@ library LimitMathCore {
         notionalVolume = makeSy.divDown(pt_yt_ratio);
     }
 
-    function calcYtForSy(
-        uint256 makeYt,
-        uint256 r,
-        PYIndex index,
-        uint256 f
-    ) internal pure returns (uint256 takeSy, uint256 fee, uint256 notionalVolume) {
+    function calcYtForSy(uint256 makeYt, uint256 r, PYIndex index, uint256 f)
+        internal
+        pure
+        returns (uint256 takeSy, uint256 fee, uint256 notionalVolume)
+    {
         // pt = yt * (r-1)
         // takeSy = pt / r / index
         // feeSy = takeSy * (f-1) / f / (r-1)
@@ -138,9 +122,7 @@ library LimitMathCore {
         return MarketMathCore._getExchangeRateFromImpliedRate(lnRate, timeToExpiry).Uint();
     }
 
-    function getCalcFunctions(
-        IPLimitOrderType.OrderType t
-    )
+    function getCalcFunctions(IPLimitOrderType.OrderType t)
         internal
         pure
         returns (function(uint256, uint256, PYIndex, uint256) internal pure returns (uint256, uint256, uint256) calc)

package/contracts/limit/LimitRouterBase.sol

@@ -2,15 +2,15 @@
 
 pragma solidity ^0.8.17;
 
-import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
-import "@openzeppelin/contracts-upgradeable/utils/cryptography/draft-EIP712Upgradeable.sol";
-import "../interfaces/IPLimitRouter.sol";
 import "../core/libraries/BoringOwnableUpgradeableV2.sol";
 import "../core/libraries/TokenHelper.sol";
+import "../interfaces/IPLimitRouter.sol";
 import "../interfaces/IStandardizedYield.sol";
-import "./helpers/NonceManager.sol";
 import "../interfaces/IWETH.sol";
 import {LimitMathCore as LimitMath} from "./LimitMathCore.sol";
+import "./helpers/NonceManager.sol";
+import "@openzeppelin/contracts-upgradeable/utils/cryptography/draft-EIP712Upgradeable.sol";
+import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
 
 abstract contract LimitRouterBase is
     EIP712Upgradeable,
@@ -22,15 +22,14 @@ abstract contract LimitRouterBase is
     using SafeERC20 for IERC20;
     using PMath for uint256;
 
-    bytes32 internal constant LIMIT_ORDER_TYPEHASH =
-        keccak256(
-            "Order(uint256 salt,uint256 expiry,uint256 nonce,uint8 orderType,address token,address YT,address maker,address receiver,uint256 makingAmount,uint256 lnImpliedRate,uint256 failSafeRate,bytes permit)"
-        );
+    bytes32 internal constant LIMIT_ORDER_TYPEHASH = keccak256(
+        "Order(uint256 salt,uint256 expiry,uint256 nonce,uint8 orderType,address token,address YT,address maker,address receiver,uint256 makingAmount,uint256 lnImpliedRate,uint256 failSafeRate,bytes permit)"
+    );
 
     uint128 internal constant _ORDER_DOES_NOT_EXIST = 0;
     uint128 internal constant _ORDER_FILLED = 1;
-    uint256 internal constant NEW_PRIME = 12421;
-    uint256 internal constant MAX_LN_FEE_RATE_ROOT = 48790164169432003; // ln(1.05)
+    uint256 internal constant NEW_PRIME = 12_421;
+    uint256 internal constant MAX_LN_FEE_RATE_ROOT = 48_790_164_169_432_003; // ln(1.05)
 
     bytes private constant EMPTY_BYTES = abi.encode();
 
@@ -70,7 +69,8 @@ abstract contract LimitRouterBase is
         FillOrderParams[] memory params,
         address receiver,
         uint256 maxTaking,
-        bytes calldata /*optData*/,
+        bytes calldata,
+        /*optData*/
         bytes memory callback
     ) external returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee, bytes memory callbackReturn) {
         params = _validateSkipSigAndFilterOrders(params);
@@ -94,16 +94,18 @@ abstract contract LimitRouterBase is
         bytes callback;
     }
 
-    function fillNoOrders(
-        bytes memory callback
-    ) internal returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee, bytes memory callbackReturn) {
+    function fillNoOrders(bytes memory callback)
+        internal
+        returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee, bytes memory callbackReturn)
+    {
         callbackReturn = callbackIfNeeded(0, 0, 0, callback);
         return (0, 0, 0, callbackReturn);
     }
 
-    function fillTokenForPY(
-        Args memory a
-    ) internal returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee, bytes memory callbackReturn) {
+    function fillTokenForPY(Args memory a)
+        internal
+        returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee, bytes memory callbackReturn)
+    {
         (address SY, address PT, address YT, bytes32[] memory orderHashes) = _checkSig_updMakingAndStatus(a.params);
 
         // Token => This
@@ -131,9 +133,10 @@ abstract contract LimitRouterBase is
         _emitEvents(a.params, orderHashes, fromMakers, out.netTakings, out.netFees, out.notionalVolumes);
     }
 
-    function fillPYForToken(
-        Args memory a
-    ) internal returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee, bytes memory callbackReturn) {
+    function fillPYForToken(Args memory a)
+        internal
+        returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee, bytes memory callbackReturn)
+    {
         (address SY, address PT, address YT, bytes32[] memory orderHashes) = _checkSig_updMakingAndStatus(a.params);
 
         FillResults memory out = LimitMath.calcBatch(a.params, YT, getLnFeeRateRoot(YT));
@@ -162,9 +165,11 @@ abstract contract LimitRouterBase is
     }
 
     // ----------------- verify & convert functions -----------------
-    function _validateSkipSigAndFilterOrders(
-        FillOrderParams[] memory params
-    ) internal view returns (FillOrderParams[] memory res) {
+    function _validateSkipSigAndFilterOrders(FillOrderParams[] memory params)
+        internal
+        view
+        returns (FillOrderParams[] memory res)
+    {
         uint256 len = params.length;
         require(len != 0, "LOP: empty batch");
 
@@ -192,19 +197,18 @@ abstract contract LimitRouterBase is
         }
     }
 
-    function _checkSig_updMakingAndStatus(
-        FillOrderParams[] memory params
-    ) internal returns (address SY, address PT, address YT, bytes32[] memory orderHashes) {
+    function _checkSig_updMakingAndStatus(FillOrderParams[] memory params)
+        internal
+        returns (address SY, address PT, address YT, bytes32[] memory orderHashes)
+    {
         uint256 len = params.length;
         orderHashes = new bytes32[](len);
 
         for (uint256 i = 0; i < len; i++) {
             FillOrderParams memory param = params[i];
 
-            (bytes32 orderHash, uint256 remainingMakerAmount, uint256 filledMakerAmount) = _checkSig(
-                param.order,
-                param.signature
-            );
+            (bytes32 orderHash, uint256 remainingMakerAmount, uint256 filledMakerAmount) =
+                _checkSig(param.order, param.signature);
             uint256 netMaking = PMath.min(param.makingAmount, remainingMakerAmount);
 
             unchecked {
@@ -252,26 +256,17 @@ abstract contract LimitRouterBase is
         }
     }
 
-    function callbackIfNeeded(
-        uint256 actualMaking,
-        uint256 actualTaking,
-        uint256 totalFee,
-        bytes memory callback
-    ) internal returns (bytes memory callbackReturn) {
+    function callbackIfNeeded(uint256 actualMaking, uint256 actualTaking, uint256 totalFee, bytes memory callback)
+        internal
+        returns (bytes memory callbackReturn)
+    {
         if (callback.length > 0) {
-            callbackReturn = IPLimitRouterCallback(msg.sender).limitRouterCallback(
-                actualMaking,
-                actualTaking,
-                totalFee,
-                callback
-            );
+            callbackReturn =
+                IPLimitRouterCallback(msg.sender).limitRouterCallback(actualMaking, actualTaking, totalFee, callback);
         }
     }
 
-    function _checkSig(
-        Order memory order,
-        bytes memory signature
-    )
+    function _checkSig(Order memory order, bytes memory signature)
         public
         view
         returns (
@@ -301,10 +296,10 @@ abstract contract LimitRouterBase is
 
     // ----------------- simple helper functions functions -----------------
 
-    function _transferFromMakers_mintSy_updMakings(
-        address SY,
-        FillOrderParams[] memory params
-    ) internal returns (uint256[] memory fromMakers) {
+    function _transferFromMakers_mintSy_updMakings(address SY, FillOrderParams[] memory params)
+        internal
+        returns (uint256[] memory fromMakers)
+    {
         uint256 len = params.length;
         fromMakers = new uint256[](len);
 
@@ -340,19 +335,13 @@ abstract contract LimitRouterBase is
         }
         _safeApproveInf(token, SY);
         return
-            IStandardizedYield(SY).deposit{value: token == NATIVE ? netTokenIn : 0}(
-                address(this),
-                token,
-                netTokenIn,
-                0
-            );
+            IStandardizedYield(SY).deposit{value: token == NATIVE ? netTokenIn : 0}(address(this), token, netTokenIn, 0);
     }
 
-    function _redeemSy_transferToMakers(
-        address SY,
-        FillOrderParams[] memory params,
-        uint256[] memory netSyOuts
-    ) internal returns (uint256[] memory toMakers) {
+    function _redeemSy_transferToMakers(address SY, FillOrderParams[] memory params, uint256[] memory netSyOuts)
+        internal
+        returns (uint256[] memory toMakers)
+    {
         uint256 len = params.length;
         toMakers = new uint256[](len);
 
@@ -401,18 +390,14 @@ abstract contract LimitRouterBase is
     }
 
     function __stillShared(address currentShared, address nextToken) private view returns (bool) {
-        return
-            (currentShared == nextToken) ||
-            (currentShared == NATIVE && nextToken == WNATIVE) ||
-            (currentShared == WNATIVE && nextToken == NATIVE);
+        return (currentShared == nextToken) || (currentShared == NATIVE && nextToken == WNATIVE)
+            || (currentShared == WNATIVE && nextToken == NATIVE);
     }
 
-    function __redeemSy_Single(
-        address receiver,
-        address SY,
-        address tokenOut,
-        uint256 netSyIn
-    ) private returns (uint256 netTokenOut) {
+    function __redeemSy_Single(address receiver, address SY, address tokenOut, uint256 netSyIn)
+        private
+        returns (uint256 netTokenOut)
+    {
         if (tokenOut == NATIVE || tokenOut == WNATIVE) {
             address otherToken = tokenOut == NATIVE ? WNATIVE : NATIVE;
             address tokenRedeemSy = IStandardizedYield(SY).isValidTokenOut(tokenOut) ? tokenOut : otherToken;
@@ -432,12 +417,9 @@ abstract contract LimitRouterBase is
     }
 
     // ! Allow self-fill of orders
-    function _transferFromMakers(
-        IERC20 token,
-        FillOrderParams[] memory params,
-        address to,
-        uint256[] memory netIn
-    ) internal {
+    function _transferFromMakers(IERC20 token, FillOrderParams[] memory params, address to, uint256[] memory netIn)
+        internal
+    {
         uint256 len = params.length;
         for (uint256 i = 0; i < len; i++) {
             if (params[i].order.maker == to) continue;
@@ -445,12 +427,9 @@ abstract contract LimitRouterBase is
         }
     }
 
-    function _transferToMakers(
-        IERC20 token,
-        address payer,
-        FillOrderParams[] memory params,
-        uint256[] memory netOut
-    ) internal {
+    function _transferToMakers(IERC20 token, address payer, FillOrderParams[] memory params, uint256[] memory netOut)
+        internal
+    {
         uint256 len = params.length;
         for (uint256 i = 0; i < len; i++) {
             if (payer == params[i].order.receiver) continue;
@@ -486,11 +465,10 @@ abstract contract LimitRouterBase is
     }
 
     /// @dev if zero fees are intended, it must be explicitly allowed again
-    function setLnFeeRateRoots(
-        address[] memory YTs,
-        uint256[] memory lnFeeRateRoots,
-        bool allowZeroFees
-    ) public onlyHelperAndOwner {
+    function setLnFeeRateRoots(address[] memory YTs, uint256[] memory lnFeeRateRoots, bool allowZeroFees)
+        public
+        onlyHelperAndOwner
+    {
         uint256 len = YTs.length;
         require(len == lnFeeRateRoots.length, "LOP: length mismatch");
 

package/contracts/limit/PendleLimitRouter.sol

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "./LimitRouterBase.sol";
 import "../core/libraries/Errors.sol";
+import "./LimitRouterBase.sol";
 
 contract PendleLimitRouter is LimitRouterBase {
     using Address for address;
@@ -39,9 +39,11 @@ contract PendleLimitRouter is LimitRouterBase {
         }
     }
 
-    function orderStatusesRaw(
-        bytes32[] memory orderHashes
-    ) public view returns (uint256[] memory remainingsRaw, uint256[] memory filledAmounts) {
+    function orderStatusesRaw(bytes32[] memory orderHashes)
+        public
+        view
+        returns (uint256[] memory remainingsRaw, uint256[] memory filledAmounts)
+    {
         uint256 len = orderHashes.length;
         remainingsRaw = new uint256[](len);
         filledAmounts = new uint256[](len);
@@ -52,9 +54,11 @@ contract PendleLimitRouter is LimitRouterBase {
         }
     }
 
-    function orderStatuses(
-        bytes32[] memory orderHashes
-    ) external view returns (uint256[] memory remainings, uint256[] memory filledAmounts) {
+    function orderStatuses(bytes32[] memory orderHashes)
+        external
+        view
+        returns (uint256[] memory remainings, uint256[] memory filledAmounts)
+    {
         (remainings, filledAmounts) = orderStatusesRaw(orderHashes);
         for (uint256 i = 0; i < remainings.length; i++) {
             require(remainings[i] != _ORDER_DOES_NOT_EXIST, "LOP: Unknown order");

package/contracts/offchain-helpers/AddressProvider.sol

@@ -1,7 +1,7 @@
 pragma solidity ^0.8.17;
 
-import "../interfaces/IAddressProvider.sol";
 import "../core/libraries/BoringOwnableUpgradeableV2.sol";
+import "../interfaces/IAddressProvider.sol";
 
 contract AddressProvider is IAddressProvider, BoringOwnableUpgradeableV2 {
     mapping(uint256 => address) public get;

package/contracts/offchain-helpers/AutomateReady.sol

@@ -72,7 +72,7 @@ abstract contract AutomateReady {
     constructor(address _automate, address _taskCreator) {
         automate = IAutomate(_automate);
         _gelato = IAutomate(_automate).gelato();
-        (dedicatedMsgSender, ) = IOpsProxyFactory(OPS_PROXY_FACTORY).getProxyOf(_taskCreator);
+        (dedicatedMsgSender,) = IOpsProxyFactory(OPS_PROXY_FACTORY).getProxyOf(_taskCreator);
     }
 
     /**
@@ -83,7 +83,7 @@ abstract contract AutomateReady {
      */
     function _transfer(uint256 _fee, address _feeToken) internal {
         if (_feeToken == ETH) {
-            (bool success, ) = _gelato.call{value: _fee}("");
+            (bool success,) = _gelato.call{value: _fee}("");
             require(success, "_transfer: ETH transfer failed");
         } else {
             SafeERC20.safeTransfer(IERC20(_feeToken), _gelato, _fee);

package/contracts/offchain-helpers/BalanceReader.sol

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 import "../core/libraries/BoringOwnableUpgradeableV2.sol";
 import "../interfaces/IPMarket.sol";
 import "../interfaces/IStandardizedYield.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 
 contract BalanceReader is UUPSUpgradeable, BoringOwnableUpgradeableV2 {
     struct UserMarketInfo {
@@ -66,7 +66,12 @@ contract BalanceReader is UUPSUpgradeable, BoringOwnableUpgradeableV2 {
         }
     }
 
-    function _redeemRewards(IPMarket market, address user) internal returns (uint256[] memory /*rewardsOut*/) {
+    function _redeemRewards(IPMarket market, address user)
+        internal
+        returns (
+            uint256[] memory /*rewardsOut*/
+        )
+    {
         try market.redeemRewards(user) returns (uint256[] memory rewardsOut) {
             return rewardsOut;
         } catch {
@@ -74,13 +79,15 @@ contract BalanceReader is UUPSUpgradeable, BoringOwnableUpgradeableV2 {
         }
     }
 
-    function _redeemDueInterestAndRewards(
-        IPYieldToken YT,
-        address user
-    ) internal returns (uint256 /*interestOut*/, uint256[] memory /*rewardsOut*/) {
+    function _redeemDueInterestAndRewards(IPYieldToken YT, address user)
+        internal
+        returns (
+            uint256, /*interestOut*/
+            uint256[] memory /*rewardsOut*/
+        )
+    {
         try YT.redeemDueInterestAndRewards(user, true, true) returns (
-            uint256 interestOut,
-            uint256[] memory rewardsOut
+            uint256 interestOut, uint256[] memory rewardsOut
         ) {
             return (interestOut, rewardsOut);
         } catch {
@@ -88,7 +95,12 @@ contract BalanceReader is UUPSUpgradeable, BoringOwnableUpgradeableV2 {
         }
     }
 
-    function _claimRewards(IStandardizedYield SY, address user) internal returns (uint256[] memory /*rewardsOut*/) {
+    function _claimRewards(IStandardizedYield SY, address user)
+        internal
+        returns (
+            uint256[] memory /*rewardsOut*/
+        )
+    {
         try SY.claimRewards(user) returns (uint256[] memory rewardsOut) {
             return rewardsOut;
         } catch {