@pendle/core-v2 1.4.4-testnet → 1.6.0-testnet

package/contracts/core/StandardizedYield/implementations/BalancerStable/base/{PendleAuraBalancerStableLPSY.sol → PendleAuraBalancerStableLPSYV2.sol}

@@ -14,13 +14,14 @@ import "./StablePoolUserData.sol";
 import "../../../../libraries/ArrayLib.sol";
 import "../../../SYBaseWithRewards.sol";
 
-abstract contract PendleAuraBalancerStableLPSY is SYBaseWithRewards {
+abstract contract PendleAuraBalancerStableLPSYV2 is SYBaseWithRewards {
     using ArrayLib for address[];
 
-    address public constant BAL_TOKEN = 0xba100000625a3754423978a60c9317c58a424e3D;
-    address public constant AURA_TOKEN = 0xC0c293ce456fF0ED870ADd98a0828Dd4d2903DBF;
-    address public constant AURA_BOOSTER = 0xA57b8d98dAE62B26Ec3bcC4a365338157060B234;
-    address public constant BALANCER_VAULT = 0xBA12222222228d8Ba445958a75a0704d566BF2C8;
+    address internal constant BAL_TOKEN = 0xba100000625a3754423978a60c9317c58a424e3D;
+    address internal constant AURA_TOKEN = 0xC0c293ce456fF0ED870ADd98a0828Dd4d2903DBF;
+    address internal constant AURA_BOOSTER = 0xA57b8d98dAE62B26Ec3bcC4a365338157060B234;
+    address internal constant BALANCER_VAULT = 0xBA12222222228d8Ba445958a75a0704d566BF2C8;
+    uint256 internal constant DEFAULT_GAS_REENTRANCY_CHECK = 7000;
 
     address public immutable balLp;
     bytes32 public immutable balPoolId;
@@ -30,6 +31,7 @@ abstract contract PendleAuraBalancerStableLPSY is SYBaseWithRewards {
 
     IBalancerStablePreview public immutable previewHelper;
 
+    uint256 public gasForReentrancyCheck;
     address[] public extraRewards;
 
     constructor(
@@ -53,11 +55,14 @@ abstract contract PendleAuraBalancerStableLPSY is SYBaseWithRewards {
         }
 
         previewHelper = _previewHelper;
+        gasForReentrancyCheck = DEFAULT_GAS_REENTRANCY_CHECK;
     }
 
-    function _getPoolInfo(
-        uint256 _auraPid
-    ) internal view returns (address _auraLp, address _auraRewardManager) {
+    function _getPoolInfo(uint256 _auraPid)
+        internal
+        view
+        returns (address _auraLp, address _auraRewardManager)
+    {
         if (_auraPid > IBooster(AURA_BOOSTER).poolLength()) revert Errors.SYBalancerInvalidPid();
         (_auraLp, , , _auraRewardManager, , ) = IBooster(AURA_BOOSTER).poolInfo(_auraPid);
     }
@@ -69,10 +74,12 @@ abstract contract PendleAuraBalancerStableLPSY is SYBaseWithRewards {
     /**
      * @notice Either wraps LP, or also joins pool using exact tokenIn
      */
-    function _deposit(
-        address tokenIn,
-        uint256 amount
-    ) internal virtual override returns (uint256 amountSharesOut) {
+    function _deposit(address tokenIn, uint256 amount)
+        internal
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
         if (tokenIn == balLp) {
             amountSharesOut = amount;
         } else {
@@ -100,17 +107,60 @@ abstract contract PendleAuraBalancerStableLPSY is SYBaseWithRewards {
     }
 
     function exchangeRate() external view override returns (uint256) {
+        _checkBalancerReadOnlyReentrancy();
         return IRateProvider(balLp).getRate();
     }
 
+    /*
+    * The `manageUserBalance` function is a non-view function that includes a reentrancy guard
+        in the form of `_require(_status != _ENTERED, Errors.REENTRANCY);`. To prevent
+        read-only reentrancy, it's important to ensure that our `manageUserBalance` has enough gas
+        to reach this check, so that it can fail if necessary.
+
+    * On the way to the check, there's at most one `COLD_SLOAD` plus miscellaneous decoding &
+        require, which we've found through testing to cost no more than 3200 gas. Therefore,
+        attaching 7000 gas should guarantee that it's always possible to reach the check.
+
+    * Once we've reached the check, one of two scenarios can occur:
+    1. The call doesn't pass the check, and reverts with error `BAL#400` ⇒ `response.length = 100`.
+    2. The call passes the check. Then, the call can either:
+        a. continue on to set the `status` variable to 2, causing the EVM to revert (since
+        the sub-call is a `staticcall`), and `response.length == 0`
+        b. run out of gas, which will also lead to a revert with `response.length == 0`
+    In both cases, to differentiate between 1 and 2, we check `response.length != 0`. If it's
+    true, then it's a read-only reentrancy. Otherwise, we're good (and we can ignore
+    differentiating between 2a and 2b).
+    */
+    function _checkBalancerReadOnlyReentrancy() internal view {
+        IVault.UserBalanceOp[] memory noop = new IVault.UserBalanceOp[](0);
+
+        (bool isSuccess, bytes memory response) = BALANCER_VAULT.staticcall{
+            gas: gasForReentrancyCheck
+        }(
+            abi.encodeWithSignature(
+                "manageUserBalance((uint8,address,uint256,address,address)[])",
+                noop
+            )
+        );
+
+        assert(!isSuccess);
+        if (response.length != 0) revert Errors.SYBalancerReentrancy();
+    }
+
+    function setGasForReentrancyCheck(uint256 newGas) external onlyOwner {
+        require(newGas >= DEFAULT_GAS_REENTRANCY_CHECK, "lower than default");
+        gasForReentrancyCheck = newGas;
+    }
+
     /*///////////////////////////////////////////////////////////////
                     BALANCER-RELATED FUNCTIONS
     //////////////////////////////////////////////////////////////*/
 
-    function _depositToBalancer(
-        address tokenIn,
-        uint256 amountTokenToDeposit
-    ) internal virtual returns (uint256) {
+    function _depositToBalancer(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        virtual
+        returns (uint256)
+    {
         IVault.JoinPoolRequest memory request = _assembleJoinRequest(
             tokenIn,
             amountTokenToDeposit
@@ -121,10 +171,12 @@ abstract contract PendleAuraBalancerStableLPSY is SYBaseWithRewards {
         return _selfBalance(balLp);
     }
 
-    function _assembleJoinRequest(
-        address tokenIn,
-        uint256 amountTokenToDeposit
-    ) internal view virtual returns (IVault.JoinPoolRequest memory request) {
+    function _assembleJoinRequest(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        virtual
+        returns (IVault.JoinPoolRequest memory request)
+    {
         // max amounts in
         address[] memory assets = _getPoolTokenAddresses();
 
@@ -166,10 +218,12 @@ abstract contract PendleAuraBalancerStableLPSY is SYBaseWithRewards {
         return balanceAfter - balanceBefore;
     }
 
-    function _assembleExitRequest(
-        address tokenOut,
-        uint256 amountLpToRedeem
-    ) internal view virtual returns (IVault.ExitPoolRequest memory request) {
+    function _assembleExitRequest(address tokenOut, uint256 amountLpToRedeem)
+        internal
+        view
+        virtual
+        returns (IVault.ExitPoolRequest memory request)
+    {
         address[] memory assets = _getPoolTokenAddresses();
         uint256[] memory minAmountsOut = new uint256[](assets.length);
 
@@ -201,10 +255,13 @@ abstract contract PendleAuraBalancerStableLPSY is SYBaseWithRewards {
                    PREVIEW FUNCTIONS
     //////////////////////////////////////////////////////////////*/
 
-    function _previewDeposit(
-        address tokenIn,
-        uint256 amountTokenToDeposit
-    ) internal view virtual override returns (uint256 amountSharesOut) {
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
         if (tokenIn == balLp) {
             amountSharesOut = amountTokenToDeposit;
         } else {
@@ -222,10 +279,13 @@ abstract contract PendleAuraBalancerStableLPSY is SYBaseWithRewards {
         }
     }
 
-    function _previewRedeem(
-        address tokenOut,
-        uint256 amountSharesToRedeem
-    ) internal view virtual override returns (uint256 amountTokenOut) {
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 amountTokenOut)
+    {
         if (tokenOut == balLp) {
             amountTokenOut = amountSharesToRedeem;
         } else {
@@ -303,7 +363,11 @@ abstract contract PendleAuraBalancerStableLPSY is SYBaseWithRewards {
     function assetInfo()
         external
         view
-        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
+        returns (
+            AssetType assetType,
+            address assetAddress,
+            uint8 assetDecimals
+        )
     {
         return (AssetType.LIQUIDITY, balLp, IERC20Metadata(balLp).decimals());
     }

package/contracts/core/StandardizedYield/implementations/PendleSfrxEthSY.sol

@@ -0,0 +1,132 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../SYBase.sol";
+import "../../../interfaces/Frax/IFrxEthMinter.sol";
+import "../../../interfaces/IERC4626.sol";
+
+/// @dev deposit through weth is not neccessary to be done on this contract's level
+/// as we already supported this with our router
+contract PendleSfrxEthSY is SYBase {
+    address public immutable minter;
+    address public immutable frxETH;
+    address public immutable sfrxETH;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _minter
+    ) SYBase(_name, _symbol, IFrxEthMinter(_minter).sfrxETHToken()) {
+        minter = _minter;
+        sfrxETH = IFrxEthMinter(minter).sfrxETHToken();
+        frxETH = IFrxEthMinter(minter).frxETHToken();
+
+        _safeApproveInf(frxETH, sfrxETH);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * The underlying yield token is frxETH. If the base token deposited is ETH, the function
+     * deposits through fraxMinterContract - the most efficient way to get frxETH and deposit
+     * directly to sfrxETH.
+     */
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == NATIVE) {
+            return IFrxEthMinter(minter).submitAndDeposit{ value: amountDeposited }(address(this));
+        } else if (tokenIn == frxETH) {
+            return IERC4626(sfrxETH).deposit(amountDeposited, address(this));
+        } else {
+            return amountDeposited;
+        }
+    }
+
+    /**
+     * Withdrawal to sfrxETH and frxETH is done normally as other ERC4626.
+     * Withdrawal to ETH is on the other hand not possible
+     */
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 /*amountTokenOut*/) {
+        if (tokenOut == sfrxETH) {
+            _transferOut(sfrxETH, receiver, amountSharesToRedeem);
+            return amountSharesToRedeem;
+        } else {
+            return IERC4626(sfrxETH).redeem(amountSharesToRedeem, receiver, address(this));
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice Calculates and updates the exchange rate of shares to underlying asset token
+     * @dev It is the exchange rate of sfrxETH to frxETH
+     */
+    function exchangeRate() public view virtual override returns (uint256) {
+        return IERC4626(sfrxETH).convertToAssets(1 ether);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == sfrxETH) {
+            return amountTokenToDeposit;
+        } else {
+            return IERC4626(sfrxETH).previewDeposit(amountTokenToDeposit);
+        }
+    }
+
+    function _previewRedeem(
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256 /*amountTokenOut*/) {
+        if (tokenOut == sfrxETH) {
+            return amountSharesToRedeem;
+        } else {
+            return IERC4626(sfrxETH).convertToAssets(amountSharesToRedeem);
+        }
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](3);
+        res[0] = frxETH;
+        res[1] = sfrxETH;
+        res[2] = NATIVE;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = frxETH;
+        res[1] = sfrxETH;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == frxETH || token == sfrxETH || token == NATIVE;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == frxETH || token == sfrxETH;
+    }
+
+    function assetInfo()
+        external
+        view
+        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
+    {
+        return (AssetType.TOKEN, frxETH, 18);
+    }
+}

package/contracts/core/StandardizedYield/implementations/PendleStargateLPSY.sol

@@ -0,0 +1,222 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../SYBaseWithRewards.sol";
+import "../../../interfaces/IStargateRouter.sol";
+import "../../../interfaces/IStargateLP.sol";
+import "../../../interfaces/IStargateStaking.sol";
+
+contract PendleStargateLPSY is SYBaseWithRewards {
+    uint256 public constant STARGATE_BP_DENOMINATOR = 10000;
+
+    using Math for uint256;
+
+    uint16 public immutable pid; // pool id
+    uint256 public immutable sid; // staking id
+    address public immutable lp;
+    address public immutable underlying;
+    address public immutable stargateRouter;
+    address public immutable stargateStaking;
+    address public immutable stgToken;
+
+    // preview variables
+    uint256 public immutable convertRate;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _stargateLP,
+        address _stargateStaking,
+        uint256 _sid
+    ) SYBaseWithRewards(_name, _symbol, _stargateLP) {
+        lp = _stargateLP;
+        underlying = IStargateLP(lp).token();
+
+        stargateRouter = IStargateLP(lp).router();
+        pid = uint16(IStargateLP(lp).poolId());
+
+        stargateStaking = _stargateStaking;
+        sid = _sid;
+
+        stgToken = IStargateStaking(stargateStaking).stargate();
+
+        // preview variables
+        convertRate = IStargateLP(lp).convertRate();
+
+        _safeApproveInf(underlying, stargateRouter);
+        _safeApproveInf(lp, stargateStaking);
+
+        _validateStargateStakingId(stargateStaking, sid, lp);
+    }
+
+    function _validateStargateStakingId(
+        address staking,
+        uint256 id,
+        address lpToken
+    ) internal view {
+        (address _lpToken, , , ) = IStargateStaking(staking).poolInfo(id);
+        // Custom error not needed here since this only happens on deployment
+        require(_lpToken == lpToken, "invalid sid & lpToken");
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * The underlying yield token is startgateLP. If the base token deposited is underlying, the function
+     * deposits received underlying into the startgateLP contract.
+     */
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 amountSharesOut) {
+        if (tokenIn == underlying) {
+            IStargateRouter(stargateRouter).addLiquidity(pid, amountDeposited, address(this));
+            amountSharesOut = _selfBalance(lp);
+            // all outstanding LP will be staked
+        } else {
+            amountSharesOut = amountDeposited;
+        }
+        IStargateStaking(stargateStaking).deposit(sid, amountSharesOut);
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 amountTokenOut) {
+        IStargateStaking(stargateStaking).withdraw(sid, amountSharesToRedeem);
+        if (tokenOut == lp) {
+            amountTokenOut = amountSharesToRedeem;
+            _transferOut(lp, receiver, amountTokenOut);
+        } else {
+            /**
+             * @dev There is an lp cap variable in stargate to define the maximum amount of lp
+             * which can be burned.
+             * In case there is not enough liquidity in the pool to proceed the withdrawal,
+             * stargatePool will not revert and try to withdraw as much lp as it can instead.
+             *
+             * When this rare case happens, Pendle's SY should guarantee to revert.
+             */
+
+            uint256 preBalanceLp = _selfBalance(lp);
+
+            uint256 amountSD = IStargateRouter(stargateRouter).instantRedeemLocal(
+                pid,
+                amountSharesToRedeem,
+                receiver
+            );
+            uint256 lpUsed = preBalanceLp - _selfBalance(lp);
+            if (lpUsed < amountSharesToRedeem) {
+                revert Errors.SYStargateRedeemCapExceeded(amountSharesToRedeem, lpUsed);
+            }
+
+            amountTokenOut = amountSD * convertRate;
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice Calculates and updates the exchange rate of shares to underlying asset token
+     * @dev It is the exchange rate of lp to underlying
+     */
+    function exchangeRate() public view virtual override returns (uint256) {
+        return
+            IStargateLP(lp).totalLiquidity().divDown(IStargateLP(lp).totalSupply()) * convertRate;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {IStandardizedYield-getRewardTokens}
+     */
+    function _getRewardTokens() internal view override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = stgToken;
+    }
+
+    function _redeemExternalReward() internal override {
+        IStargateStaking(stargateStaking).withdraw(sid, 0);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 amountSharesOut) {
+        if (tokenIn == lp) {
+            amountSharesOut = amountTokenToDeposit;
+        } else {
+            uint256 totalLiquidity = IStargateLP(lp).totalLiquidity();
+            uint256 totalSupply = IStargateLP(lp).totalSupply();
+            uint256 mintFeeBP = IStargateLP(lp).mintFeeBP();
+
+            uint256 amountSD = amountTokenToDeposit / convertRate;
+
+            // Tho fee is always enabled, it is currently set to zero
+            uint256 mintFeeSD = (amountSD * mintFeeBP) / STARGATE_BP_DENOMINATOR;
+            amountSD = amountSD - mintFeeSD;
+
+            // skip check for lp.totalSupply() == 0
+            amountSharesOut = (amountSD * totalSupply) / totalLiquidity;
+        }
+    }
+
+    function _previewRedeem(
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256 amountTokenOut) {
+        if (tokenOut == lp) {
+            amountTokenOut = amountSharesToRedeem;
+        } else {
+            uint256 totalLiquidity = IStargateLP(lp).totalLiquidity();
+            uint256 totalSupply = IStargateLP(lp).totalSupply();
+            uint256 deltaCredit = IStargateLP(lp).deltaCredit();
+
+            uint256 capAmountLp = (deltaCredit * totalSupply) / totalLiquidity;
+            if (amountSharesToRedeem > capAmountLp) {
+                revert Errors.SYStargateRedeemCapExceeded(amountSharesToRedeem, capAmountLp);
+            }
+
+            uint256 amountSD = (amountSharesToRedeem * totalLiquidity) / totalSupply;
+            amountTokenOut = amountSD * convertRate;
+        }
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = underlying;
+        res[1] = lp;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = underlying;
+        res[1] = lp;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == underlying || token == lp;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == underlying || token == lp;
+    }
+
+    function assetInfo()
+        external
+        view
+        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
+    {
+        return (AssetType.TOKEN, underlying, IERC20Metadata(underlying).decimals());
+    }
+}

package/contracts/core/libraries/Errors.sol

@@ -114,6 +114,10 @@ library Errors {
     error SYBalancerInvalidPid();
     error SYInvalidRewardToken(address token);
 
+    error SYStargateRedeemCapExceeded(uint256 amountLpDesired, uint256 amountLpRedeemable);
+
+    error SYBalancerReentrancy();
+
     // Liquidity Mining
     error VCInactivePool(address pool);
     error VCPoolAlreadyActive(address pool);
@@ -163,6 +167,7 @@ library Errors {
     error ArrayOutOfBounds();
     error ZeroAddress();
     error FailedToSendEther();
+    error InvalidMerkleProof();
 
     error OnlyLayerZeroEndpoint();
     error OnlyYT();

package/contracts/interfaces/Balancer/IVault.sol

@@ -5,6 +5,21 @@ import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import "./IAsset.sol";
 
 interface IVault {
+    enum UserBalanceOpKind {
+        DEPOSIT_INTERNAL,
+        WITHDRAW_INTERNAL,
+        TRANSFER_INTERNAL,
+        TRANSFER_EXTERNAL
+    }
+
+    struct UserBalanceOp {
+        UserBalanceOpKind kind;
+        IAsset asset;
+        uint256 amount;
+        address sender;
+        address payable recipient;
+    }
+
     struct JoinPoolRequest {
         address[] assets;
         uint256[] maxAmountsIn;
@@ -61,12 +76,14 @@ interface IVault {
         uint256 deadline
     ) external payable returns (uint256);
 
-    function getPoolTokens(
-        bytes32 poolId
-    )
+    function getPoolTokens(bytes32 poolId)
         external
         view
-        returns (IERC20[] memory tokens, uint256[] memory balances, uint256 lastChangeBlock);
+        returns (
+            IERC20[] memory tokens,
+            uint256[] memory balances,
+            uint256 lastChangeBlock
+        );
 
     function WETH() external view returns (IERC20);
 

package/contracts/interfaces/Frax/IFrxEthMinter.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface IFrxEthMinter {
+    function frxETHToken() external view returns (address);
+
+    function sfrxETHToken() external view returns (address);
+
+    function submitAndDeposit(address recipient) external payable returns (uint256 shares);
+}

package/contracts/interfaces/GMX/IGlpManager.sol

@@ -9,4 +9,6 @@ interface IGlpManager {
     function gov() external view returns (address);
 
     function setCooldownDuration(uint256 _cooldownDuration) external;
+
+    function getPrice(bool _maximise) external view returns (uint256);
 }

package/contracts/interfaces/IPFeeDistributor.sol

@@ -13,10 +13,9 @@ interface IPFeeDistributor {
         uint128 iter;
     }
 
-    function claimReward(
-        address user,
-        address[] calldata pools
-    ) external returns (uint256[] memory amountRewardOut);
+    function claimReward(address user, address[] calldata pools)
+        external
+        returns (uint256[] memory amountRewardOut);
 
     function getAllPools() external view returns (address[] memory);
 }