@pendle/core-v2 3.0.0-beta-9 → 3.0.0

package/contracts/core/StandardizedYield/implementations/MUX/PendleMlpSY.sol

@@ -0,0 +1,195 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../SYBaseWithRewards.sol";
+import "../../../../interfaces/MUX/IMUXRewardRouter.sol";
+import "../../../../interfaces/IPPriceFeed.sol";
+import "../../../libraries/ArrayLib.sol";
+
+contract PendleMlpSY is SYBaseWithRewards {
+    using PMath for uint256;
+
+    uint256 constant VEMUX_MAXTIME = 4 * 365 * 86400; // 4 years
+
+    address public immutable mlp;
+    address public immutable sMlp;
+    address public immutable mux;
+    address public immutable weth;
+    address public immutable arb;
+    address public immutable rewardRouter;
+
+    // reward status
+    bool public hasVeMuxPosition;
+    bool public isRewardSettled;
+
+    // non-security related
+    address public immutable mlpPriceFeed;
+
+    constructor(
+        address _rewardRouter,
+        address _mlpPriceFeed,
+        address _arb
+    ) SYBaseWithRewards("SY MUXLP", "SY-MUXLP", IMUXRewardRouter(_rewardRouter).mlp()) {
+        rewardRouter = _rewardRouter;
+        weth = IMUXRewardRouter(_rewardRouter).weth();
+        mlp = IMUXRewardRouter(_rewardRouter).mlp();
+        sMlp = IMUXRewardRouter(_rewardRouter).mlpMuxTracker();
+        mux = IMUXRewardRouter(_rewardRouter).mux();
+        arb = _arb;
+
+        mlpPriceFeed = _mlpPriceFeed;
+
+        // Dont have to approve for mlpMuxTracker as the contract allows whitelisted handlers
+        // to transfer from anyone (MUX's reward router in this case)
+        _safeApproveInf(mlp, IMUXRewardRouter(_rewardRouter).mlpFeeTracker());
+        _safeApproveInf(mux, IMUXRewardRouter(_rewardRouter).votingEscrow());
+        _safeApproveInf(mux, IMUXRewardRouter(_rewardRouter).muxVester());
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == mlp) {
+            IMUXRewardRouter(rewardRouter).stakeMlp(amountDeposited);
+        }
+        return amountDeposited;
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 /*amountTokenOut*/) {
+        if (tokenOut == mlp) {
+            IMUXRewardRouter(rewardRouter).unstakeMlp(amountSharesToRedeem);
+        }
+        _transferOut(tokenOut, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return PMath.ONE;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {IStandardizedYield-getRewardTokens}
+     */
+    function _getRewardTokens() internal view override returns (address[] memory) {
+        return ArrayLib.create(weth, arb);
+    }
+
+    function _redeemExternalReward() internal override {
+        // IMUXRewardRouter(rewardRouter).compound() would revert in the case mux to be compounded = 0 (2 txns in the same block)
+        // So we should not use that method
+        IMUXRewardRouter(rewardRouter).claimAll();
+
+        bool _hasVeMuxPosition = hasVeMuxPosition;
+        bool _isRewardSettled = isRewardSettled;
+
+        if (_isRewardSettled) return;
+
+        uint256 muxBalance = _selfBalance(mux);
+        if (muxBalance > 0) {
+            IMUXRewardRouter(rewardRouter).stakeMux(muxBalance, block.timestamp + VEMUX_MAXTIME);
+            if (!_hasVeMuxPosition) {
+                hasVeMuxPosition = true;
+            }
+        } else if (_hasVeMuxPosition) {
+            IMUXRewardRouter(rewardRouter).increaseStakeUnlockTime(block.timestamp + VEMUX_MAXTIME);
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 /*amountSharesOut*/) {
+        return amountTokenToDeposit;
+    }
+
+    function _previewRedeem(
+        address,
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256 /*amountTokenOut*/) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(mlp, sMlp);
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(mlp, sMlp);
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == mlp || token == sMlp;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == mlp || token == sMlp;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.LIQUIDITY, mlp, IERC20Metadata(mlp).decimals());
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                        GOVERNANCE WITHDRAWAL
+    //////////////////////////////////////////////////////////////*/
+
+    function setRewardStatus(bool _isRewardSettled) external onlyOwner {
+        isRewardSettled = _isRewardSettled;
+    }
+
+    /**
+     * @dev this function assumes revert if the lock hasnt expired
+     * @dev There are two methods for vesting MUX (one through veMUX culmulative reward and one through paired staked MLP)
+     *
+     * Will not go with the later one as this contract should not utilize users' sMLP for other purposes
+     */
+    function withdrawAndVestMux() external onlyOwner {
+        IMUXRewardRouter(rewardRouter).unstakeMcbAndMux();
+
+        uint256 amountToVest = PMath.min(
+            _selfBalance(mux),
+            IMUXRewardRouter(rewardRouter).maxVestableTokenFromVe(address(this))
+        );
+        IMUXRewardRouter(rewardRouter).depositToVeVester(amountToVest);
+    }
+
+    function claimVestedRewards(address receiver) external onlyOwner returns (uint256 amountClaimed) {
+        IMUXRewardRouter(rewardRouter).claimVestedTokenFromVe(address(this));
+
+        address mcb = IMUXRewardRouter(rewardRouter).mcb();
+        amountClaimed = _selfBalance(mcb);
+        if (amountClaimed != 0) {
+            _transferOut(mcb, receiver, amountClaimed);
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                        OFF-CHAIN USAGE ONLY
+            (NO SECURITY RELATED && CAN BE LEFT UNAUDITED)
+    //////////////////////////////////////////////////////////////*/
+
+    function getPrice() external view returns (uint256) {
+        return IPPriceFeed(mlpPriceFeed).getPrice();
+    }
+}

package/contracts/core/StandardizedYield/implementations/MantleStakedEth/PendleMantleStakedEthSY.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../../SYBase.sol";
 import "../../../../interfaces/IPOracleForSy.sol";
@@ -28,14 +28,7 @@ contract PendleMantleStakedEthSY is SYBase {
                     DEPOSIT/REDEEM USING BASE TOKENS
     //////////////////////////////////////////////////////////////*/
 
-    function _deposit(address, uint256 amountDeposited)
-        internal
-        pure
-        override
-        returns (
-            uint256 /*amountSharesOut*/
-        )
-    {
+    function _deposit(address, uint256 amountDeposited) internal pure override returns (uint256 /*amountSharesOut*/) {
         return amountDeposited;
     }
 
@@ -43,13 +36,7 @@ contract PendleMantleStakedEthSY is SYBase {
         address receiver,
         address tokenOut,
         uint256 amountSharesToRedeem
-    )
-        internal
-        override
-        returns (
-            uint256 /*amountTokenOut*/
-        )
-    {
+    ) internal override returns (uint256 /*amountTokenOut*/) {
         _transferOut(tokenOut, receiver, amountSharesToRedeem);
         return amountSharesToRedeem;
     }
@@ -66,25 +53,17 @@ contract PendleMantleStakedEthSY is SYBase {
                 MISC FUNCTIONS FOR METADATA
     //////////////////////////////////////////////////////////////*/
 
-    function _previewDeposit(address, uint256 amountTokenToDeposit)
-        internal
-        pure
-        override
-        returns (
-            uint256 /*amountSharesOut*/
-        )
-    {
+    function _previewDeposit(
+        address,
+        uint256 amountTokenToDeposit
+    ) internal pure override returns (uint256 /*amountSharesOut*/) {
         return amountTokenToDeposit;
     }
 
-    function _previewRedeem(address, uint256 amountSharesToRedeem)
-        internal
-        pure
-        override
-        returns (
-            uint256 /*amountTokenOut*/
-        )
-    {
+    function _previewRedeem(
+        address,
+        uint256 amountSharesToRedeem
+    ) internal pure override returns (uint256 /*amountTokenOut*/) {
         return amountSharesToRedeem;
     }
 
@@ -106,15 +85,7 @@ contract PendleMantleStakedEthSY is SYBase {
         return token == yieldToken;
     }
 
-    function assetInfo()
-        external
-        view
-        returns (
-            AssetType assetType,
-            address assetAddress,
-            uint8 assetDecimals
-        )
-    {
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
         return (AssetType.TOKEN, underlyingAssetOnEthAddr, underlyingAssetOnEthDecimals);
     }
 }

package/contracts/core/StandardizedYield/implementations/MantleStakedEth/PendleOracleForSyProxy.sol

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

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

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../SYBase.sol";
-import { AggregatorV2V3Interface as IChainlinkAggregator } from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
+import {AggregatorV2V3Interface as IChainlinkAggregator} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
 
 contract PendleArbitrumStakedEthSY is SYBase {
     using PMath for int256;
@@ -28,14 +28,7 @@ contract PendleArbitrumStakedEthSY is SYBase {
                     DEPOSIT/REDEEM USING BASE TOKENS
     //////////////////////////////////////////////////////////////*/
 
-    function _deposit(address, uint256 amountDeposited)
-        internal
-        pure
-        override
-        returns (
-            uint256 /*amountSharesOut*/
-        )
-    {
+    function _deposit(address, uint256 amountDeposited) internal pure override returns (uint256 /*amountSharesOut*/) {
         return amountDeposited;
     }
 
@@ -43,13 +36,7 @@ contract PendleArbitrumStakedEthSY is SYBase {
         address receiver,
         address tokenOut,
         uint256 amountSharesToRedeem
-    )
-        internal
-        override
-        returns (
-            uint256 /*amountTokenOut*/
-        )
-    {
+    ) internal override returns (uint256 /*amountTokenOut*/) {
         _transferOut(tokenOut, receiver, amountSharesToRedeem);
         return amountSharesToRedeem;
     }
@@ -66,25 +53,17 @@ contract PendleArbitrumStakedEthSY is SYBase {
                 MISC FUNCTIONS FOR METADATA
     //////////////////////////////////////////////////////////////*/
 
-    function _previewDeposit(address, uint256 amountTokenToDeposit)
-        internal
-        pure
-        override
-        returns (
-            uint256 /*amountSharesOut*/
-        )
-    {
+    function _previewDeposit(
+        address,
+        uint256 amountTokenToDeposit
+    ) internal pure override returns (uint256 /*amountSharesOut*/) {
         return amountTokenToDeposit;
     }
 
-    function _previewRedeem(address, uint256 amountSharesToRedeem)
-        internal
-        pure
-        override
-        returns (
-            uint256 /*amountTokenOut*/
-        )
-    {
+    function _previewRedeem(
+        address,
+        uint256 amountSharesToRedeem
+    ) internal pure override returns (uint256 /*amountTokenOut*/) {
         return amountSharesToRedeem;
     }
 
@@ -106,15 +85,7 @@ contract PendleArbitrumStakedEthSY is SYBase {
         return token == yieldToken;
     }
 
-    function assetInfo()
-        external
-        view
-        returns (
-            AssetType assetType,
-            address assetAddress,
-            uint8 assetDecimals
-        )
-    {
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
         return (AssetType.TOKEN, underlyingAssetOnEthAddr, underlyingAssetOnEthDecimals);
     }
 }

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

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../SYBase.sol";
-import { AggregatorV2V3Interface as IChainlinkAggregator } from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
+import {AggregatorV2V3Interface as IChainlinkAggregator} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
 
 contract PendleBridgedLSDSY is SYBase {
     using PMath for int256;
@@ -28,10 +28,7 @@ contract PendleBridgedLSDSY is SYBase {
                     DEPOSIT/REDEEM USING BASE TOKENS
     //////////////////////////////////////////////////////////////*/
 
-    function _deposit(
-        address,
-        uint256 amountDeposited
-    ) internal pure override returns (uint256 /*amountSharesOut*/) {
+    function _deposit(address, uint256 amountDeposited) internal pure override returns (uint256 /*amountSharesOut*/) {
         return amountDeposited;
     }
 
@@ -89,11 +86,7 @@ contract PendleBridgedLSDSY is SYBase {
         return token == yieldToken;
     }
 
-    function assetInfo()
-        external
-        view
-        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
-    {
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
         return (AssetType.TOKEN, underlyingAssetOnEthAddr, underlyingAssetOnEthDecimals);
     }
 }

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

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../SYBase.sol";
 import "../../../interfaces/IERC4626.sol";
@@ -8,11 +8,7 @@ contract PendleERC4626SY is SYBase {
     using PMath for uint256;
     address public immutable asset;
 
-    constructor(
-        string memory _name,
-        string memory _symbol,
-        address _erc4626
-    ) SYBase(_name, _symbol, _erc4626) {
+    constructor(string memory _name, string memory _symbol, address _erc4626) SYBase(_name, _symbol, _erc4626) {
         asset = IERC4626(_erc4626).asset();
         _safeApproveInf(asset, _erc4626);
     }
@@ -37,11 +33,7 @@ contract PendleERC4626SY is SYBase {
             amountTokenOut = amountSharesToRedeem;
             _transferOut(yieldToken, receiver, amountTokenOut);
         } else {
-            amountTokenOut = IERC4626(yieldToken).redeem(
-                amountSharesToRedeem,
-                receiver,
-                address(this)
-            );
+            amountTokenOut = IERC4626(yieldToken).redeem(amountSharesToRedeem, receiver, address(this));
         }
     }
 
@@ -87,11 +79,7 @@ contract PendleERC4626SY is SYBase {
         return token == yieldToken || token == asset;
     }
 
-    function assetInfo()
-        external
-        view
-        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
-    {
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
         return (AssetType.TOKEN, asset, IERC20Metadata(asset).decimals());
     }
 }

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

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../SYBase.sol";
 import "../../../interfaces/Lybra/IEUSD.sol";
@@ -7,11 +7,7 @@ import "../../../interfaces/Lybra/IEUSD.sol";
 contract PendleEUSDSY is SYBase {
     address public immutable eUSD;
 
-    constructor(
-        string memory _name,
-        string memory _symbol,
-        address _eUSD
-    ) SYBase(_name, _symbol, _eUSD) {
+    constructor(string memory _name, string memory _symbol, address _eUSD) SYBase(_name, _symbol, _eUSD) {
         eUSD = _eUSD;
     }
 
@@ -78,11 +74,7 @@ contract PendleEUSDSY is SYBase {
         return token == eUSD;
     }
 
-    function assetInfo()
-        external
-        view
-        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
-    {
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
         assetType = AssetType.TOKEN;
         assetAddress = eUSD;
         assetDecimals = 18;

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

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../SYBase.sol";
 import "../../../interfaces/IERC4626.sol";
@@ -8,11 +8,7 @@ contract PendleGDaiSY is SYBase {
     address public immutable DAI;
     address public immutable gDAI;
 
-    constructor(
-        string memory _name,
-        string memory _symbol,
-        address _gDAI
-    ) SYBase(_name, _symbol, _gDAI) {
+    constructor(string memory _name, string memory _symbol, address _gDAI) SYBase(_name, _symbol, _gDAI) {
         gDAI = _gDAI;
         DAI = IERC4626(gDAI).asset();
         _safeApproveInf(DAI, gDAI);
@@ -102,11 +98,7 @@ contract PendleGDaiSY is SYBase {
         return token == gDAI;
     }
 
-    function assetInfo()
-        external
-        view
-        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
-    {
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
         return (AssetType.TOKEN, DAI, 18);
     }
 }

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

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../SYBase.sol";
 import "../../../interfaces/ILooksFeeSharing.sol";
@@ -30,10 +30,7 @@ contract PendleLooksStakingSY is SYBase {
                     DEPOSIT/REDEEM USING BASE TOKENS
     //////////////////////////////////////////////////////////////*/
 
-    function _deposit(
-        address,
-        uint256 amountDeposited
-    ) internal virtual override returns (uint256 amountSharesOut) {
+    function _deposit(address, uint256 amountDeposited) internal virtual override returns (uint256 amountSharesOut) {
         uint256 previousShare = ILooksStaking(stakingContract).userInfo(address(this));
         ILooksStaking(stakingContract).deposit(amountDeposited);
         amountSharesOut = ILooksStaking(stakingContract).userInfo(address(this)) - previousShare;
@@ -79,15 +76,9 @@ contract PendleLooksStakingSY is SYBase {
         amountTokenOut = (amountSharesToRedeem * totalLooks) / totalShares;
     }
 
-    function _getLooksStakingParams()
-        private
-        view
-        returns (uint256 totalShares, uint256 totalLooks)
-    {
+    function _getLooksStakingParams() private view returns (uint256 totalShares, uint256 totalLooks) {
         totalShares = ILooksStaking(stakingContract).totalShares();
-        totalLooks = ILooksFeeSharing(feeSharingContract).calculateSharesValueInLOOKS(
-            stakingContract
-        );
+        totalLooks = ILooksFeeSharing(feeSharingContract).calculateSharesValueInLOOKS(stakingContract);
     }
 
     function getTokensIn() public view virtual override returns (address[] memory res) {
@@ -108,11 +99,7 @@ contract PendleLooksStakingSY is SYBase {
         return token == looks;
     }
 
-    function assetInfo()
-        external
-        view
-        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
-    {
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
         return (AssetType.TOKEN, looks, IERC20Metadata(looks).decimals());
     }
 }

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

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../SYBase.sol";
 import "../../../interfaces/Frax/IFrxEthMinter.sol";
@@ -38,7 +38,7 @@ contract PendleSfrxEthSY is SYBase {
         uint256 amountDeposited
     ) internal virtual override returns (uint256 /*amountSharesOut*/) {
         if (tokenIn == NATIVE) {
-            return IFrxEthMinter(minter).submitAndDeposit{ value: amountDeposited }(address(this));
+            return IFrxEthMinter(minter).submitAndDeposit{value: amountDeposited}(address(this));
         } else if (tokenIn == frxETH) {
             return IERC4626(sfrxETH).deposit(amountDeposited, address(this));
         } else {
@@ -122,11 +122,7 @@ contract PendleSfrxEthSY is SYBase {
         return token == frxETH || token == sfrxETH;
     }
 
-    function assetInfo()
-        external
-        view
-        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
-    {
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
         return (AssetType.TOKEN, frxETH, 18);
     }
 }

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

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../SYBaseWithRewards.sol";
 import "../../../interfaces/IStargateRouter.sol";
@@ -49,11 +49,7 @@ contract PendleStargateLPSY is SYBaseWithRewards {
         _validateStargateStakingId(stargateStaking, sid, lp);
     }
 
-    function _validateStargateStakingId(
-        address staking,
-        uint256 id,
-        address lpToken
-    ) internal view {
+    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");
@@ -102,11 +98,7 @@ contract PendleStargateLPSY is SYBaseWithRewards {
 
             uint256 preBalanceLp = _selfBalance(lp);
 
-            uint256 amountSD = IStargateRouter(stargateRouter).instantRedeemLocal(
-                pid,
-                amountSharesToRedeem,
-                receiver
-            );
+            uint256 amountSD = IStargateRouter(stargateRouter).instantRedeemLocal(pid, amountSharesToRedeem, receiver);
             uint256 lpUsed = preBalanceLp - _selfBalance(lp);
             if (lpUsed < amountSharesToRedeem) {
                 revert Errors.SYStargateRedeemCapExceeded(amountSharesToRedeem, lpUsed);
@@ -125,8 +117,7 @@ contract PendleStargateLPSY is SYBaseWithRewards {
      * @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;
+        return IStargateLP(lp).totalLiquidity().divDown(IStargateLP(lp).totalSupply()) * convertRate;
     }
 
     /*///////////////////////////////////////////////////////////////
@@ -212,11 +203,7 @@ contract PendleStargateLPSY is SYBaseWithRewards {
         return token == underlying || token == lp;
     }
 
-    function assetInfo()
-        external
-        view
-        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
-    {
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
         return (AssetType.TOKEN, underlying, IERC20Metadata(underlying).decimals());
     }
 }