@pendle/core-v2 3.0.0-beta-11 → 3.0.0-beta-13

package/contracts/core/StandardizedYield/implementations/PendleWbEthSY.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/BinanceEth/IWBETH.sol";
@@ -25,10 +25,7 @@ contract PendleWbEthSY is SYBase {
                     DEPOSIT/REDEEM USING BASE TOKENS
     //////////////////////////////////////////////////////////////*/
 
-    function _deposit(
-        address tokenIn,
-        uint256 amountDeposited
-    ) internal override returns (uint256 amountSharesOut) {
+    function _deposit(address tokenIn, uint256 amountDeposited) internal override returns (uint256 amountSharesOut) {
         if (tokenIn == eth) {
             uint256 previousBalance = _selfBalance(wbETH);
             IWBETH(wbETH).deposit(amountDeposited, address(this));
@@ -98,11 +95,7 @@ contract PendleWbEthSY is SYBase {
         return token == wbETH;
     }
 
-    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, eth, 18);
     }
 }

package/contracts/core/StandardizedYield/implementations/PendleWstEthSY.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/IWstETH.sol";
@@ -48,9 +48,7 @@ contract PendleWstEthSY is SYBase {
             } else {
                 if (tokenIn == wETH) IWETH(wETH).withdraw(amountDeposited);
 
-                uint256 amountStEthSharesOut = IStETH(stETH).submit{ value: amountDeposited }(
-                    address(0)
-                );
+                uint256 amountStEthSharesOut = IStETH(stETH).submit{value: amountDeposited}(address(0));
                 amountStETH = IStETH(stETH).getPooledEthByShares(amountStEthSharesOut);
             }
             amountSharesOut = IWstETH(wstETH).wrap(amountStETH);
@@ -101,9 +99,7 @@ contract PendleWstEthSY is SYBase {
             if (tokenIn != stETH) {
                 uint256 totalShares = IStETH(stETH).getTotalShares();
                 uint256 totalPooledEth = IStETH(stETH).getTotalPooledEther();
-                uint256 amountStEthSharesOut = IStETH(stETH).getSharesByPooledEth(
-                    amountTokenToDeposit
-                );
+                uint256 amountStEthSharesOut = IStETH(stETH).getSharesByPooledEth(amountTokenToDeposit);
 
                 totalShares += amountStEthSharesOut;
                 totalPooledEth += amountTokenToDeposit;
@@ -146,11 +142,7 @@ contract PendleWstEthSY is SYBase {
         return token == stETH || token == wstETH;
     }
 
-    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, stETH, IERC20Metadata(stETH).decimals());
     }
 }

package/contracts/core/StandardizedYield/implementations/Silo/PendleSiloWithIncentiveSY.sol

@@ -0,0 +1,157 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.17;
+
+import "../../SYBaseWithRewards.sol";
+import "../../../../interfaces/Silo/ISiloIncentiveController.sol";
+import "../../../../interfaces/Silo/ISilo.sol";
+import "../../../../interfaces/Silo/ISiloLens.sol";
+import "../../../libraries/ArrayLib.sol";
+import "../../../libraries/math/PMath.sol";
+
+contract PendleSiloWithIncentiveSY is SYBaseWithRewards {
+    using PMath for uint256;
+
+    address public immutable asset;
+    address public immutable collateralToken;
+    address public immutable silo;
+    address public immutable incentiveController;
+    address public immutable siloLens;
+    address public immutable rewardToken;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _asset,
+        address _collateralToken,
+        address _silo,
+        address _incentiveController,
+        address _siloLens
+    ) SYBaseWithRewards(_name, _symbol, _collateralToken) {
+        asset = _asset;
+        collateralToken = _collateralToken;
+        silo = _silo;
+        incentiveController = _incentiveController;
+        siloLens = _siloLens;
+
+        rewardToken = ISiloIncentiveController(incentiveController).REWARD_TOKEN();
+
+        _safeApproveInf(asset, silo);
+    }
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 amountSharesOut) {
+        if (tokenIn == collateralToken) {
+            return amountDeposited;
+        } else {
+            (, amountSharesOut) = ISilo(silo).deposit(asset, amountDeposited, false);
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 amountTokenOut) {
+        if (tokenOut == collateralToken) {
+            _transferOut(collateralToken, receiver, amountSharesToRedeem);
+            return amountSharesToRedeem;
+        } else {
+            // Silo withdrawing interface only accepts amount of asset as input
+            // Therefore we need to ensure that assetInput.toShareRoundUp() <= amountSharesToRedeem
+
+            (uint256 td, uint256 ts) = _getSiloInterestData();
+            amountTokenOut = (td * amountSharesToRedeem) / ts; // round down should ensure that shares being burned <= amountSharesToRedeem
+
+            // amountAssetToWithdraw should = withdrawnAmount as withdrawing does not
+            // bear any fees
+            ISilo(silo).withdraw(asset, amountTokenOut, false);
+            _transferOut(tokenOut, receiver, amountTokenOut);
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        (uint256 td, uint256 ts) = _getSiloInterestData();
+        return td.divDown(ts);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {IStandardizedYield-getRewardTokens}
+     */
+    function _getRewardTokens() internal view override returns (address[] memory) {
+        return ArrayLib.create(rewardToken);
+    }
+
+    function _redeemExternalReward() internal override {
+        ISiloIncentiveController(incentiveController).claimRewardsToSelf(
+            ArrayLib.create(collateralToken),
+            type(uint256).max
+        );
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                        SILO DATA FUNCITONS
+    //////////////////////////////////////////////////////////////*/
+
+    function _getSiloInterestData() internal view returns (uint256 totalDeposit, uint256 totalCollateralTokenSupply) {
+        totalDeposit = ISiloLens(siloLens).totalDepositsWithInterest(silo, asset);
+        totalCollateralTokenSupply = IERC20(collateralToken).totalSupply();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 amountSharesOut) {
+        if (tokenIn == collateralToken) {
+            return amountTokenToDeposit;
+        } else {
+            (uint256 td, uint256 ts) = _getSiloInterestData();
+            return (amountTokenToDeposit * ts) / td;
+        }
+    }
+
+    function _previewRedeem(
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256 amountTokenOut) {
+        if (tokenOut == collateralToken) {
+            return amountSharesToRedeem;
+        } else {
+            (uint256 td, uint256 ts) = _getSiloInterestData();
+            return (amountSharesToRedeem * td) / ts;
+        }
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(asset, collateralToken);
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(asset, collateralToken);
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == asset || token == collateralToken;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == asset || token == collateralToken;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, asset, IERC20Metadata(asset).decimals());
+    }
+}

package/contracts/core/StandardizedYield/implementations/Stader/PendleETHXSY.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 "../../../libraries/ArrayLib.sol";
 import "../../../../interfaces/Stader/IStaderStakeManager.sol";
@@ -13,10 +13,7 @@ contract PendleETHXSY is SYBase {
     address public immutable stakeManager;
     address public immutable ethx;
 
-    constructor(
-        address _stakeManager,
-        address _ethx
-    ) SYBase("SY Stader Staking ETHx", "SY-ETHx", _ethx) {
+    constructor(address _stakeManager, address _ethx) SYBase("SY Stader Staking ETHx", "SY-ETHx", _ethx) {
         stakeManager = _stakeManager;
         ethx = _ethx;
     }
@@ -30,8 +27,7 @@ contract PendleETHXSY is SYBase {
         uint256 amountDeposited
     ) internal virtual override returns (uint256 /*amountSharesOut*/) {
         if (tokenIn == NATIVE) {
-            return
-                IStaderStakeManager(stakeManager).deposit{ value: amountDeposited }(address(this));
+            return IStaderStakeManager(stakeManager).deposit{value: amountDeposited}(address(this));
         } else {
             return amountDeposited;
         }
@@ -100,11 +96,7 @@ contract PendleETHXSY is SYBase {
         return token == ethx;
     }
 
-    function assetInfo()
-        external
-        pure
-        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
-    {
+    function assetInfo() external pure returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
         return (AssetType.TOKEN, NATIVE, 18);
     }
 }

package/contracts/core/StandardizedYield/implementations/Swell/PendleSwETH.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/ISwETH.sol";
 
@@ -8,11 +8,7 @@ contract SwETHSY is SYBase {
 
     address public immutable swETH;
 
-    constructor(
-        string memory _name,
-        string memory _symbol,
-        address _swETH
-    ) SYBase(_name, _symbol, _swETH) {
+    constructor(string memory _name, string memory _symbol, address _swETH) SYBase(_name, _symbol, _swETH) {
         swETH = _swETH;
     }
 
@@ -26,7 +22,7 @@ contract SwETHSY is SYBase {
     ) internal virtual override returns (uint256 /*amountSharesOut*/) {
         if (tokenIn == NATIVE) {
             uint256 preBalance = _selfBalance(swETH);
-            ISwETH(swETH).deposit{ value: amountDeposited }();
+            ISwETH(swETH).deposit{value: amountDeposited}();
             return _selfBalance(swETH) - preBalance;
         } else {
             // sweth
@@ -92,11 +88,7 @@ contract SwETHSY is SYBase {
         return token == swETH;
     }
 
-    function assetInfo()
-        external
-        pure
-        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
-    {
+    function assetInfo() external pure returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
         return (AssetType.TOKEN, NATIVE, 18);
     }
 }

package/contracts/core/StandardizedYield/implementations/Thena/PendleThenaSY.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../../SYBaseWithRewards.sol";
 import "./ThenaLpHelper.sol";
@@ -39,12 +39,10 @@ contract PendleThenaSY is ThenaLpHelper, SYBaseWithRewards {
     /**
      * @dev See {SYBase-_deposit}
      */
-    function _deposit(address tokenIn, uint256 amountDeposited)
-        internal
-        virtual
-        override
-        returns (uint256 amountLpDeposited)
-    {
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 amountLpDeposited) {
         _withdrawAllFromGauge();
         if (tokenIn == pair) {
             amountLpDeposited = amountDeposited;
@@ -86,7 +84,7 @@ contract PendleThenaSY is ThenaLpHelper, SYBaseWithRewards {
     function _getRewardTokens() internal view virtual override returns (address[] memory res) {
         res = new address[](1 + externalRewardTokens.length);
         res[0] = THENA;
-        for(uint256 i = 1; i < res.length; ++i) {
+        for (uint256 i = 1; i < res.length; ++i) {
             res[i] = externalRewardTokens[i - 1];
         }
     }
@@ -99,12 +97,7 @@ contract PendleThenaSY is ThenaLpHelper, SYBaseWithRewards {
                     PREVIEW-RELATED
     //////////////////////////////////////////////////////////////*/
 
-    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
-        internal
-        view
-        override
-        returns (uint256)
-    {
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit) internal view override returns (uint256) {
         if (tokenIn == pair) {
             return amountTokenToDeposit;
         } else {
@@ -112,12 +105,7 @@ contract PendleThenaSY is ThenaLpHelper, SYBaseWithRewards {
         }
     }
 
-    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
-        internal
-        view
-        override
-        returns (uint256)
-    {
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem) internal view override returns (uint256) {
         if (tokenOut == pair) {
             return amountSharesToRedeem;
         } else {
@@ -151,15 +139,7 @@ contract PendleThenaSY is ThenaLpHelper, SYBaseWithRewards {
         return token == token0 || token == token1 || token == pair;
     }
 
-    function assetInfo()
-        external
-        view
-        returns (
-            AssetType assetType,
-            address assetAddress,
-            uint8 assetDecimals
-        )
-    {
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
         return (AssetType.LIQUIDITY, pair, IERC20Metadata(pair).decimals());
     }
 

package/contracts/core/StandardizedYield/implementations/Thena/ThenaLpHelper.sol

@@ -77,10 +77,7 @@ abstract contract ThenaLpHelper is TokenHelper, ThenaMath {
      * ==================================================================
      */
 
-    function _addLiquidity(
-        uint256 amount0ToAddLiq,
-        uint256 amount1ToAddLiq
-    ) private returns (uint256 amountLpOut) {
+    function _addLiquidity(uint256 amount0ToAddLiq, uint256 amount1ToAddLiq) private returns (uint256 amountLpOut) {
         (, , amountLpOut) = IThenaRouter(router).addLiquidity(
             token0,
             token1,
@@ -94,9 +91,7 @@ abstract contract ThenaLpHelper is TokenHelper, ThenaMath {
         );
     }
 
-    function _removeLiquidity(
-        uint256 amountLpToRemove
-    ) private returns (uint256 amountTokenA, uint256 amountTokenB) {
+    function _removeLiquidity(uint256 amountLpToRemove) private returns (uint256 amountTokenA, uint256 amountTokenB) {
         return
             IThenaRouter(router).removeLiquidity(
                 token0,
@@ -133,9 +128,7 @@ abstract contract ThenaLpHelper is TokenHelper, ThenaMath {
      * ==================================================================
      */
 
-    function _getNormalizedThenaData(
-        address tokenIn
-    ) internal view returns (ThenaData memory data) {
+    function _getNormalizedThenaData(address tokenIn) internal view returns (ThenaData memory data) {
         data.pair = pair;
         data.isStable = isStable;
         data.fee = IThenaFactory(factory).getFee(data.isStable);

package/contracts/core/StandardizedYield/implementations/Thena/ThenaMath.sol

@@ -41,25 +41,18 @@ abstract contract ThenaMath {
         address tokenIn,
         uint256 amountIn
     ) internal view returns (uint256) {
-        return
-            data.isStable
-                ? _getStableZapAmount(data, tokenIn, amountIn)
-                : _getVolatileZapAmount(data, amountIn);
+        return data.isStable ? _getStableZapAmount(data, tokenIn, amountIn) : _getVolatileZapAmount(data, amountIn);
     }
 
-    function _getVolatileZapAmount(
-        ThenaData memory data,
-        uint256 amountIn
-    ) private pure returns (uint256) {
-
-        uint256 numer0 = (TWO - FEE_DENOMINATOR) * data.reserve0 / FEE_DENOMINATOR;
+    function _getVolatileZapAmount(ThenaData memory data, uint256 amountIn) private pure returns (uint256) {
+        uint256 numer0 = ((TWO - FEE_DENOMINATOR) * data.reserve0) / FEE_DENOMINATOR;
         uint256 numer1 = PMath.square(numer0);
         uint256 numer2 = 4 * PMath.square(ONE - data.fee) * amountIn * data.reserve0;
 
         uint256 numer = PMath.sqrt(numer1 + numer2) - numer0;
         uint256 denom = 2 * PMath.square(ONE - data.fee);
 
-        return numer * FEE_DENOMINATOR / denom;
+        return (numer * FEE_DENOMINATOR) / denom;
     }
 
     function _getStableZapAmount(
@@ -71,23 +64,13 @@ abstract contract ThenaMath {
 
         while (!PMath.isAApproxB(params.guessMin, params.guessMax, binarySearchEps)) {
             params.amountSwapIn = (params.guessMax + params.guessMin) / 2;
-            params.amount1ToAddLiq = IThenaPair(data.pair).getAmountOut(
-                params.amountSwapIn,
-                tokenIn
-            );
-
-            params.newReserve0 = _getReserveAfterSwap(
-                params.amountSwapIn,
-                data.reserve0,
-                data.fee
-            );
+            params.amount1ToAddLiq = IThenaPair(data.pair).getAmountOut(params.amountSwapIn, tokenIn);
+
+            params.newReserve0 = _getReserveAfterSwap(params.amountSwapIn, data.reserve0, data.fee);
             params.newReserve1 = data.reserve1 - params.amount1ToAddLiq;
             params.amount0ToAddLiq = amountIn - params.amountSwapIn;
 
-            if (
-                params.amount0ToAddLiq * params.newReserve1 <
-                params.amount1ToAddLiq * params.newReserve0
-            ) {
+            if (params.amount0ToAddLiq * params.newReserve1 < params.amount1ToAddLiq * params.newReserve0) {
                 params.guessMax = params.amountSwapIn - 1; // need swap less
             } else {
                 params.guessMin = params.amountSwapIn + 1; // swap more
@@ -112,11 +95,7 @@ abstract contract ThenaMath {
         params.guessMax = (params.guessMin * FEE_DENOMINATOR) / (FEE_DENOMINATOR - data.fee);
     }
 
-    function _getReserveAfterSwap(
-        uint256 amountIn,
-        uint256 reserve,
-        uint256 fee
-    ) internal pure returns (uint256) {
+    function _getReserveAfterSwap(uint256 amountIn, uint256 reserve, uint256 fee) internal pure returns (uint256) {
         return reserve + amountIn - (amountIn * fee) / FEE_DENOMINATOR;
     }
 

package/contracts/core/StandardizedYield/implementations/Thena/ThenaPreview.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "./ThenaMath.sol";
 
@@ -14,12 +14,7 @@ interface IThenaSY {
     function pair() external view returns (address);
 }
 
-contract ThenaPreview is
-    IPendlePreviewHelper,
-    ThenaMath,
-    BoringOwnableUpgradeable,
-    UUPSUpgradeable
-{
+contract ThenaPreview is IPendlePreviewHelper, ThenaMath, BoringOwnableUpgradeable, UUPSUpgradeable {
     using PMath for uint256;
 
     address internal immutable factory;
@@ -35,10 +30,7 @@ contract ThenaPreview is
     // solhint-disable-next-line
     function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
 
-    function previewDeposit(
-        address tokenIn,
-        uint256 amountTokenIn
-    ) external view returns (uint256 amountLpOut) {
+    function previewDeposit(address tokenIn, uint256 amountTokenIn) external view returns (uint256 amountLpOut) {
         address pair = IThenaSY(msg.sender).pair();
 
         ThenaData memory data = _getNormalizedPairData(pair, tokenIn);
@@ -79,22 +71,15 @@ contract ThenaPreview is
     }
 
     // @reference: Camelot
-    function _getSwapAmountOut(
-        ThenaData memory data,
-        uint256 amountIn
-    ) internal pure returns (uint256) {
+    function _getSwapAmountOut(ThenaData memory data, uint256 amountIn) internal pure returns (uint256) {
         if (!data.isStable) {
             amountIn = amountIn * (FEE_DENOMINATOR - data.fee);
             return (amountIn * data.reserve1) / (data.reserve0 * FEE_DENOMINATOR + amountIn);
         } else {
-            amountIn = (amountIn - (amountIn * data.fee) / FEE_DENOMINATOR).divDown(
-                data.decimals0
-            );
+            amountIn = (amountIn - (amountIn * data.fee) / FEE_DENOMINATOR).divDown(data.decimals0);
             uint256 reserveA = data.reserve0.divDown(data.decimals0);
             uint256 reserveB = data.reserve1.divDown(data.decimals1);
-            uint256 xy = reserveA.mulDown(reserveB).mulDown(
-                reserveA.squareDown() + reserveB.squareDown()
-            );
+            uint256 xy = reserveA.mulDown(reserveB).mulDown(reserveA.squareDown() + reserveB.squareDown());
             uint256 y = reserveB - _get_y(amountIn + reserveA, xy, reserveB);
             return y.mulDown(data.decimals1);
         }
@@ -117,25 +102,14 @@ contract ThenaPreview is
         }
 
         uint256 supply = IThenaPair(data.pair).totalSupply();
-        return
-            PMath.min(
-                (amount0ToAddLiq * supply) / data.reserve0,
-                (amount1ToAddLiq * supply) / data.reserve1
-            );
+        return PMath.min((amount0ToAddLiq * supply) / data.reserve0, (amount1ToAddLiq * supply) / data.reserve1);
     }
 
-    function _quote(
-        uint256 amountA,
-        uint256 reserveA,
-        uint256 reserveB
-    ) private pure returns (uint256 amountB) {
+    function _quote(uint256 amountA, uint256 reserveA, uint256 reserveB) private pure returns (uint256 amountB) {
         amountB = (amountA * reserveB) / reserveA;
     }
 
-    function _getNormalizedPairData(
-        address pair,
-        address pivotToken
-    ) internal view returns (ThenaData memory data) {
+    function _getNormalizedPairData(address pair, address pivotToken) internal view returns (ThenaData memory data) {
         data.pair = pair;
         data.isStable = IThenaPair(pair).isStable();
         data.fee = IThenaFactory(factory).getFee(data.isStable);
@@ -180,11 +154,7 @@ contract ThenaPreview is
     }
 
     function _f(uint256 x0, uint256 y) internal pure returns (uint256) {
-        return
-            (x0 * ((((y * y) / 1e18) * y) / 1e18)) /
-            1e18 +
-            (((((x0 * x0) / 1e18) * x0) / 1e18) * y) /
-            1e18;
+        return (x0 * ((((y * y) / 1e18) * y) / 1e18)) / 1e18 + (((((x0 * x0) / 1e18) * x0) / 1e18) * y) / 1e18;
     }
 
     function _d(uint256 x0, uint256 y) internal pure returns (uint256) {

package/contracts/core/YieldContracts/InterestManagerYT.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../../interfaces/IPYieldToken.sol";
 import "../../interfaces/IPPrincipalToken.sol";
@@ -36,10 +36,8 @@ abstract contract InterestManagerYT is TokenHelper, IPInterestManagerYT {
 
     function _distributeInterestForTwo(address user1, address user2) internal {
         uint256 index = _getInterestIndex();
-        if (user1 != address(0) && user1 != address(this))
-            _distributeInterestPrivate(user1, index);
-        if (user2 != address(0) && user2 != address(this))
-            _distributeInterestPrivate(user2, index);
+        if (user1 != address(0) && user1 != address(this)) _distributeInterestPrivate(user1, index);
+        if (user2 != address(0) && user2 != address(this)) _distributeInterestPrivate(user2, index);
     }
 
     function _doTransferOutInterest(
@@ -58,6 +56,8 @@ abstract contract InterestManagerYT is TokenHelper, IPInterestManagerYT {
 
         _transferOut(SY, treasury, feeAmount);
         _transferOut(SY, user, interestAmount);
+
+        emit CollectInterestFee(feeAmount);
     }
 
     // should only be callable from `_distributeInterestForTwo` & make sure user != address(0) && user != address(this)
@@ -74,9 +74,7 @@ abstract contract InterestManagerYT is TokenHelper, IPInterestManagerYT {
 
         uint256 principal = _YTbalance(user);
 
-        uint256 interestFromYT = (principal * (currentIndex - prevIndex)).divDown(
-            prevIndex * currentIndex
-        );
+        uint256 interestFromYT = (principal * (currentIndex - prevIndex)).divDown(prevIndex * currentIndex);
 
         userInterest[user].accrued += interestFromYT.Uint128();
         userInterest[user].index = currentIndex.Uint128();

package/contracts/core/YieldContracts/PendlePrincipalToken.sol

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

package/contracts/core/YieldContracts/PendleYieldContractFactory.sol

@@ -21,7 +21,7 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  */
 
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../../interfaces/IPYieldContractFactory.sol";
 
@@ -106,8 +106,7 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContract
         uint32 expiry,
         bool doCacheIndexSameBlock
     ) external returns (address PT, address YT) {
-        if (MiniHelpers.isTimeInThePast(expiry) || expiry % expiryDivisor != 0)
-            revert Errors.YCFactoryInvalidExpiry();
+        if (MiniHelpers.isTimeInThePast(expiry) || expiry % expiryDivisor != 0) revert Errors.YCFactoryInvalidExpiry();
 
         if (getPT[SY][expiry] != address(0)) revert Errors.YCFactoryYieldContractExisted();