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

package/contracts/core/StandardizedYield/SYBase.sol

@@ -6,17 +6,12 @@ import "../erc20/PendleERC20Permit.sol";
 
 import "../libraries/math/PMath.sol";
 import "../libraries/TokenHelper.sol";
+import "../libraries/ArrayLib.sol";
 import "../libraries/Errors.sol";
 import "../libraries/BoringOwnableUpgradeable.sol";
 import "@openzeppelin/contracts/security/Pausable.sol";
 
-abstract contract SYBase is
-    IStandardizedYield,
-    PendleERC20Permit,
-    TokenHelper,
-    BoringOwnableUpgradeable,
-    Pausable
-{
+abstract contract SYBase is IStandardizedYield, PendleERC20Permit, TokenHelper, BoringOwnableUpgradeable, Pausable {
     using PMath for uint256;
 
     address public immutable yieldToken;
@@ -52,8 +47,7 @@ abstract contract SYBase is
         _transferIn(tokenIn, msg.sender, amountTokenToDeposit);
 
         amountSharesOut = _deposit(tokenIn, amountTokenToDeposit);
-        if (amountSharesOut < minSharesOut)
-            revert Errors.SYInsufficientSharesOut(amountSharesOut, minSharesOut);
+        if (amountSharesOut < minSharesOut) revert Errors.SYInsufficientSharesOut(amountSharesOut, minSharesOut);
 
         _mint(receiver, amountSharesOut);
         emit Deposit(msg.sender, receiver, tokenIn, amountTokenToDeposit, amountSharesOut);
@@ -79,8 +73,7 @@ abstract contract SYBase is
         }
 
         amountTokenOut = _redeem(receiver, tokenOut, amountSharesToRedeem);
-        if (amountTokenOut < minTokenOut)
-            revert Errors.SYInsufficientTokenOut(amountTokenOut, minTokenOut);
+        if (amountTokenOut < minTokenOut) revert Errors.SYInsufficientTokenOut(amountTokenOut, minTokenOut);
         emit Redeem(msg.sender, receiver, tokenOut, amountSharesToRedeem, amountTokenOut);
     }
 
@@ -90,10 +83,7 @@ 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
@@ -123,31 +113,21 @@ abstract contract SYBase is
     /**
      * @dev See {IStandardizedYield-claimRewards}
      */
-    function claimRewards(
-        address /*user*/
-    ) external virtual override returns (uint256[] memory rewardAmounts) {
+    function claimRewards(address /*user*/) external virtual override returns (uint256[] memory rewardAmounts) {
         rewardAmounts = new uint256[](0);
     }
 
     /**
      * @dev See {IStandardizedYield-getRewardTokens}
      */
-    function getRewardTokens()
-        external
-        view
-        virtual
-        override
-        returns (address[] memory rewardTokens)
-    {
+    function getRewardTokens() external view virtual override returns (address[] memory rewardTokens) {
         rewardTokens = new address[](0);
     }
 
     /**
      * @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) {
         rewardAmounts = new uint256[](0);
     }
 
@@ -155,13 +135,7 @@ abstract contract SYBase is
         indexes = new uint256[](0);
     }
 
-    function rewardIndexesStored()
-        external
-        view
-        virtual
-        override
-        returns (uint256[] memory indexes)
-    {
+    function rewardIndexesStored() external view virtual override returns (uint256[] memory indexes) {
         indexes = new uint256[](0);
     }
 
@@ -193,11 +167,7 @@ abstract contract SYBase is
         _unpause();
     }
 
-    function _beforeTokenTransfer(
-        address,
-        address,
-        uint256
-    ) internal virtual override whenNotPaused {}
+    function _beforeTokenTransfer(address, address, uint256) internal virtual override whenNotPaused {}
 
     function _previewDeposit(
         address tokenIn,

package/contracts/core/StandardizedYield/SYBaseUpg.sol

@@ -0,0 +1,197 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../interfaces/IStandardizedYield.sol";
+
+import "../erc20/PendleERC20PermitUpg.sol";
+
+import "../libraries/math/PMath.sol";
+import "../libraries/TokenHelper.sol";
+import "../libraries/Errors.sol";
+import "../libraries/BoringOwnableUpgradeable.sol";
+import "@openzeppelin/contracts/security/Pausable.sol";
+
+abstract contract SYBaseUpg is
+    IStandardizedYield,
+    PendleERC20PermitUpg,
+    TokenHelper,
+    BoringOwnableUpgradeable,
+    Pausable
+{
+    using PMath for uint256;
+
+    address public immutable yieldToken;
+
+    uint256[100] private __gap;
+
+    constructor(address _yieldToken) PendleERC20Upg(IERC20Metadata(_yieldToken).decimals()) {
+        yieldToken = _yieldToken;
+    }
+
+    function __SYBaseUpg_init(string memory name_, string memory symbol_) internal onlyInitializing {
+        __ERC20PermitUpg_init(name_, symbol_);
+        __BoringOwnable_init();
+    }
+
+    // solhint-disable no-empty-blocks
+    receive() external payable {}
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {IStandardizedYield-deposit}
+     */
+    function deposit(
+        address receiver,
+        address tokenIn,
+        uint256 amountTokenToDeposit,
+        uint256 minSharesOut
+    ) external payable nonReentrant returns (uint256 amountSharesOut) {
+        if (!isValidTokenIn(tokenIn)) revert Errors.SYInvalidTokenIn(tokenIn);
+        if (amountTokenToDeposit == 0) revert Errors.SYZeroDeposit();
+
+        _transferIn(tokenIn, msg.sender, amountTokenToDeposit);
+
+        amountSharesOut = _deposit(tokenIn, amountTokenToDeposit);
+        if (amountSharesOut < minSharesOut) revert Errors.SYInsufficientSharesOut(amountSharesOut, minSharesOut);
+
+        _mint(receiver, amountSharesOut);
+        emit Deposit(msg.sender, receiver, tokenIn, amountTokenToDeposit, amountSharesOut);
+    }
+
+    /**
+     * @dev See {IStandardizedYield-redeem}
+     */
+    function redeem(
+        address receiver,
+        uint256 amountSharesToRedeem,
+        address tokenOut,
+        uint256 minTokenOut,
+        bool burnFromInternalBalance
+    ) external nonReentrant returns (uint256 amountTokenOut) {
+        if (!isValidTokenOut(tokenOut)) revert Errors.SYInvalidTokenOut(tokenOut);
+        if (amountSharesToRedeem == 0) revert Errors.SYZeroRedeem();
+
+        if (burnFromInternalBalance) {
+            _burn(address(this), amountSharesToRedeem);
+        } else {
+            _burn(msg.sender, amountSharesToRedeem);
+        }
+
+        amountTokenOut = _redeem(receiver, tokenOut, amountSharesToRedeem);
+        if (amountTokenOut < minTokenOut) revert Errors.SYInsufficientTokenOut(amountTokenOut, minTokenOut);
+        emit Redeem(msg.sender, receiver, tokenOut, amountSharesToRedeem, amountTokenOut);
+    }
+
+    /**
+     * @notice mint shares based on the deposited base tokens
+     * @param tokenIn base token address used to mint shares
+     * @param amountDeposited amount of base tokens deposited
+     * @return amountSharesOut amount of shares minted
+     */
+    function _deposit(address tokenIn, uint256 amountDeposited) internal virtual returns (uint256 amountSharesOut);
+
+    /**
+     * @notice redeems base tokens based on amount of shares to be burned
+     * @param tokenOut address of the base token to be redeemed
+     * @param amountSharesToRedeem amount of shares to be burned
+     * @return amountTokenOut amount of base tokens redeemed
+     */
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual returns (uint256 amountTokenOut);
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {IStandardizedYield-exchangeRate}
+     */
+    function exchangeRate() external view virtual override returns (uint256 res);
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {IStandardizedYield-claimRewards}
+     */
+    function claimRewards(address /*user*/) external virtual override returns (uint256[] memory rewardAmounts) {
+        rewardAmounts = new uint256[](0);
+    }
+
+    /**
+     * @dev See {IStandardizedYield-getRewardTokens}
+     */
+    function getRewardTokens() external view virtual override returns (address[] memory rewardTokens) {
+        rewardTokens = new address[](0);
+    }
+
+    /**
+     * @dev See {IStandardizedYield-accruedRewards}
+     */
+    function accruedRewards(address /*user*/) external view virtual override returns (uint256[] memory rewardAmounts) {
+        rewardAmounts = new uint256[](0);
+    }
+
+    function rewardIndexesCurrent() external virtual override returns (uint256[] memory indexes) {
+        indexes = new uint256[](0);
+    }
+
+    function rewardIndexesStored() external view virtual override returns (uint256[] memory indexes) {
+        indexes = new uint256[](0);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC METADATA FUNCTIONS
+    //////////////////////////////////////////////////////////////*/
+
+    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) {
+        if (!isValidTokenOut(tokenOut)) revert Errors.SYInvalidTokenOut(tokenOut);
+        return _previewRedeem(tokenOut, amountSharesToRedeem);
+    }
+
+    function pause() external onlyOwner {
+        _pause();
+    }
+
+    function unpause() external onlyOwner {
+        _unpause();
+    }
+
+    function _beforeTokenTransfer(address, address, uint256) internal virtual override whenNotPaused {}
+
+    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 getTokensIn() public view virtual returns (address[] memory res);
+
+    function getTokensOut() public view virtual returns (address[] memory res);
+
+    function isValidTokenIn(address token) public view virtual returns (bool);
+
+    function isValidTokenOut(address token) public view virtual returns (bool);
+}

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 whenNotPaused returns (uint256[] memory rewardAmounts) {
         _updateAndDistributeRewards(user);
         rewardAmounts = _doTransferOutRewards(user, user);
 
@@ -40,26 +36,14 @@ abstract contract SYBaseWithRewards is SYBase, RewardManager {
     /**
      * @dev See {IStandardizedYield-getRewardTokens}
      */
-    function getRewardTokens()
-        external
-        view
-        virtual
-        override
-        returns (address[] memory rewardTokens)
-    {
+    function getRewardTokens() external view virtual override returns (address[] memory rewardTokens) {
         rewardTokens = _getRewardTokens();
     }
 
     /**
      * @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; ) {
@@ -70,23 +54,11 @@ abstract contract SYBaseWithRewards is SYBase, RewardManager {
         }
     }
 
-    function rewardIndexesCurrent()
-        external
-        override
-        nonReentrant
-        returns (uint256[] memory indexes)
-    {
-        _updateRewardIndex();
-        return rewardIndexesStored();
+    function rewardIndexesCurrent() external override nonReentrant whenNotPaused returns (uint256[] memory indexes) {
+        (, indexes) = _updateRewardIndex();
     }
 
-    function rewardIndexesStored()
-        public
-        view
-        virtual
-        override
-        returns (uint256[] memory indexes)
-    {
+    function rewardIndexesStored() public view virtual override returns (uint256[] memory indexes) {
         address[] memory rewardTokens = _getRewardTokens();
         indexes = new uint256[](rewardTokens.length);
         for (uint256 i = 0; i < rewardTokens.length; ) {
@@ -116,11 +88,7 @@ abstract contract SYBaseWithRewards is SYBase, RewardManager {
     /*///////////////////////////////////////////////////////////////
                             TRANSFER HOOKS
     //////////////////////////////////////////////////////////////*/
-    function _beforeTokenTransfer(
-        address from,
-        address to,
-        uint256
-    ) internal virtual override whenNotPaused {
+    function _beforeTokenTransfer(address from, address to, uint256) internal virtual override whenNotPaused {
         _updateAndDistributeRewardsForTwo(from, to);
     }
 }

package/contracts/core/StandardizedYield/SYBaseWithRewardsUpg.sol

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../RewardManager/RewardManager.sol";
+import "./SYBaseUpg.sol";
+
+/// NOTE: yieldToken MUST NEVER BE a rewardToken, else the rewardManager will behave erroneously
+abstract contract SYBaseWithRewardsUpg is SYBaseUpg, RewardManager {
+    using PMath for uint256;
+    using ArrayLib for address[];
+
+    uint256[100] private __gap;
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {IStandardizedYield-claimRewards}
+     */
+    function claimRewards(
+        address user
+    ) external virtual override nonReentrant whenNotPaused returns (uint256[] memory rewardAmounts) {
+        _updateAndDistributeRewards(user);
+        rewardAmounts = _doTransferOutRewards(user, user);
+
+        emit ClaimRewards(user, _getRewardTokens(), rewardAmounts);
+    }
+
+    /**
+     * @dev See {IStandardizedYield-getRewardTokens}
+     */
+    function getRewardTokens() external view virtual override returns (address[] memory rewardTokens) {
+        rewardTokens = _getRewardTokens();
+    }
+
+    /**
+     * @dev See {IStandardizedYield-accruedRewards}
+     */
+    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; ) {
+            rewardAmounts[i] = userReward[rewardTokens[i]][user].accrued;
+            unchecked {
+                i++;
+            }
+        }
+    }
+
+    function rewardIndexesCurrent() external override nonReentrant whenNotPaused returns (uint256[] memory indexes) {
+        (, indexes) = _updateRewardIndex();
+    }
+
+    function rewardIndexesStored() public view virtual override returns (uint256[] memory indexes) {
+        address[] memory rewardTokens = _getRewardTokens();
+        indexes = new uint256[](rewardTokens.length);
+        for (uint256 i = 0; i < rewardTokens.length; ) {
+            indexes[i] = rewardState[rewardTokens[i]].index;
+            unchecked {
+                i++;
+            }
+        }
+    }
+
+    /**
+     * @notice returns the total number of reward shares
+     * @dev this is simply the total supply of shares, as rewards shares are equivalent to SY shares
+     */
+    function _rewardSharesTotal() internal view virtual override returns (uint256) {
+        return totalSupply();
+    }
+
+    /**
+     * @notice returns the reward shares of (`user`)
+     * @dev this is simply the SY balance of (`user`), as rewards shares are equivalent to SY shares
+     */
+    function _rewardSharesUser(address user) internal view virtual override returns (uint256) {
+        return balanceOf(user);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                            TRANSFER HOOKS
+    //////////////////////////////////////////////////////////////*/
+    function _beforeTokenTransfer(address from, address to, uint256) internal virtual override whenNotPaused {
+        _updateAndDistributeRewardsForTwo(from, to);
+    }
+}

package/contracts/core/StandardizedYield/SYUtils.sol

@@ -16,10 +16,7 @@ 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,26 +16,20 @@ 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;
         } else {
             if (tokenIn == WETH) IWETH(WETH).withdraw(amountDep);
 
-            uint256 amountStEthSharesOut = IStETH(STETH).submit{ value: amountDep }(address(0));
+            uint256 amountStEthSharesOut = IStETH(STETH).submit{value: amountDep}(address(0));
             amountStETH = IStETH(STETH).getPooledEthByShares(amountStEthSharesOut);
         }
         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);
     }

package/contracts/core/StandardizedYield/implementations/AaveV3/PendleAaveV3SY.sol

@@ -0,0 +1,94 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.23;
+
+import "../../SYBase.sol";
+import "./libraries/AaveAdapterLib.sol";
+import "../../../../interfaces/AaveV3/IAaveV3AToken.sol";
+import "../../../../interfaces/AaveV3/IAaveV3Pool.sol";
+
+// @NOTE: In this contract, we denote the "scaled balance" term as "share"
+contract PendleAaveV3SY is SYBase {
+    using PMath for uint256;
+
+    address public immutable aToken;
+    address public immutable aavePool;
+    address public immutable underlying;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _aavePool,
+        address _aToken
+    ) SYBase(_name, _symbol, _aToken) {
+        aToken = _aToken;
+        aavePool = _aavePool;
+        underlying = IAaveV3AToken(aToken).UNDERLYING_ASSET_ADDRESS();
+
+        _safeApproveInf(underlying, _aavePool);
+    }
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 amountSharesOut) {
+        if (tokenIn == underlying) {
+            IAaveV3Pool(aavePool).supply(underlying, amountDeposited, address(this), 0);
+        }
+        amountSharesOut = AaveAdapterLib.calcSharesFromAssetUp(amountDeposited, _getNormalizedIncome());
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256 amountTokenOut) {
+        amountTokenOut = AaveAdapterLib.calcSharesToAssetDown(amountSharesToRedeem, _getNormalizedIncome());
+        if (tokenOut == underlying) {
+            IAaveV3Pool(aavePool).withdraw(underlying, amountTokenOut, receiver);
+        } else {
+            _transferOut(aToken, receiver, amountTokenOut);
+        }
+    }
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return _getNormalizedIncome() / 1e9;
+    }
+
+    function _previewDeposit(
+        address,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 /*amountSharesOut*/) {
+        return AaveAdapterLib.calcSharesFromAssetUp(amountTokenToDeposit, _getNormalizedIncome());
+    }
+
+    function _previewRedeem(
+        address,
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256 /*amountTokenOut*/) {
+        return AaveAdapterLib.calcSharesToAssetDown(amountSharesToRedeem, _getNormalizedIncome());
+    }
+
+    function _getNormalizedIncome() internal view returns (uint256) {
+        return IAaveV3Pool(aavePool).getReserveNormalizedIncome(underlying);
+    }
+
+    function getTokensIn() public view override returns (address[] memory res) {
+        return ArrayLib.create(underlying, aToken);
+    }
+
+    function getTokensOut() public view override returns (address[] memory res) {
+        return ArrayLib.create(underlying, aToken);
+    }
+
+    function isValidTokenIn(address token) public view override returns (bool) {
+        return token == aToken || token == underlying;
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool) {
+        return token == aToken || token == underlying;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, underlying, IERC20Metadata(underlying).decimals());
+    }
+}

package/contracts/core/StandardizedYield/implementations/AaveV3/libraries/AaveAdapterLib.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+import "./WadRayMath.sol";
+
+library AaveAdapterLib {
+    // Also denote this function as f(share) for a given (constant) index
+    function calcSharesToAssetDown(uint256 amountShares, uint256 index) internal pure returns (uint256) {
+        return (amountShares * index) / WadRayMath.RAY;
+    }
+
+    function calcSharesFromAssetDown(uint256 amountAssets, uint256 index) internal pure returns (uint256) {
+        return (amountAssets * WadRayMath.RAY) / index;
+    }
+
+    function calcSharesFromAssetUp(uint256 amountAssets, uint256 index) internal pure returns (uint256) {
+        return WadRayMath.rayDiv(amountAssets, index);
+    }
+}