@pendle/core-v2 5.2.0-beta-5 → 5.2.1-beta-1

package/contracts/LiquidityMining/CrossChainMsg/libraries/LayerZeroHelper.sol

@@ -5,40 +5,46 @@ library LayerZeroHelper {
     uint256 constant EVM_ADDRESS_SIZE = 20;
 
     function _getLayerZeroChainIds(uint256 chainId) internal pure returns (uint16) {
-        if (chainId == 43113) return 10106;
         // fuji testnet
-        else if (chainId == 80001) return 10109;
+        if (chainId == 43113) return 10106;
         // mumbai testnet
-        else if (chainId == 43114) return 106;
+        else if (chainId == 80001) return 10109;
         // avax mainnet
-        else if (chainId == 42161) return 110;
+        else if (chainId == 43114) return 106;
         // arbitrum one
-        else if (chainId == 56) return 102;
+        else if (chainId == 42161) return 110;
         // binance smart chain
+        else if (chainId == 56) return 102;
+        // mainnet
         else if (chainId == 1) return 101;
         // mantle
         else if (chainId == 5000) return 181;
         // optimism
         else if (chainId == 10) return 111;
+        // base
+        else if (chainId == 8453) return 184;
         assert(false);
     }
 
     function _getOriginalChainIds(uint16 chainId) internal pure returns (uint256) {
-        if (chainId == 10106) return 43113;
         // fuji testnet
-        else if (chainId == 10109) return 80001;
+        if (chainId == 10106) return 43113;
         // mumbai testnet
-        else if (chainId == 106) return 43114;
+        else if (chainId == 10109) return 80001;
         // avax mainnet
-        else if (chainId == 110) return 42161;
+        else if (chainId == 106) return 43114;
         // arbitrum one
-        else if (chainId == 102) return 56;
+        else if (chainId == 110) return 42161;
         // binance smart chain
+        else if (chainId == 102) return 56;
+        // mainnet
         else if (chainId == 101) return 1;
         // mantle
         else if (chainId == 181) return 5000;
         // optimism
         else if (chainId == 111) return 10;
+        // base
+        else if (chainId == 184) return 8453;
         assert(false);
     }
 

package/contracts/LiquidityMining/VotingController/PendleVotingControllerUpg.sol

@@ -150,8 +150,13 @@ contract PendleVotingControllerUpg is PendleMsgSenderAppUpg, VotingControllerSto
                     GOVERNANCE-ONLY FUNCTIONS
     //////////////////////////////////////////////////////////////*/
 
-    modifier onlyHelperAndOwner() {
-        require(msg.sender == ownerHelper || msg.sender == owner, "not allowed");
+    modifier onlyAddPoolHelperAndOwner() {
+        require(msg.sender == addPoolHelper || msg.sender == owner, "add pool not allowed");
+        _;
+    }
+
+    modifier onlyRemovePoolHelperAndOwner() {
+        require(msg.sender == removePoolHelper || msg.sender == owner, "remove pool not allowed");
         _;
     }
 
@@ -162,7 +167,7 @@ contract PendleVotingControllerUpg is PendleMsgSenderAppUpg, VotingControllerSto
      * - `pool` must not have been added before (even if has been removed).
      * - `chainId` must be valid.
      */
-    function addPool(uint64 chainId, address pool) external onlyHelperAndOwner {
+    function addPool(uint64 chainId, address pool) external onlyAddPoolHelperAndOwner {
         if (_isPoolActive(pool)) revert Errors.VCPoolAlreadyActive(pool);
         if (allRemovedPools.contains(pool)) revert Errors.VCPoolAlreadyAddAndRemoved(pool);
 
@@ -170,13 +175,25 @@ contract PendleVotingControllerUpg is PendleMsgSenderAppUpg, VotingControllerSto
         emit AddPool(chainId, pool);
     }
 
+    function addMultiPools(uint64[] memory chainIds, address[] memory pools) external onlyAddPoolHelperAndOwner {
+        if (chainIds.length != pools.length) revert Errors.ArrayLengthMismatch();
+        for (uint256 i = 0; i < chainIds.length; ++i) {
+            (uint64 chainId, address pool) = (chainIds[i], pools[i]);
+            if (_isPoolActive(pool)) revert Errors.VCPoolAlreadyActive(pool);
+            if (allRemovedPools.contains(pool)) revert Errors.VCPoolAlreadyAddAndRemoved(pool);
+
+            _addPool(chainId, pool);
+            emit AddPool(chainId, pool);
+        }
+    }
+
     /**
      * @notice remove a pool from voting. Can only be done by governance
      * @custom:gov NOTE TO GOV:
      * - Previous week's results should have been broadcasted prior to calling this function.
      * - `pool` must be currently active.
      */
-    function removePool(address pool) external onlyOwner {
+    function removePool(address pool) external onlyRemovePoolHelperAndOwner {
         if (!_isPoolActive(pool)) revert Errors.VCInactivePool(pool);
 
         uint64 chainId = poolData[pool].chainId;
@@ -263,8 +280,12 @@ contract PendleVotingControllerUpg is PendleMsgSenderAppUpg, VotingControllerSto
         }
     }
 
-    function setOwnerHelper(address _helper) public onlyOwner {
-        ownerHelper = _helper;
+    function setAddPoolHelper(address _helper) public onlyOwner {
+        addPoolHelper = _helper;
+    }
+
+    function setRemovePoolHelper(address _helper) public onlyOwner {
+        removePoolHelper = _helper;
     }
 
     //solhint-disable-next-line

package/contracts/LiquidityMining/VotingController/VotingControllerStorageUpg.sol

@@ -73,9 +73,10 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
     // [user][pool] => checkpoint
     mapping(address => mapping(address => Checkpoints.History)) internal __dep_userPoolHistory;
 
-    address public ownerHelper;
+    address public addPoolHelper;
+    address public removePoolHelper;
 
-    uint256[99] private __gap;
+    uint256[98] private __gap;
 
     constructor(address _vePendle) {
         vePendle = IPVeToken(_vePendle);

package/contracts/core/StandardizedYield/SYBaseWithoutPermitUpg.sol

@@ -12,7 +12,13 @@ import "../libraries/Errors.sol";
 import "../libraries/BoringOwnableUpgradeable.sol";
 import "@openzeppelin/contracts/security/Pausable.sol";
 
-abstract contract SYBaseUpg is IStandardizedYield, PendleERC20Upg, TokenHelper, BoringOwnableUpgradeable, Pausable {
+abstract contract SYBaseWithoutPermitUpg is
+    IStandardizedYield,
+    PendleERC20Upg,
+    TokenHelper,
+    BoringOwnableUpgradeable,
+    Pausable
+{
     using PMath for uint256;
 
     address public immutable yieldToken;

package/contracts/core/StandardizedYield/implementations/AaveV3/{PendleAaveV3WithRewardsSY.sol → PendleAaveV3WithRewardsSYUpg.sol}

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.23;
 
-import "../../SYBaseWithRewards.sol";
+import "../../SYBaseWithRewardsUpg.sol";
 import "./libraries/AaveAdapterLib.sol";
 import "../../../../interfaces/AaveV3/IAaveV3AToken.sol";
 import "../../../../interfaces/AaveV3/IAaveV3Pool.sol";
@@ -11,7 +11,7 @@ import "../../../../interfaces/AaveV3/IAaveV3IncentiveController.sol";
 
 // [NEW] @NOTE: As for the getRewardTokens function, it will check for different incentive controller
 // so this implementation should only be used in L2s. L1 would require more gas optimization
-contract PendleAaveV3WithRewardsSY is SYBaseWithRewards {
+contract PendleAaveV3WithRewardsSYUpg is SYBaseWithRewardsUpg {
     using PMath for uint256;
 
     event NewIncentiveController(address incentiveController);
@@ -22,25 +22,27 @@ contract PendleAaveV3WithRewardsSY is SYBaseWithRewards {
     address public immutable aToken;
     address public immutable aavePool;
     address public immutable underlying;
+    address public immutable incentiveController;
+    address public immutable defaultRewardToken;
 
-    address public incentiveController;
-    address[] public rewardTokens;
+    uint256[100] private __gap;
 
     constructor(
-        string memory _name,
-        string memory _symbol,
         address _aavePool,
         address _aToken,
-        address _incentiveController
-    ) SYBaseWithRewards(_name, _symbol, _aToken) {
+        address _initialIncentiveController,
+        address _defaultRewardToken
+    ) SYBaseUpg(_aToken) {
         aToken = _aToken;
         aavePool = _aavePool;
         underlying = IAaveV3AToken(aToken).UNDERLYING_ASSET_ADDRESS();
+        incentiveController = _initialIncentiveController;
+        defaultRewardToken = _defaultRewardToken;
+    }
 
-        if (_incentiveController != address(0)) {
-            _updateIncentiveController(_incentiveController);
-        }
-        _safeApproveInf(underlying, _aavePool);
+    function initialize(string memory _name, string memory _symbol) external initializer {
+        __SYBaseUpg_init(_name, _symbol);
+        _safeApproveInf(underlying, aavePool);
     }
 
     function _deposit(
@@ -73,14 +75,14 @@ contract PendleAaveV3WithRewardsSY is SYBaseWithRewards {
     function _previewDeposit(
         address,
         uint256 amountTokenToDeposit
-    ) internal view override returns (uint256 /*amountSharesOut*/) {
+    ) internal view virtual override returns (uint256 /*amountSharesOut*/) {
         return AaveAdapterLib.calcSharesFromAssetUp(amountTokenToDeposit, _getNormalizedIncome());
     }
 
     function _previewRedeem(
         address,
         uint256 amountSharesToRedeem
-    ) internal view override returns (uint256 /*amountTokenOut*/) {
+    ) internal view virtual override returns (uint256 /*amountTokenOut*/) {
         return AaveAdapterLib.calcSharesToAssetDown(amountSharesToRedeem, _getNormalizedIncome());
     }
 
@@ -88,23 +90,28 @@ contract PendleAaveV3WithRewardsSY is SYBaseWithRewards {
         return IAaveV3Pool(aavePool).getReserveNormalizedIncome(underlying);
     }
 
-    function getTokensIn() public view override returns (address[] memory res) {
+    function getTokensIn() public view virtual override returns (address[] memory res) {
         return ArrayLib.create(underlying, aToken);
     }
 
-    function getTokensOut() public view override returns (address[] memory res) {
+    function getTokensOut() public view virtual override returns (address[] memory res) {
         return ArrayLib.create(underlying, aToken);
     }
 
-    function isValidTokenIn(address token) public view override returns (bool) {
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
         return token == aToken || token == underlying;
     }
 
-    function isValidTokenOut(address token) public view override returns (bool) {
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
         return token == aToken || token == underlying;
     }
 
-    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+    function assetInfo()
+        external
+        view
+        virtual
+        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
+    {
         return (AssetType.TOKEN, underlying, IERC20Metadata(underlying).decimals());
     }
 
@@ -112,19 +119,11 @@ contract PendleAaveV3WithRewardsSY is SYBaseWithRewards {
                             REWARDS-RELATED
     //////////////////////////////////////////////////////////////*/
 
-    function updateIncentiveController(address _incentiveController) external onlyOwner {
-        _updateIncentiveController(_incentiveController);
-    }
-
-    function updateRewardTokenList() external onlyOwner {
-        _updateRewardTokenList();
-    }
-
     /**
      * @dev See {IStandardizedYield-getRewardTokens}
      */
     function _getRewardTokens() internal view override returns (address[] memory res) {
-        return rewardTokens;
+        return ArrayLib.create(defaultRewardToken);
     }
 
     function _redeemExternalReward() internal override {
@@ -132,21 +131,4 @@ contract PendleAaveV3WithRewardsSY is SYBaseWithRewards {
             IAaveV3IncentiveController(incentiveController).claimAllRewardsToSelf(ArrayLib.create(aToken));
         }
     }
-
-    function _updateIncentiveController(address _incentiveController) internal {
-        if (_incentiveController == incentiveController) {
-            revert SameIncentiveController();
-        }
-        _redeemExternalReward();
-
-        incentiveController = _incentiveController;
-        if (_incentiveController != address(0)) {
-            _updateRewardTokenList();
-        }
-        emit NewIncentiveController(_incentiveController);
-    }
-
-    function _updateRewardTokenList() internal {
-        rewardTokens = ArrayLib.merge(rewardTokens, IAaveV3IncentiveController(incentiveController).getRewardsList());
-    }
 }

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

@@ -0,0 +1,130 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../SYBaseWithRewardsUpg.sol";
+import "../../../../interfaces/AaveV3/IAaveStkGHO.sol";
+import "../../../../interfaces/Angle/IAngleDistributor.sol";
+
+contract PendleStkGHOSY is SYBaseWithRewardsUpg {
+    using PMath for uint256;
+
+    event ClaimedOffchainGHO(uint256 amountClaimed);
+
+    address public constant ANGLE_DISTRIBUTOR = 0x3Ef3D8bA38EBe18DB133cEc108f4D14CE00Dd9Ae;
+    address public constant STKGHO = 0x1a88Df1cFe15Af22B3c4c783D4e6F7F9e0C1885d;
+    address public constant GHO = 0x40D16FC0246aD3160Ccc09B8D0D3A2cD28aE6C2f;
+    address public constant AAVE = 0x7Fc66500c84A76Ad7e9c93437bFc5Ac33E2DDaE9;
+    bytes32 public constant ZERO_REWARD_ERROR = 0x33d2eb294587ef7b32eb48e48695ebfec45a9c8922ec7d1c444cfad1fb208e8d;
+
+    constructor() SYBaseUpg(STKGHO) {}
+
+    function initialize() external initializer {
+        __SYBaseUpg_init("SY stk GHO", "SY-stkGHO");
+        _safeApproveInf(GHO, STKGHO);
+    }
+
+    function _deposit(address tokenIn, uint256 amountDeposited) internal virtual override returns (uint256) {
+        if (tokenIn == STKGHO) {
+            return amountDeposited;
+        }
+
+        uint256 preBalance = _selfBalance(STKGHO);
+        IAaveStkGHO(STKGHO).stake(address(this), amountDeposited);
+        return _selfBalance(STKGHO) - preBalance;
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256) {
+        _transferOut(STKGHO, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return PMath.ONE.divDown(IAaveStkGHO(STKGHO).getExchangeRate());
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {IStandardizedYield-getRewardTokens}
+     */
+    function _getRewardTokens() internal pure override returns (address[] memory) {
+        return ArrayLib.create(AAVE);
+    }
+
+    function _redeemExternalReward() internal override {
+        try IAaveStkGHO(STKGHO).claimRewards(address(this), type(uint256).max) {} catch Error(
+            string memory errorString
+        ) {
+            // StkGHO claim reverts when claimable amount = 0, meaning two sy transfers in diff block/same timestamp would revert.
+            // This is expected to not happen at all on ETH mainnet but just to be sure.
+            if (keccak256(abi.encodePacked(errorString)) != ZERO_REWARD_ERROR) {
+                revert(errorString);
+            }
+        }
+    }
+
+    function claimOffchainGHORewards(
+        address[] calldata users,
+        address[] calldata tokens,
+        uint256[] calldata amounts,
+        bytes32[][] calldata proofs
+    ) external onlyOwner {
+        uint256 preBalance = _selfBalance(GHO);
+        IAngleDistributor(ANGLE_DISTRIBUTOR).claim(users, tokens, amounts, proofs);
+        uint256 amountClaimed = _selfBalance(GHO) - preBalance;
+
+        if (amountClaimed > 0) {
+            _transferOut(GHO, msg.sender, amountClaimed);
+            emit ClaimedOffchainGHO(amountClaimed);
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 amountSharesOut) {
+        if (tokenIn == STKGHO) return amountTokenToDeposit;
+        return IAaveStkGHO(STKGHO).previewStake(amountTokenToDeposit);
+    }
+
+    function _previewRedeem(
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256 amountTokenOut) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(GHO, STKGHO);
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(STKGHO);
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == GHO || token == STKGHO;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == STKGHO;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, GHO, IERC20Metadata(GHO).decimals());
+    }
+}

package/contracts/core/StandardizedYield/implementations/GLP/PendleGlpSY.sol

@@ -15,7 +15,7 @@ contract PendleGlpSY is SYBaseWithRewardsUpg, GLPPreviewHelper {
     address public immutable stakedGlp;
     address public immutable rewardRouter;
     address public immutable glpRouter;
-    address public immutable glpManager;
+    address public immutable glpManager = 0x3963FfC9dff443c2A94f21b129D429891E32ec18;
     address public immutable weth;
 
     constructor(
@@ -31,7 +31,6 @@ contract PendleGlpSY is SYBaseWithRewardsUpg, GLPPreviewHelper {
         stakedGlp = _stakedGlp;
         rewardRouter = _rewardRouter;
         glpRouter = _glpRouter;
-        glpManager = IRewardRouterV2(glpRouter).glpManager();
         weth = IRewardRouterV2(glpRouter).weth();
     }
 

package/contracts/core/StandardizedYield/implementations/Mantle/PendleCMETHSY.sol

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../SYBase.sol";
+import "../../../../interfaces/IPExchangeRateOracle.sol";
+
+contract PendleCMETHSY is SYBase {
+    using PMath for int256;
+
+    address public exchangeRateOracle = 0x1E2Ad9764cfAc60876486A7c714bc71f5b55f5C2;
+    address public constant CMETH = 0xE6829d9a7eE3040e1276Fa75293Bde931859e8fA;
+    address public constant WETH = 0xdEAddEaDdeadDEadDEADDEAddEADDEAddead1111;
+
+    constructor() SYBase("SY cmETH", "SY-cmETH", CMETH) {}
+
+    function setExchangeRateOracle(address newOracle) external onlyOwner {
+        exchangeRateOracle = newOracle;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address, uint256 amountDeposited) internal pure override returns (uint256 /*amountSharesOut*/) {
+        return amountDeposited;
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256 /*amountTokenOut*/) {
+        _transferOut(tokenOut, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view override returns (uint256) {
+        return IPExchangeRateOracle(exchangeRateOracle).getExchangeRate();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address,
+        uint256 amountTokenToDeposit
+    ) internal pure override returns (uint256 /*amountSharesOut*/) {
+        return amountTokenToDeposit;
+    }
+
+    function _previewRedeem(
+        address,
+        uint256 amountSharesToRedeem
+    ) internal pure override returns (uint256 /*amountTokenOut*/) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view override returns (address[] memory res) {
+        return ArrayLib.create(yieldToken);
+    }
+
+    function getTokensOut() public view override returns (address[] memory res) {
+        return ArrayLib.create(yieldToken);
+    }
+
+    function isValidTokenIn(address token) public view override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, WETH, 18);
+    }
+}

package/contracts/core/StandardizedYield/implementations/Morpho/PendleMorphoMetaVaultSY.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../PendleERC4626SYV2.sol";
+import "../../../../interfaces/IPTokenWithSupplyCap.sol";
+
+contract PendleMorphoMetaVaultSY is PendleERC4626SYV2, IPTokenWithSupplyCap {
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _erc4626
+    ) PendleERC4626SYV2(_name, _symbol, _erc4626) {}
+
+    function getAbsoluteSupplyCap() external view returns (uint256) {
+        return IERC4626(yieldToken).totalSupply() + IERC4626(yieldToken).maxMint(address(this));
+    }
+
+    function getAbsoluteTotalSupply() external view returns (uint256) {
+        return IERC4626(yieldToken).totalSupply();
+    }
+}

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

@@ -42,7 +42,6 @@ contract PendleERC4626SY is SYBase {
         uint256 totalSupply = IERC4626(yieldToken).totalSupply();
         return totalAssets.divDown(totalSupply);
     }
-
     function _previewDeposit(
         address tokenIn,
         uint256 amountTokenToDeposit

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

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../SYBase.sol";
+import "../../../interfaces/IERC4626.sol";
+
+contract PendleERC4626SYV2 is SYBase {
+    using PMath for uint256;
+    address public immutable asset;
+
+    constructor(string memory _name, string memory _symbol, address _erc4626) SYBase(_name, _symbol, _erc4626) {
+        asset = IERC4626(_erc4626).asset();
+        _safeApproveInf(asset, _erc4626);
+    }
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == yieldToken) {
+            return amountDeposited;
+        } else {
+            return IERC4626(yieldToken).deposit(amountDeposited, address(this));
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 amountTokenOut) {
+        if (tokenOut == yieldToken) {
+            amountTokenOut = amountSharesToRedeem;
+            _transferOut(yieldToken, receiver, amountTokenOut);
+        } else {
+            amountTokenOut = IERC4626(yieldToken).redeem(amountSharesToRedeem, receiver, address(this));
+        }
+    }
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return IERC4626(yieldToken).convertToAssets(PMath.ONE);
+    }
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == yieldToken) return amountTokenToDeposit;
+        else return IERC4626(yieldToken).previewDeposit(amountTokenToDeposit);
+    }
+
+    function _previewRedeem(
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256 /*amountTokenOut*/) {
+        if (tokenOut == yieldToken) return amountSharesToRedeem;
+        else return IERC4626(yieldToken).previewRedeem(amountSharesToRedeem);
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = asset;
+        res[1] = yieldToken;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = asset;
+        res[1] = yieldToken;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == yieldToken || token == asset;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == yieldToken || token == asset;
+    }
+
+    function assetInfo()
+        external
+        view
+        virtual
+        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
+    {
+        return (AssetType.TOKEN, asset, IERC20Metadata(asset).decimals());
+    }
+}