@pendle/core-v2 2.1.1-mainnet → 2.2.0-mainnet

package/contracts/core/Market/PendleGauge.sol

@@ -28,11 +28,7 @@ abstract contract PendleGauge is RewardManager, IPGauge {
     uint256 public totalActiveSupply;
     mapping(address => uint256) public activeBalance;
 
-    constructor(
-        address _SY,
-        address _vePendle,
-        address _gaugeController
-    ) {
+    constructor(address _SY, address _vePendle, address _gaugeController) {
         SY = _SY;
         vePENDLE = IPVeToken(_vePendle);
         gaugeController = _gaugeController;
@@ -74,11 +70,10 @@ abstract contract PendleGauge is RewardManager, IPGauge {
         activeBalance[user] = newActiveBalance;
     }
 
-    function _calcVeBoostedLpBalance(address user, uint256 lpBalance)
-        internal
-        virtual
-        returns (uint256)
-    {
+    function _calcVeBoostedLpBalance(
+        address user,
+        uint256 lpBalance
+    ) internal virtual returns (uint256) {
         (uint256 vePendleSupply, uint256 vePendleBalance) = vePENDLE.totalSupplyAndBalanceCurrent(
             user
         );
@@ -116,19 +111,11 @@ abstract contract PendleGauge is RewardManager, IPGauge {
         return SYRewards.append(PENDLE);
     }
 
-    function _beforeTokenTransfer(
-        address from,
-        address to,
-        uint256
-    ) internal virtual {
+    function _beforeTokenTransfer(address from, address to, uint256) internal virtual {
         _updateAndDistributeRewardsForTwo(from, to);
     }
 
-    function _afterTokenTransfer(
-        address from,
-        address to,
-        uint256
-    ) internal virtual {
+    function _afterTokenTransfer(address from, address to, uint256) internal virtual {
         _updateUserActiveBalanceForTwo(from, to);
     }
 }

package/contracts/core/Market/PendleMarket.sol

@@ -96,11 +96,7 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
         external
         nonReentrant
         notExpired
-        returns (
-            uint256 netLpOut,
-            uint256 netSyUsed,
-            uint256 netPtUsed
-        )
+        returns (uint256 netLpOut, uint256 netSyUsed, uint256 netPtUsed)
     {
         MarketState memory market = readState(msg.sender);
         PYIndex index = YT.newIndex();
@@ -260,11 +256,9 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
                                 ORACLE
     //////////////////////////////////////////////////////////////*/
 
-    function observe(uint32[] memory secondsAgos)
-        external
-        view
-        returns (uint216[] memory lnImpliedRateCumulative)
-    {
+    function observe(
+        uint32[] memory secondsAgos
+    ) external view returns (uint216[] memory lnImpliedRateCumulative) {
         return
             observations.observe(
                 uint32(block.timestamp),
@@ -336,11 +330,7 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
     function readTokens()
         external
         view
-        returns (
-            IStandardizedYield _SY,
-            IPPrincipalToken _PT,
-            IPYieldToken _YT
-        )
+        returns (IStandardizedYield _SY, IPPrincipalToken _PT, IPYieldToken _YT)
     {
         _SY = SY;
         _PT = PT;

package/contracts/core/Market/PendleMarketFactory.sol

@@ -103,15 +103,9 @@ contract PendleMarketFactory is BoringOwnableUpgradeable, IPMarketFactory {
         emit CreateNewMarket(market, PT, scalarRoot, initialAnchor);
     }
 
-    function getMarketConfig(address router)
-        external
-        view
-        returns (
-            address _treasury,
-            uint80 _lnFeeRateRoot,
-            uint8 _reserveFeePercent
-        )
-    {
+    function getMarketConfig(
+        address router
+    ) external view returns (address _treasury, uint80 _lnFeeRateRoot, uint8 _reserveFeePercent) {
         (_treasury, _lnFeeRateRoot, _reserveFeePercent) = (
             treasury,
             defaultFee.lnFeeRateRoot,

package/contracts/core/RewardManager/RewardManager.sol

@@ -54,12 +54,10 @@ abstract contract RewardManager is RewardManagerAbstract {
 
     /// @dev this function doesn't need redeemExternal since redeemExternal is bundled in updateRewardIndex
     /// @dev this function also has to update rewardState.lastBalance
-    function _doTransferOutRewards(address user, address receiver)
-        internal
-        virtual
-        override
-        returns (uint256[] memory rewardAmounts)
-    {
+    function _doTransferOutRewards(
+        address user,
+        address receiver
+    ) internal virtual override returns (uint256[] memory rewardAmounts) {
         address[] memory tokens = _getRewardTokens();
         rewardAmounts = new uint256[](tokens.length);
         for (uint256 i = 0; i < tokens.length; i++) {

package/contracts/core/RewardManager/RewardManagerAbstract.sol

@@ -80,10 +80,10 @@ abstract contract RewardManagerAbstract is IRewardManager, TokenHelper {
 
     function _redeemExternalReward() internal virtual;
 
-    function _doTransferOutRewards(address user, address receiver)
-        internal
-        virtual
-        returns (uint256[] memory rewardAmounts);
+    function _doTransferOutRewards(
+        address user,
+        address receiver
+    ) internal virtual returns (uint256[] memory rewardAmounts);
 
     function _rewardSharesUser(address user) internal view virtual returns (uint256);
 }

package/contracts/core/StandardizedYield/PYIndex.sol

@@ -16,64 +16,35 @@ library PYIndexLib {
         return PYIndex.wrap(YT.pyIndexCurrent());
     }
 
-    function syToAsset(PYIndex index, uint256 syAmount)
-        internal
-        pure
-        returns (uint256)
-    {
+    function syToAsset(PYIndex index, uint256 syAmount) internal pure returns (uint256) {
         return SYUtils.syToAsset(PYIndex.unwrap(index), syAmount);
     }
 
-    function assetToSy(PYIndex index, uint256 assetAmount)
-        internal
-        pure
-        returns (uint256)
-    {
+    function assetToSy(PYIndex index, uint256 assetAmount) internal pure returns (uint256) {
         return SYUtils.assetToSy(PYIndex.unwrap(index), assetAmount);
     }
 
-    function assetToSyUp(PYIndex index, uint256 assetAmount)
-        internal
-        pure
-        returns (uint256)
-    {
+    function assetToSyUp(PYIndex index, uint256 assetAmount) internal pure returns (uint256) {
         return SYUtils.assetToSyUp(PYIndex.unwrap(index), assetAmount);
     }
 
-    function syToAssetUp(PYIndex index, uint256 syAmount)
-        internal
-        pure
-        returns (uint256)
-    {
+    function syToAssetUp(PYIndex index, uint256 syAmount) internal pure returns (uint256) {
         uint256 _index = PYIndex.unwrap(index);
         return SYUtils.syToAssetUp(_index, syAmount);
     }
 
-    function syToAsset(PYIndex index, int256 syAmount)
-        internal
-        pure
-        returns (int256)
-    {
+    function syToAsset(PYIndex index, int256 syAmount) internal pure returns (int256) {
         int256 sign = syAmount < 0 ? int256(-1) : int256(1);
         return sign * (SYUtils.syToAsset(PYIndex.unwrap(index), syAmount.abs())).Int();
     }
 
-    function assetToSy(PYIndex index, int256 assetAmount)
-        internal
-        pure
-        returns (int256)
-    {
+    function assetToSy(PYIndex index, int256 assetAmount) internal pure returns (int256) {
         int256 sign = assetAmount < 0 ? int256(-1) : int256(1);
         return sign * (SYUtils.assetToSy(PYIndex.unwrap(index), assetAmount.abs())).Int();
     }
 
-    function assetToSyUp(PYIndex index, int256 assetAmount)
-        internal
-        pure
-        returns (int256)
-    {
+    function assetToSyUp(PYIndex index, int256 assetAmount) internal pure returns (int256) {
         int256 sign = assetAmount < 0 ? int256(-1) : int256(1);
         return sign * (SYUtils.assetToSyUp(PYIndex.unwrap(index), assetAmount.abs())).Int();
     }
-
 }

package/contracts/core/StandardizedYield/SYBase.sol

@@ -90,10 +90,10 @@ abstract contract SYBase is
      * @param amountDeposited amount of base tokens deposited
      * @return amountSharesOut amount of shares minted
      */
-    function _deposit(address tokenIn, uint256 amountDeposited)
-        internal
-        virtual
-        returns (uint256 amountSharesOut);
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual returns (uint256 amountSharesOut);
 
     /**
      * @notice redeems base tokens based on amount of shares to be burned
@@ -169,22 +169,18 @@ abstract contract SYBase is
                 MISC METADATA FUNCTIONS
     //////////////////////////////////////////////////////////////*/
 
-    function previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
-        external
-        view
-        virtual
-        returns (uint256 amountSharesOut)
-    {
+    function previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) external view virtual returns (uint256 amountSharesOut) {
         if (!isValidTokenIn(tokenIn)) revert Errors.SYInvalidTokenIn(tokenIn);
         return _previewDeposit(tokenIn, amountTokenToDeposit);
     }
 
-    function previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
-        external
-        view
-        virtual
-        returns (uint256 amountTokenOut)
-    {
+    function previewRedeem(
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) external view virtual returns (uint256 amountTokenOut) {
         if (!isValidTokenOut(tokenOut)) revert Errors.SYInvalidTokenOut(tokenOut);
         return _previewRedeem(tokenOut, amountSharesToRedeem);
     }
@@ -203,17 +199,15 @@ abstract contract SYBase is
         uint256
     ) internal virtual override whenNotPaused {}
 
-    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
-        internal
-        view
-        virtual
-        returns (uint256 amountSharesOut);
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view virtual returns (uint256 amountSharesOut);
 
-    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
-        internal
-        view
-        virtual
-        returns (uint256 amountTokenOut);
+    function _previewRedeem(
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal view virtual returns (uint256 amountTokenOut);
 
     function getTokensIn() public view virtual returns (address[] memory res);
 

package/contracts/core/StandardizedYield/SYBaseWithRewards.sol

@@ -24,13 +24,9 @@ abstract contract SYBaseWithRewards is SYBase, RewardManager {
     /**
      * @dev See {IStandardizedYield-claimRewards}
      */
-    function claimRewards(address user)
-        external
-        virtual
-        override
-        nonReentrant
-        returns (uint256[] memory rewardAmounts)
-    {
+    function claimRewards(
+        address user
+    ) external virtual override nonReentrant returns (uint256[] memory rewardAmounts) {
         _updateAndDistributeRewards(user);
         rewardAmounts = _doTransferOutRewards(user, user);
 
@@ -53,13 +49,9 @@ abstract contract SYBaseWithRewards is SYBase, RewardManager {
     /**
      * @dev See {IStandardizedYield-accruedRewards}
      */
-    function accruedRewards(address user)
-        external
-        view
-        virtual
-        override
-        returns (uint256[] memory rewardAmounts)
-    {
+    function accruedRewards(
+        address user
+    ) external view virtual override returns (uint256[] memory rewardAmounts) {
         address[] memory rewardTokens = _getRewardTokens();
         rewardAmounts = new uint256[](rewardTokens.length);
         for (uint256 i = 0; i < rewardTokens.length; ) {
@@ -116,11 +108,7 @@ abstract contract SYBaseWithRewards is SYBase, RewardManager {
     /*///////////////////////////////////////////////////////////////
                             TRANSFER HOOKS
     //////////////////////////////////////////////////////////////*/
-    function _beforeTokenTransfer(
-        address from,
-        address to,
-        uint256
-    ) internal virtual override {
+    function _beforeTokenTransfer(address from, address to, uint256) internal virtual override {
         _updateAndDistributeRewardsForTwo(from, to);
     }
 }

package/contracts/core/StandardizedYield/SYUtils.sol

@@ -16,11 +16,10 @@ library SYUtils {
         return (assetAmount * ONE) / exchangeRate;
     }
 
-    function assetToSyUp(uint256 exchangeRate, uint256 assetAmount)
-        internal
-        pure
-        returns (uint256)
-    {
+    function assetToSyUp(
+        uint256 exchangeRate,
+        uint256 assetAmount
+    ) internal pure returns (uint256) {
         return (assetAmount * ONE + exchangeRate - 1) / exchangeRate;
     }
 }

package/contracts/core/StandardizedYield/StEthHelper.sol

@@ -16,11 +16,10 @@ abstract contract StEthHelper is TokenHelper {
     }
 
     /// @dev tokenIn must be either ETH, WETH or STETH
-    function _depositWstETH(address tokenIn, uint256 amountDep)
-        internal
-        virtual
-        returns (uint256 amountOut)
-    {
+    function _depositWstETH(
+        address tokenIn,
+        uint256 amountDep
+    ) internal virtual returns (uint256 amountOut) {
         uint256 amountStETH;
         if (tokenIn == STETH) {
             amountStETH = amountDep;
@@ -33,22 +32,19 @@ abstract contract StEthHelper is TokenHelper {
         amountOut = IWstETH(WSTETH).wrap(amountStETH);
     }
 
-    function _redeemWstETH(address receiver, uint256 amountRedeem)
-        internal
-        virtual
-        returns (uint256 amountTokenOut)
-    {
+    function _redeemWstETH(
+        address receiver,
+        uint256 amountRedeem
+    ) internal virtual returns (uint256 amountTokenOut) {
         amountTokenOut = IWstETH(WSTETH).unwrap(amountRedeem);
         if (receiver != address(this)) _transferOut(STETH, receiver, amountTokenOut);
     }
 
     /// @dev tokenIn must be either ETH, WETH or STETH
-    function _previewDepositWstETH(address tokenIn, uint256 amountDep)
-        internal
-        view
-        virtual
-        returns (uint256 amountOut)
-    {
+    function _previewDepositWstETH(
+        address tokenIn,
+        uint256 amountDep
+    ) internal view virtual returns (uint256 amountOut) {
         if (tokenIn != STETH) {
             assert(tokenIn == WETH || tokenIn == NATIVE);
             uint256 totalShares = IStETH(STETH).getTotalShares();

package/contracts/core/StandardizedYield/implementations/Ape/sAPE.sol

@@ -8,7 +8,7 @@ contract sAPE is SYBase {
     using Math for uint256;
 
     uint256 public constant APE_COIN_POOL_ID = 0;
-    uint256 public constant MIN_APE_DEPOSIT = 10**18;
+    uint256 public constant MIN_APE_DEPOSIT = 10 ** 18;
     uint256 public constant EPOCH_LENGTH = 1 hours;
     uint256 private constant MINIMUM_LIQUIDITY = 1e9;
 
@@ -42,12 +42,10 @@ contract sAPE is SYBase {
         emit Redeem(msg.sender, msg.sender, apeCoin, amountShares, amountTokenOut);
     }
 
-    function _deposit(address, uint256 amountDeposited)
-        internal
-        virtual
-        override
-        returns (uint256 amountSharesOut)
-    {
+    function _deposit(
+        address,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 amountSharesOut) {
         // Respecting APE's deposit invariant
         if (amountDeposited < MIN_APE_DEPOSIT) {
             revert Errors.SYApeDepositAmountTooSmall(amountDeposited);
@@ -141,22 +139,18 @@ contract sAPE is SYBase {
                 MISC FUNCTIONS FOR METADATA
     //////////////////////////////////////////////////////////////*/
 
-    function _previewDeposit(address, uint256 amountTokenToDeposit)
-        internal
-        view
-        override
-        returns (uint256 amountSharesOut)
-    {
+    function _previewDeposit(
+        address,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 amountSharesOut) {
         // This function is intentionally left reverted when totalSupply() = 0
         amountSharesOut = (amountTokenToDeposit * totalSupply()) / getTotalAssetOwned();
     }
 
-    function _previewRedeem(address, uint256 amountSharesToRedeem)
-        internal
-        view
-        override
-        returns (uint256 amountTokenOut)
-    {
+    function _previewRedeem(
+        address,
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256 amountTokenOut) {
         // This function is intentionally left reverted when totalSupply() = 0
         amountTokenOut = (amountSharesToRedeem * getTotalAssetOwned()) / totalSupply();
     }
@@ -186,11 +180,7 @@ contract sAPE is SYBase {
     function assetInfo()
         external
         view
-        returns (
-            AssetType assetType,
-            address assetAddress,
-            uint8 assetDecimals
-        )
+        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
     {
         return (AssetType.TOKEN, apeCoin, IERC20Metadata(apeCoin).decimals());
     }

package/contracts/core/StandardizedYield/implementations/BalancerStable/PendleAuraWethAnkrethSY.sol

@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./base/PendleAuraBalancerStableLPSY.sol";
+import "../../../../interfaces/IWETH.sol";
+import "./base/MetaStable/MetaStablePreview.sol";
+
+contract PendleAuraWethAnkrethSY is PendleAuraBalancerStableLPSY {
+    address internal constant ANKRETH = 0xE95A203B1a91a908F9B9CE46459d101078c2c3cb;
+    address internal constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
+
+    uint256 internal constant AURA_PID = 48;
+    address internal constant LP = 0x8A34b5ad76F528bfEc06c80D85EF3b53dA7FC300;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        MetaStablePreview _previewHelper
+    ) PendleAuraBalancerStableLPSY(_name, _symbol, LP, AURA_PID, _previewHelper) {}
+
+    function _deposit(
+        address tokenIn,
+        uint256 amount
+    ) internal virtual override returns (uint256 amountSharesOut) {
+        if (tokenIn == NATIVE) {
+            IWETH(WETH).deposit{ value: amount }();
+            amountSharesOut = super._deposit(WETH, amount);
+        } else {
+            amountSharesOut = super._deposit(tokenIn, amount);
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 amountTokenOut) {
+        if (tokenOut == NATIVE) {
+            amountTokenOut = super._redeem(address(this), WETH, amountSharesToRedeem);
+            IWETH(WETH).withdraw(amountTokenOut);
+            _transferOut(NATIVE, receiver, amountTokenOut);
+        } else {
+            amountTokenOut = super._redeem(receiver, tokenOut, amountSharesToRedeem);
+        }
+    }
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view virtual override returns (uint256 amountSharesOut) {
+        if (tokenIn == NATIVE) {
+            amountSharesOut = super._previewDeposit(WETH, amountTokenToDeposit);
+        } else {
+            amountSharesOut = super._previewDeposit(tokenIn, amountTokenToDeposit);
+        }
+    }
+
+    function _previewRedeem(
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal view virtual override returns (uint256 amountTokenOut) {
+        if (tokenOut == NATIVE) {
+            amountTokenOut = super._previewRedeem(WETH, amountSharesToRedeem);
+        } else {
+            amountTokenOut = super._previewRedeem(tokenOut, amountSharesToRedeem);
+        }
+    }
+
+    function _getPoolTokenAddresses()
+        internal
+        view
+        virtual
+        override
+        returns (address[] memory res)
+    {
+        res = new address[](2);
+        res[0] = WETH;
+        res[1] = ANKRETH;
+    }
+
+    function _getRateProviders() internal view virtual returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = 0x0000000000000000000000000000000000000000;
+        res[1] = 0x00F8e64a8651E3479A0B20F46b1D462Fe29D6aBc;
+    }
+
+    function _getRawScalingFactors() internal view virtual returns (uint256[] memory res) {
+        res = new uint256[](2);
+        res[0] = 1e18;
+        res[1] = 1e18;
+    }
+
+    function _getImmutablePoolData() internal view virtual override returns (bytes memory) {
+        MetaStablePreview.ImmutableData memory res;
+        res.LP = LP;
+        res.poolTokens = _getPoolTokenAddresses();
+        res.rateProviders = _getRateProviders();
+        res.rawScalingFactors = _getRawScalingFactors();
+
+        return abi.encode(res);
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](4);
+        res[0] = LP;
+        res[1] = WETH;
+        res[2] = ANKRETH;
+        res[3] = NATIVE;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](4);
+        res[0] = LP;
+        res[1] = WETH;
+        res[2] = ANKRETH;
+        res[3] = NATIVE;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return (token == LP || token == WETH || token == ANKRETH || token == NATIVE);
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return (token == LP || token == WETH || token == ANKRETH || token == NATIVE);
+    }
+}

package/contracts/core/StandardizedYield/implementations/BalancerStable/PendleAuraWethRethSY.sol

@@ -18,12 +18,10 @@ contract PendleAuraWethRethSY is PendleAuraBalancerStableLPSY {
         MetaStablePreview _previewHelper
     ) PendleAuraBalancerStableLPSY(_name, _symbol, LP, AURA_PID, _previewHelper) {}
 
-    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 == NATIVE) {
             IWETH(WETH).deposit{ value: amount }();
             amountSharesOut = super._deposit(WETH, amount);
@@ -46,13 +44,10 @@ contract PendleAuraWethRethSY is PendleAuraBalancerStableLPSY {
         }
     }
 
-    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 == NATIVE) {
             amountSharesOut = super._previewDeposit(WETH, amountTokenToDeposit);
         } else {
@@ -60,13 +55,10 @@ contract PendleAuraWethRethSY is PendleAuraBalancerStableLPSY {
         }
     }
 
-    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 == NATIVE) {
             amountTokenOut = super._previewRedeem(WETH, amountSharesToRedeem);
         } else {