@pendle/core-v2 1.3.0-mainnet → 1.3.0-testnet

package/contracts/core/RewardManager/RewardManager.sol

@@ -3,7 +3,7 @@ pragma solidity 0.8.17;
 
 import "./RewardManagerAbstract.sol";
 
-/// NOTE: This RewardManager is used with PendleMarket & SY. For YT, it will use RewardManagerAbstract
+/// NOTE: This RewardManager is used with SY & YTv2 & PendleMarket. For YTv1, it will use RewardManagerAbstract
 /// NOTE: RewardManager must not have duplicated rewardTokens
 abstract contract RewardManager is RewardManagerAbstract {
     using Math for uint256;
@@ -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

@@ -7,20 +7,19 @@ import "../../interfaces/IStETH.sol";
 import "../libraries/TokenHelper.sol";
 
 abstract contract StEthHelper is TokenHelper {
-    address public constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
-    address public constant WSTETH = 0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0;
-    address public constant STETH = 0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84;
+    address internal constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
+    address internal constant WSTETH = 0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0;
+    address internal constant STETH = 0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84;
 
     constructor() {
         _safeApproveInf(STETH, WSTETH);
     }
 
     /// @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);
-        _transferOut(STETH, receiver, amountTokenOut);
+        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,127 @@
+// 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) {
+        if (tokenOut == NATIVE) {
+            uint256 amountTokenOut = super._redeem(address(this), WETH, amountSharesToRedeem);
+            IWETH(WETH).withdraw(amountTokenOut);
+            _transferOut(NATIVE, receiver, amountTokenOut);
+            return amountTokenOut;
+        } else {
+            return 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 {

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

@@ -16,12 +16,10 @@ contract PendleAuraWethWstethSY is PendleAuraBalancerStableLPSY, StEthHelper {
         MetaStablePreview _previewHelper
     ) PendleAuraBalancerStableLPSY(_name, _symbol, LP, AURA_PID, _previewHelper) StEthHelper() {}
 
-    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);
@@ -50,13 +48,10 @@ contract PendleAuraWethWstethSY is PendleAuraBalancerStableLPSY, StEthHelper {
         }
     }
 
-    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 if (tokenIn == STETH) {
@@ -67,13 +62,10 @@ contract PendleAuraWethWstethSY is PendleAuraBalancerStableLPSY, StEthHelper {
         }
     }
 
-    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 if (tokenOut == STETH) {

package/contracts/core/StandardizedYield/implementations/BalancerStable/base/MetaStable/MetaStableMath.sol

@@ -293,11 +293,7 @@ library MetaStableMath {
         }
     }
 
-    function div(
-        uint256 a,
-        uint256 b,
-        bool roundUp
-    ) internal pure returns (uint256) {
+    function div(uint256 a, uint256 b, bool roundUp) internal pure returns (uint256) {
         return roundUp ? divUp(a, b) : divDown(a, b);
     }