@pendle/core-v2 1.4.0-mainnet → 1.4.1-testnet

package/build/artifacts/contracts/router/swap-aggregator/kyberswap/ethereum/IHashflow.sol/IHashflow.json

@@ -0,0 +1,101 @@
+{
+  "_format": "hh-sol-artifact-1",
+  "contractName": "IHashflow",
+  "sourceName": "contracts/router/swap-aggregator/kyberswap/ethereum/IHashflow.sol",
+  "abi": [
+    {
+      "inputs": [
+        {
+          "components": [
+            {
+              "internalType": "enum IHashflow.RFQType",
+              "name": "rfqType",
+              "type": "uint8"
+            },
+            {
+              "internalType": "address",
+              "name": "pool",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "eoa",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "trader",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "effectiveTrader",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "baseToken",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "quoteToken",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "effectiveBaseTokenAmount",
+              "type": "uint256"
+            },
+            {
+              "internalType": "uint256",
+              "name": "maxBaseTokenAmount",
+              "type": "uint256"
+            },
+            {
+              "internalType": "uint256",
+              "name": "maxQuoteTokenAmount",
+              "type": "uint256"
+            },
+            {
+              "internalType": "uint256",
+              "name": "fees",
+              "type": "uint256"
+            },
+            {
+              "internalType": "uint256",
+              "name": "quoteExpiry",
+              "type": "uint256"
+            },
+            {
+              "internalType": "uint256",
+              "name": "nonce",
+              "type": "uint256"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "txid",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "bytes",
+              "name": "signedQuote",
+              "type": "bytes"
+            }
+          ],
+          "internalType": "struct IHashflow.Quote",
+          "name": "quote",
+          "type": "tuple"
+        }
+      ],
+      "name": "tradeSingleHop",
+      "outputs": [],
+      "stateMutability": "payable",
+      "type": "function"
+    }
+  ],
+  "bytecode": "0x",
+  "deployedBytecode": "0x",
+  "linkReferences": {},
+  "deployedLinkReferences": {}
+}

package/build/artifacts/contracts/router/swap-aggregator/kyberswap/ethereum/IMetaAggregationRouterV2.sol/IMetaAggregationRouterV2.dbg.json

@@ -0,0 +1,4 @@
+{
+  "_format": "hh-sol-dbg-1",
+  "buildInfo": "../../../../../../build-info/c3489c617a6ecbf681f91df4f40237bf.json"
+}

package/build/artifacts/contracts/router/{kyberswap/interfaces/IMetaAggregationRouter.sol/IMetaAggregationRouter.json → swap-aggregator/kyberswap/ethereum/IMetaAggregationRouterV2.sol/IMetaAggregationRouterV2.json}

@@ -1,76 +1,98 @@
 {
   "_format": "hh-sol-artifact-1",
-  "contractName": "IMetaAggregationRouter",
-  "sourceName": "contracts/router/kyberswap/interfaces/IMetaAggregationRouter.sol",
+  "contractName": "IMetaAggregationRouterV2",
+  "sourceName": "contracts/router/swap-aggregator/kyberswap/ethereum/IMetaAggregationRouterV2.sol",
   "abi": [
     {
       "inputs": [
-        {
-          "internalType": "contract IAggregationExecutor",
-          "name": "caller",
-          "type": "address"
-        },
         {
           "components": [
             {
-              "internalType": "contract IERC20",
-              "name": "srcToken",
-              "type": "address"
-            },
-            {
-              "internalType": "contract IERC20",
-              "name": "dstToken",
+              "internalType": "address",
+              "name": "callTarget",
               "type": "address"
             },
-            {
-              "internalType": "address[]",
-              "name": "srcReceivers",
-              "type": "address[]"
-            },
-            {
-              "internalType": "uint256[]",
-              "name": "srcAmounts",
-              "type": "uint256[]"
-            },
             {
               "internalType": "address",
-              "name": "dstReceiver",
+              "name": "approveTarget",
               "type": "address"
             },
             {
-              "internalType": "uint256",
-              "name": "amount",
-              "type": "uint256"
-            },
-            {
-              "internalType": "uint256",
-              "name": "minReturnAmount",
-              "type": "uint256"
+              "internalType": "bytes",
+              "name": "targetData",
+              "type": "bytes"
             },
             {
-              "internalType": "uint256",
-              "name": "flags",
-              "type": "uint256"
+              "components": [
+                {
+                  "internalType": "contract IERC20",
+                  "name": "srcToken",
+                  "type": "address"
+                },
+                {
+                  "internalType": "contract IERC20",
+                  "name": "dstToken",
+                  "type": "address"
+                },
+                {
+                  "internalType": "address[]",
+                  "name": "srcReceivers",
+                  "type": "address[]"
+                },
+                {
+                  "internalType": "uint256[]",
+                  "name": "srcAmounts",
+                  "type": "uint256[]"
+                },
+                {
+                  "internalType": "address[]",
+                  "name": "feeReceivers",
+                  "type": "address[]"
+                },
+                {
+                  "internalType": "uint256[]",
+                  "name": "feeAmounts",
+                  "type": "uint256[]"
+                },
+                {
+                  "internalType": "address",
+                  "name": "dstReceiver",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "amount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "minReturnAmount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "flags",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "permit",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct IMetaAggregationRouterV2.SwapDescriptionV2",
+              "name": "desc",
+              "type": "tuple"
             },
             {
               "internalType": "bytes",
-              "name": "permit",
+              "name": "clientData",
               "type": "bytes"
             }
           ],
-          "internalType": "struct IMetaAggregationRouter.SwapDescription",
-          "name": "desc",
+          "internalType": "struct IMetaAggregationRouterV2.SwapExecutionParams",
+          "name": "execution",
           "type": "tuple"
-        },
-        {
-          "internalType": "bytes",
-          "name": "executorData",
-          "type": "bytes"
-        },
-        {
-          "internalType": "bytes",
-          "name": "clientData",
-          "type": "bytes"
         }
       ],
       "name": "swap",
@@ -118,6 +140,16 @@
               "name": "srcAmounts",
               "type": "uint256[]"
             },
+            {
+              "internalType": "address[]",
+              "name": "feeReceivers",
+              "type": "address[]"
+            },
+            {
+              "internalType": "uint256[]",
+              "name": "feeAmounts",
+              "type": "uint256[]"
+            },
             {
               "internalType": "address",
               "name": "dstReceiver",
@@ -144,7 +176,7 @@
               "type": "bytes"
             }
           ],
-          "internalType": "struct IMetaAggregationRouter.SwapDescription",
+          "internalType": "struct IMetaAggregationRouterV2.SwapDescriptionV2",
           "name": "desc",
           "type": "tuple"
         },

package/build/artifacts/contracts/router/swap-aggregator/kyberswap/ethereum/KyberHelperEthereum.sol/KyberHelperEthereum.dbg.json

@@ -0,0 +1,4 @@
+{
+  "_format": "hh-sol-dbg-1",
+  "buildInfo": "../../../../../../build-info/c3489c617a6ecbf681f91df4f40237bf.json"
+}

package/build/artifacts/contracts/router/swap-aggregator/kyberswap/ethereum/KyberHelperEthereum.sol/KyberHelperEthereum.json

@@ -0,0 +1,10 @@
+{
+  "_format": "hh-sol-artifact-1",
+  "contractName": "KyberHelperEthereum",
+  "sourceName": "contracts/router/swap-aggregator/kyberswap/ethereum/KyberHelperEthereum.sol",
+  "abi": [],
+  "bytecode": "0x",
+  "deployedBytecode": "0x",
+  "linkReferences": {},
+  "deployedLinkReferences": {}
+}

package/build/artifacts/contracts/router/swap-aggregator/kyberswap/ethereum/ScaleDataHelperEthereum.sol/ScaleDataHelperEthereum.dbg.json

@@ -0,0 +1,4 @@
+{
+  "_format": "hh-sol-dbg-1",
+  "buildInfo": "../../../../../../build-info/c3489c617a6ecbf681f91df4f40237bf.json"
+}

package/build/artifacts/contracts/router/swap-aggregator/kyberswap/ethereum/ScaleDataHelperEthereum.sol/ScaleDataHelperEthereum.json

@@ -0,0 +1,10 @@
+{
+  "_format": "hh-sol-artifact-1",
+  "contractName": "ScaleDataHelperEthereum",
+  "sourceName": "contracts/router/swap-aggregator/kyberswap/ethereum/ScaleDataHelperEthereum.sol",
+  "abi": [],
+  "bytecode": "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea264697066735822122042f2c9ed6176c32d6ee2a036d64e87452b186ef711dcdaaf7babaeeb5e21038964736f6c63430008110033",
+  "deployedBytecode": "0x73000000000000000000000000000000000000000030146080604052600080fdfea264697066735822122042f2c9ed6176c32d6ee2a036d64e87452b186ef711dcdaaf7babaeeb5e21038964736f6c63430008110033",
+  "linkReferences": {},
+  "deployedLinkReferences": {}
+}

package/contracts/LiquidityMining/CrossChainMsg/PendleMsgReceiveEndpointUpg.sol

@@ -88,11 +88,10 @@ contract PendleMsgReceiveEndpointUpg is
         }
     }
 
-    function govExecuteMessage(address receiver, bytes calldata message)
-        external
-        payable
-        onlyOwner
-    {
+    function govExecuteMessage(
+        address receiver,
+        bytes calldata message
+    ) external payable onlyOwner {
         IPMsgReceiverApp(receiver).executeMessage(message);
     }
 

package/contracts/LiquidityMining/CrossChainMsg/PendleMsgReceiverAppUpg.sol

@@ -22,12 +22,9 @@ abstract contract PendleMsgReceiverAppUpg is IPMsgReceiverApp {
         pendleMsgReceiveEndpoint = _pendleMsgReceiveEndpoint;
     }
 
-    function executeMessage(bytes calldata message)
-        external
-        payable
-        virtual
-        onlyFromPendleMsgReceiveEndpoint
-    {
+    function executeMessage(
+        bytes calldata message
+    ) external virtual onlyFromPendleMsgReceiveEndpoint {
         _executeMessage(message);
     }
 

package/contracts/LiquidityMining/CrossChainMsg/PendleMsgSendEndpointUpg.sol

@@ -74,11 +74,10 @@ contract PendleMsgSendEndpointUpg is
         );
     }
 
-    function addReceiveEndpoints(address endpointAddr, uint256 endpointChainId)
-        external
-        payable
-        onlyOwner
-    {
+    function addReceiveEndpoints(
+        address endpointAddr,
+        uint256 endpointChainId
+    ) external payable onlyOwner {
         receiveEndpoints.set(endpointChainId, endpointAddr);
     }
 
@@ -106,11 +105,9 @@ contract PendleMsgSendEndpointUpg is
 
     function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
 
-    function _getAdapterParams(uint256 estimatedGasAmount)
-        internal
-        pure
-        returns (bytes memory adapterParams)
-    {
+    function _getAdapterParams(
+        uint256 estimatedGasAmount
+    ) internal pure returns (bytes memory adapterParams) {
         // this is more like "type" rather than version
         // It is the type of adapter params you want to pass to relayer
         adapterParams = abi.encodePacked(uint16(1), estimatedGasAmount);

package/contracts/LiquidityMining/CrossChainMsg/PendleMsgSenderAppUpg.sol

@@ -48,11 +48,10 @@ abstract contract PendleMsgSenderAppUpg is BoringOwnableUpgradeable {
         );
     }
 
-    function addDestinationContract(address _address, uint256 _chainId)
-        external
-        payable
-        onlyOwner
-    {
+    function addDestinationContract(
+        address _address,
+        uint256 _chainId
+    ) external payable onlyOwner {
         destinationContracts.set(_chainId, _address);
     }
 
@@ -74,11 +73,10 @@ abstract contract PendleMsgSenderAppUpg is BoringOwnableUpgradeable {
         }
     }
 
-    function _getSendMessageFee(uint256 chainId, bytes memory message)
-        internal
-        view
-        returns (uint256)
-    {
+    function _getSendMessageFee(
+        uint256 chainId,
+        bytes memory message
+    ) internal view returns (uint256) {
         return
             pendleMsgSendEndpoint.calcFee(
                 destinationContracts.get(chainId),

package/contracts/LiquidityMining/CrossChainMsg/libraries/LayerZeroHelper.sol

@@ -5,18 +5,28 @@ library LayerZeroHelper {
     uint256 constant EVM_ADDRESS_SIZE = 20;
 
     function _getLayerZeroChainIds(uint256 chainId) internal pure returns (uint16) {
-        if (chainId == 43113) return 10106; // fuji testnet
-        else if (chainId == 80001) return 10109; // mumbai testnet
-        else if (chainId == 43114) return 106;  // avax mainnet
-        else if (chainId == 42161) return 110; // arbitrum one
+        if (chainId == 43113) return 10106;
+        // fuji testnet
+        else if (chainId == 80001) return 10109;
+        // mumbai testnet
+        else if (chainId == 43114) return 106;
+        // avax mainnet
+        else if (chainId == 42161) return 110;
+        // arbitrum one
+        else if (chainId == 1) return 101;
         assert(false);
     }
 
     function _getOriginalChainIds(uint16 chainId) internal pure returns (uint256) {
-        if (chainId == 10106) return 43113; // fuji testnet
-        else if (chainId == 10109) return 80001; // mumbai testnet
-        else if (chainId == 106) return 43114; // avax mainnet
-        else if (chainId == 110) return 42161; // arbitrum one
+        if (chainId == 10106) return 43113;
+        // fuji testnet
+        else if (chainId == 10109) return 80001;
+        // mumbai testnet
+        else if (chainId == 106) return 43114;
+        // avax mainnet
+        else if (chainId == 110) return 42161;
+        // arbitrum one
+        else if (chainId == 101) return 1;
         assert(false);
     }
 

package/contracts/LiquidityMining/GaugeController/PendleGaugeControllerBaseUpg.sol

@@ -132,11 +132,9 @@ abstract contract PendleGaugeControllerBaseUpg is
      * Pendle distributed to the accumulatedPendle
      * @dev expect to update accumulatedPendle & lastUpdated in MarketRewardData
      */
-    function _getUpdatedMarketReward(address market)
-        internal
-        view
-        returns (MarketRewardData memory)
-    {
+    function _getUpdatedMarketReward(
+        address market
+    ) internal view returns (MarketRewardData memory) {
         MarketRewardData memory rwd = rewardData[market];
         uint128 newLastUpdated = uint128(Math.min(uint128(block.timestamp), rwd.incentiveEndsAt));
         rwd.accumulatedPendle += rwd.pendlePerSec * (newLastUpdated - rwd.lastUpdated);

package/contracts/LiquidityMining/README.md

@@ -1,53 +1,54 @@
 # vePendle For Launch
 
 ### Locking PENDLE for vePendle (on ETH)
-* Each user can only lock for a maximum of $MAXLOCKTIME$ = 2 years
-* vePendle balance for users is represented by:
-$balance_u(t) = bias_u - slope_u * t$
-
-* As such, we just need to store $bias_u$ and $slope_u$ for each user. (Considerations: store $bias_u$ and $t_{expiry}$ for the user instead, because $t_{expiry}$ is always an exact number)
-* The amount of PENDLE locked by user $u$ is $locked_u$
-* For total supply, it's simply $totalBalance = totalBias - totalSlope * t$
-* Possible actions by an user:
-    * User $u$ create a new lock by locking $d_{PENDLE}$ of PENDLE tokens, expiring at $t_{expiry}$
-        $slope_u = d_{PENDLE} / MAXLOCKTIME$
-        $bias_u = slope_u \cdot t_{expiry}$
-    * User $u$ locks an additional of $d_{PENDLE}$ PENDLE tokens, into his existing lock expiring at $t_{expiry}$
-        $slope_{u_{new}} = slope_u + d_{PENDLE} / MAXLOCKTIME$
-        $bias_{u_{new}} = slope_{u_{new}} \cdot t_{expiry}$
-    * User $u$ extends his expiry from $t_{expiry}$ to $t_{expiry_{new}}$
-        $bias_{u_{new}} = slope_{u} \cdot t_{expiry_{new}}$
-        
-* Similar to Curve:
-    * We store the checkpoints for when a user's $slope$ or $bias$ changes
-    * We restrict the possible expiries to exact weeks from UNIX timestamp 0
-    * We store the global bias and slope changes due to expiry of user's vote-locks per week, and process it when the week comes
+
+- Each user can only lock for a maximum of $MAXLOCKTIME$ = 2 years
+- vePendle balance for users is represented by:
+  $balance_u(t) = bias_u - slope_u * t$
+
+- As such, we just need to store $bias_u$ and $slope_u$ for each user. (Considerations: store $bias_u$ and $t_{expiry}$ for the user instead, because $t_{expiry}$ is always an exact number)
+- The amount of PENDLE locked by user $u$ is $locked_u$
+- For total supply, it's simply $totalBalance = totalBias - totalSlope * t$
+- Possible actions by an user:
+  - User $u$ create a new lock by locking $d_{PENDLE}$ of PENDLE tokens, expiring at $t_{expiry}$
+    $slope_u = d_{PENDLE} / MAXLOCKTIME$
+    $bias_u = slope_u \cdot t_{expiry}$
+  - User $u$ locks an additional of $d_{PENDLE}$ PENDLE tokens, into his existing lock expiring at $t_{expiry}$
+    $slope_{u_{new}} = slope_u + d_{PENDLE} / MAXLOCKTIME$
+    $bias_{u_{new}} = slope_{u_{new}} \cdot t_{expiry}$
+  - User $u$ extends his expiry from $t_{expiry}$ to $t_{expiry_{new}}$
+    $bias_{u_{new}} = slope_{u} \cdot t_{expiry_{new}}$
+- Similar to Curve:
+  - We store the checkpoints for when a user's $slope$ or $bias$ changes
+  - We restrict the possible expiries to exact weeks from UNIX timestamp 0
+  - We store the global bias and slope changes due to expiry of user's vote-locks per week, and process it when the week comes
 
 ### Cross-chain messaging module
-* There are contracts inheritting `CelerSender` on governance chain - Ethereum, with a function `sendMessage(chain Y, sender, message)` to send messages to other chains.
-* On each non-governance chain, we have contracts inheritting `CelerReceiver`. Each has a function `afterReceivingMessage(sender, message)` to receive the message from governance.
-* When `sendMessage(chain Y, sender, message)` is called on governance chain, `afterReceivingMessage(sender, message)`  will be called on chain Y, thanks to the cross-chain messaging module
-* The current mechanics for the module is using Celer
-* The cross-chain messaging module can be plugged in/plugged out by the governance address (which will initially be controlled by a team multisig)
+
+- There are contracts inheritting `CelerSender` on governance chain - Ethereum, with a function `sendMessage(chain Y, sender, message)` to send messages to other chains.
+- On each non-governance chain, we have contracts inheritting `CelerReceiver`. Each has a function `afterReceivingMessage(sender, message)` to receive the message from governance.
+- When `sendMessage(chain Y, sender, message)` is called on governance chain, `afterReceivingMessage(sender, message)` will be called on chain Y, thanks to the cross-chain messaging module
+- The current mechanics for the module is using Celer
+- The cross-chain messaging module can be plugged in/plugged out by the governance address (which will initially be controlled by a team multisig)
 
 ### Voting for incentives on market and chains
-* On Ethereum, there is a `VotingController` contract to control the voting on incentives for the different markets on the different chains.
-* Adding a new chain:
-    * Only the governance address will be able to add markets and a new chains' GaugeController.
-* There is a list of `(market)` that are elligible for the voting, added by governance
-    * markets that are expired will be removed by governance
-* vePendle holders can allocate their vePendle to multiple markets on multiple chains
-* Similar to Curve, we store the bias and slope of the total vePendle voted for every market
-    * Similary, we adjust the slope/bias changes due to expired vePendle at the weekly mark
-* There is a global PENDLE per second rate for all the incentives across all the chains. This is set by governance.
-* The `VotingController` does not hold any fund. The incentivizing PENDLE is transferred directly to GaugeController by governacne. 
-        * GaugeControllers: admin can withdraw PENDLE from it
-* In each chain, there is a `GaugeController` contract that is responsible for keeping PENDLE incentives and distributing PENDLE to incentivise different markets.
-* At the finalization of each week (starting of new week), anyone can call a function `finalizeVotingResults` and then `broadcastVotes()` in `VotingController` to broadcast to any chain:
-    1. The PENDLE allocation of each market for the next week
-    2. The timestamp to mark which week is the incentivization coming from
-    When this happens, the `GaugeController` in each chain will update the PENDLE per second among the different markets
-* At any time, the governacne has the voting power equivalent to locking X PENDLE in 2 years
+
+- On Ethereum, there is a `VotingController` contract to control the voting on incentives for the different markets on the different chains.
+- Adding a new chain:
+  - Only the governance address will be able to add markets and a new chains' GaugeController.
+- There is a list of `(market)` that are elligible for the voting, added by governance
+  - markets that are expired will be removed by governance
+- vePendle holders can allocate their vePendle to multiple markets on multiple chains
+- Similar to Curve, we store the bias and slope of the total vePendle voted for every market
+  - Similary, we adjust the slope/bias changes due to expired vePendle at the weekly mark
+- There is a global PENDLE per second rate for all the incentives across all the chains. This is set by governance.
+- The `VotingController` does not hold any fund. The incentivizing PENDLE is transferred directly to GaugeController by governacne. \* GaugeControllers: admin can withdraw PENDLE from it
+- In each chain, there is a `GaugeController` contract that is responsible for keeping PENDLE incentives and distributing PENDLE to incentivise different markets.
+- At the finalization of each week (starting of new week), anyone can call a function `finalizeVotingResults` and then `broadcastVotes()` in `VotingController` to broadcast to any chain:
+  1. The PENDLE allocation of each market for the next week
+  2. The timestamp to mark which week is the incentivization coming from
+     When this happens, the `GaugeController` in each chain will update the PENDLE per second among the different markets
+- At any time, the governacne has the voting power equivalent to locking X PENDLE in 2 years
 
 ### GaugeController
 
@@ -56,8 +57,10 @@ Gauge controller will receive the voting results from VotingController and incen
 If there is still leftover reward in each pool, the gauge controller will remove and take the leftover to top up the incentivize for the current week.
 
 ### Gauge & Market
-* The Gauge/Market will receive rewardTokens from SCY as well as claiming the PENDLE token from gauge controller. All of the reward tokens (including PENDLE) will be distributed with boosting mechanism
+
+- The Gauge/Market will receive rewardTokens from SCY as well as claiming the PENDLE token from gauge controller. All of the reward tokens (including PENDLE) will be distributed with boosting mechanism
 
 ### Broadcasting vePendle balance & different address for boosting rewards for each chain
-* At anytime, an address A could send a cross message to update the vePendle balance on a specific chain
-* The governance reserves the right to set the vePENDLE delegator for some address (for other protocols to build on top).
+
+- At anytime, an address A could send a cross message to update the vePendle balance on a specific chain
+- The governance reserves the right to set the vePENDLE delegator for some address (for other protocols to build on top).

package/contracts/LiquidityMining/VeDistributor/PendleFeeDistributor.sol

@@ -37,11 +37,7 @@ contract PendleFeeDistributor is UUPSUpgradeable, BoringOwnableUpgradeable, IPFe
         _;
     }
 
-    constructor(
-        address _votingController,
-        address _vePendle,
-        address _rewardToken
-    ) initializer {
+    constructor(address _votingController, address _vePendle, address _rewardToken) initializer {
         votingController = _votingController;
         vePendle = _vePendle;
         token = _rewardToken;
@@ -114,10 +110,10 @@ contract PendleFeeDistributor is UUPSUpgradeable, BoringOwnableUpgradeable, IPFe
         lastFundedWeek[pool] = lastFunded;
     }
 
-    function claimReward(address user, address[] calldata pools)
-        external
-        returns (uint256[] memory amountRewardOut)
-    {
+    function claimReward(
+        address user,
+        address[] calldata pools
+    ) external returns (uint256[] memory amountRewardOut) {
         amountRewardOut = new uint256[](pools.length);
         for (uint256 i = 0; i < pools.length; ) {
             amountRewardOut[i] = _accumulateUserReward(pools[i], user);
@@ -132,11 +128,10 @@ contract PendleFeeDistributor is UUPSUpgradeable, BoringOwnableUpgradeable, IPFe
         return allPools;
     }
 
-    function _accumulateUserReward(address pool, address user)
-        internal
-        ensureValidPool(pool)
-        returns (uint256 totalReward)
-    {
+    function _accumulateUserReward(
+        address pool,
+        address user
+    ) internal ensureValidPool(pool) returns (uint256 totalReward) {
         uint256 length = _getUserCheckpointLength(pool, user);
         if (length == 0) return 0;