@pendle/core-v2 4.7.2 → 4.7.3-beta

package/contracts/LiquidityMining/GaugeController/PendleGaugeControllerSidechainUpg.sol

@@ -11,9 +11,10 @@ contract PendleGaugeControllerSidechainUpg is PendleGaugeControllerBaseUpg, Pend
         address _pendle,
         address _marketFactory,
         address _marketFactory2,
+        address _marketFactory3,
         address _PendleMsgReceiveEndpointUpg
     )
-        PendleGaugeControllerBaseUpg(_pendle, _marketFactory, _marketFactory2)
+        PendleGaugeControllerBaseUpg(_pendle, _marketFactory, _marketFactory2, _marketFactory3)
         PendleMsgReceiverAppUpg(_PendleMsgReceiveEndpointUpg)
     {
         _disableInitializers();

package/contracts/core/Market/MarketMathCore.sol

@@ -147,11 +147,11 @@ library MarketMathCore {
             if (netLpByPt < netLpBySy) {
                 lpToAccount = netLpByPt;
                 ptUsed = ptDesired;
-                syUsed = (market.totalSy * lpToAccount) / market.totalLp;
+                syUsed = (market.totalSy * lpToAccount).rawDivUp(market.totalLp);
             } else {
                 lpToAccount = netLpBySy;
                 syUsed = syDesired;
-                ptUsed = (market.totalPt * lpToAccount) / market.totalLp;
+                ptUsed = (market.totalPt * lpToAccount).rawDivUp(market.totalLp);
             }
         }
 

package/contracts/core/RewardManager/RewardManager.sol

@@ -39,15 +39,12 @@ abstract contract RewardManager is RewardManagerAbstract {
 
                 RewardState memory _state = rewardState[token];
                 (uint256 lastBalance, uint256 index) = (_state.lastBalance, _state.index);
-
-                uint256 accrued = _selfBalance(tokens[i]) - lastBalance;
-
                 if (index == 0) index = INITIAL_REWARD_INDEX;
-                if (totalShares != 0) index += accrued.divDown(totalShares);
 
+                (uint256 consumedIndex, uint256 consumedReward) = _getConsumedReward(token, lastBalance, totalShares);
                 rewardState[token] = RewardState({
-                    index: index.Uint128(),
-                    lastBalance: (lastBalance + accrued).Uint128()
+                    index: (index + consumedIndex).Uint128(),
+                    lastBalance: (lastBalance + consumedReward).Uint128()
                 });
                 indexes[i] = index;
             }
@@ -58,6 +55,20 @@ abstract contract RewardManager is RewardManagerAbstract {
         }
     }
 
+    function _getConsumedReward(
+        address token,
+        uint256 lastBalance,
+        uint256 totalShares
+    ) private view returns (uint256 consumedIndex, uint256 consumedReward) {
+        if (totalShares == 0) {
+            return (0, 0);
+        }
+
+        uint256 accrued = _selfBalance(token) - lastBalance;
+        consumedIndex = accrued.divDown(totalShares);
+        consumedReward = (consumedIndex * totalShares) / PMath.ONE;
+    }
+
     /// @dev this function doesn't need redeemExternal since redeemExternal is bundled in updateRewardIndex
     /// @dev this function also has to update rewardState.lastBalance
     function _doTransferOutRewards(

package/contracts/core/StandardizedYield/implementations/Dolomite/PendleDolomiteSY.sol

@@ -12,11 +12,7 @@ contract PendleDolomiteSY is SYBase {
     address public immutable marginContract;
     address public immutable dToken;
 
-    constructor(
-        string memory _name,
-        string memory _symbol,
-        address _dToken
-    ) SYBase(_name, _symbol, _dToken) {
+    constructor(string memory _name, string memory _symbol, address _dToken) SYBase(_name, _symbol, _dToken) {
         asset = IDolomiteDToken(_dToken).underlyingToken();
         marketId = IDolomiteDToken(_dToken).marketId();
         marginContract = IDolomiteDToken(_dToken).DOLOMITE_MARGIN();
@@ -69,10 +65,7 @@ contract PendleDolomiteSY is SYBase {
                         MISC FUNCTIONS FOR METADATA
     //////////////////////////////////////////////////////////////*/
 
-    function _previewDeposit(
-        address tokenIn,
-        uint256 amountTokenToDeposit
-    ) internal view override returns (uint256) {
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit) internal view override returns (uint256) {
         if (tokenIn == dToken) {
             return amountTokenToDeposit;
         }
@@ -80,10 +73,7 @@ contract PendleDolomiteSY is SYBase {
         return (amountTokenToDeposit * PMath.ONE) / index;
     }
 
-    function _previewRedeem(
-        address tokenOut,
-        uint256 amountSharesToRedeem
-    ) internal view override returns (uint256) {
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem) internal view override returns (uint256) {
         if (tokenOut == dToken) {
             return amountSharesToRedeem;
         }

package/contracts/core/StandardizedYield/implementations/EtherFi/PendleWEEthkSY.sol

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.23;
+
+import "../PendleERC20SYUpg.sol";
+import "../../../../interfaces/EtherFi/IVedaTeller.sol";
+import "../../../../interfaces/EtherFi/IVedaAccountant.sol";
+
+contract PendleWEEthkSY is PendleERC20SYUpg {
+    using PMath for uint256;
+
+    // solhint-disable immutable-vars-naming
+    // solhint-disable const-name-snakecase
+    // solhint-disable ordering
+
+    address public constant weETHk = 0x7223442cad8e9cA474fC40109ab981608F8c4273;
+    address public constant vedaTeller = 0x929B44db23740E65dF3A81eA4aAB716af1b88474;
+    address public constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
+    address public constant WEETH = 0xCd5fE23C85820F7B72D0926FC9b05b43E359b7ee;
+    address public constant EETH = 0x35fA164735182de50811E8e2E824cFb9B6118ac2;
+    address public constant WSTETH = 0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0;
+
+    address public immutable vedaAccountant;
+
+    constructor() PendleERC20SYUpg(weETHk) {
+        vedaAccountant = IVedaTeller(vedaTeller).accountant();
+    }
+
+    function approveAllForTeller() external {
+        _safeApproveInf(WETH, weETHk);
+        _safeApproveInf(WEETH, weETHk);
+        _safeApproveInf(EETH, weETHk);
+        _safeApproveInf(WSTETH, weETHk);
+    }
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == weETHk) {
+            return amountDeposited;
+        }
+        return IVedaTeller(vedaTeller).bulkDeposit(tokenIn, amountDeposited, 0, address(this));
+    }
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view virtual override returns (uint256 amountSharesOut) {
+        if (tokenIn == weETHk) {
+            return amountTokenToDeposit;
+        }
+        uint256 rate = IVedaAccountant(vedaAccountant).getRateInQuoteSafe(tokenIn);
+        amountSharesOut = amountTokenToDeposit.divDown(rate);
+    }
+
+    function isValidTokenIn(address token) public pure override returns (bool) {
+        return token == weETHk || token == WETH || token == WEETH || token == EETH || token == WSTETH;
+    }
+
+    function getTokensIn() public pure override returns (address[] memory res) {
+        return ArrayLib.create(weETHk, WETH, WEETH, EETH, WSTETH);
+    }
+}

package/contracts/core/StandardizedYield/implementations/EtherFi/PendleWEEthsSY.sol

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.23;
+
+import "../PendleERC20SYUpg.sol";
+import "../../../../interfaces/EtherFi/IVedaTeller.sol";
+import "../../../../interfaces/EtherFi/IVedaAccountant.sol";
+
+contract PendleWEEthsSY is PendleERC20SYUpg {
+    using PMath for uint256;
+
+    // solhint-disable immutable-vars-naming
+    // solhint-disable const-name-snakecase
+    // solhint-disable ordering
+
+    address public constant weETHs = 0x917ceE801a67f933F2e6b33fC0cD1ED2d5909D88;
+    address public constant vedaTeller = 0x99dE9e5a3eC2750a6983C8732E6e795A35e7B861;
+    address public constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
+    address public constant WEETH = 0xCd5fE23C85820F7B72D0926FC9b05b43E359b7ee;
+    address public constant EETH = 0x35fA164735182de50811E8e2E824cFb9B6118ac2;
+    address public constant WSTETH = 0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0;
+
+    address public immutable vedaAccountant;
+
+    constructor() PendleERC20SYUpg(weETHs) {
+        vedaAccountant = IVedaTeller(vedaTeller).accountant();
+    }
+
+    function approveAllForTeller() external {
+        _safeApproveInf(WETH, weETHs);
+        _safeApproveInf(WEETH, weETHs);
+        _safeApproveInf(EETH, weETHs);
+        _safeApproveInf(WSTETH, weETHs);
+    }
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == weETHs) {
+            return amountDeposited;
+        }
+        return IVedaTeller(vedaTeller).bulkDeposit(tokenIn, amountDeposited, 0, address(this));
+    }
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view virtual override returns (uint256 amountSharesOut) {
+        if (tokenIn == weETHs) {
+            return amountTokenToDeposit;
+        }
+        uint256 rate = IVedaAccountant(vedaAccountant).getRateInQuoteSafe(tokenIn);
+        amountSharesOut = amountTokenToDeposit.divDown(rate);
+    }
+
+    function isValidTokenIn(address token) public pure override returns (bool) {
+        return token == weETHs || token == WETH || token == WEETH || token == EETH || token == WSTETH;
+    }
+
+    function getTokensIn() public pure override returns (address[] memory res) {
+        return ArrayLib.create(weETHs, WETH, WEETH, EETH, WSTETH);
+    }
+}

package/contracts/core/StandardizedYield/implementations/Mellow/PendleMellowVaultERC20SYUpg.sol

@@ -1,119 +1,115 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.0;
+pragma solidity ^0.8.17;
 
-import "../../SYBaseUpg.sol";
-import "../../StEthHelper.sol";
-import "../../../../interfaces/IPTokenWithSupplyCap.sol";
-import "../../../../interfaces/Mellow/IMellowVault.sol";
-import "../../../../interfaces/Mellow/IMellowVaultConfigurator.sol";
-import "../../../../interfaces/IPPriceFeed.sol";
+import "./PendleMellowVaultSYBaseUpg.sol";
 
-/// @dev This SY implementation intends to ignore native interest from Mellow Vault's underlying
-contract PendleMellowVaultERC20SYUpg is SYBaseUpg, IPTokenWithSupplyCap {
-    event SetPricingHelper(address newPricingHelper);
+contract PendleMellowVaultERC20SYUpg is PendleMellowVaultSYBaseUpg {
+    error MellowVaultHasInvalidAssets();
+    error SupplyCapExceeded(uint256 totalSupply, uint256 supplyCap);
+
+    using PMath for uint256;
+
+    // solhint-disable immutable-vars-naming
+    address public immutable depositToken;
 
     // solhint-disable immutable-vars-naming
-    address public immutable vault;
-    address public immutable configurator;
-    address public pricingHelper;
-
-    constructor(address _vault) SYBaseUpg(_vault) {
-        vault = _vault;
-        configurator = IMellowVault(_vault).configurator();
-        _disableInitializers();
+    uint256 public immutable interfaceVersion;
+
+    // [ERC20 deposit of the vault, vault address, interface version (0 = referral, 1 = non referral)]
+    constructor(address _depositToken, address _vault, uint256 _interfaceVersion) PendleMellowVaultSYBaseUpg(_vault) {
+        depositToken = _depositToken;
+        if (_interfaceVersion > 1) {
+            revert("invalid interface version");
+        }
+        interfaceVersion = _interfaceVersion;
     }
 
     function initialize(
         string memory _name,
         string memory _symbol,
         address _pricingHelper
-    ) external virtual initializer {
+    ) external override initializer {
         __SYBaseUpg_init(_name, _symbol);
+        _safeApproveInf(depositToken, vault);
         _setPricingHelper(_pricingHelper);
     }
 
     function _deposit(
-        address /*tokenIn*/,
+        address tokenIn,
         uint256 amountDeposited
     ) internal virtual override returns (uint256 amountSharesOut) {
-        return amountDeposited;
-    }
-
-    function _redeem(
-        address receiver,
-        address /*tokenOut*/,
-        uint256 amountSharesToRedeem
-    ) internal virtual override returns (uint256) {
-        _transferOut(vault, receiver, amountSharesToRedeem);
-        return amountSharesToRedeem;
+        if (tokenIn == vault) {
+            return amountDeposited;
+        }
+
+        if (interfaceVersion == 0) {
+            (, amountSharesOut) = IMellowVault(vault).deposit(
+                address(this),
+                ArrayLib.create(amountDeposited),
+                0,
+                type(uint256).max,
+                0
+            );
+        } else if (interfaceVersion == 1) {
+            (, amountSharesOut) = IMellowVault(vault).deposit(
+                address(this),
+                ArrayLib.create(amountDeposited),
+                0,
+                type(uint256).max
+            );
+        }
     }
 
     function exchangeRate() public view virtual override returns (uint256 res) {
-        return PMath.ONE;
+        (uint256 tvl, uint256 supply) = _getMellowVaultTvl();
+        return tvl * PMath.ONE / supply;
     }
 
     function _previewDeposit(
-        address /*tokenIn*/,
+        address tokenIn,
         uint256 amountTokenToDeposit
-    ) internal view virtual override returns (uint256 /*amountSharesOut*/) {
-        return amountTokenToDeposit;
-    }
+    ) internal view virtual override returns (uint256 amountSharesOut) {
+        if (tokenIn == vault) {
+            return amountTokenToDeposit;
+        }
 
-    function _previewRedeem(
-        address /*tokenOut*/,
-        uint256 amountSharesToRedeem
-    ) internal view virtual override returns (uint256 /*amountTokenOut*/) {
-        return amountSharesToRedeem;
-    }
+        (uint256 tvl, uint256 supply) = _getMellowVaultTvl();
+        amountSharesOut = (amountTokenToDeposit * supply) / tvl;
 
-    function getTokensIn() public view virtual override returns (address[] memory res) {
-        return ArrayLib.create(vault);
+        uint256 supplyCap = IMellowVaultConfigurator(configurator).maximalTotalSupply();
+        uint256 newSupply = supply + amountSharesOut;
+        if (newSupply > supplyCap) {
+            revert SupplyCapExceeded(newSupply, supplyCap);
+        }
     }
 
-    function getTokensOut() public view virtual override returns (address[] memory res) {
-        return ArrayLib.create(vault);
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        return ArrayLib.create(depositToken, vault);
     }
 
     function isValidTokenIn(address token) public view virtual override returns (bool) {
-        return token == vault;
+        return token == depositToken || token == vault;
     }
 
-    function isValidTokenOut(address token) public view virtual override returns (bool) {
-        return token == vault;
+    /// @dev returns mellow TVL in depositToken
+    /// @dev reverts if the vault contains more than 1 token
+    function _getMellowVaultTvl() internal view returns (uint256 tvl, uint256 supply) {
+        (address[] memory tokens, uint256[] memory amounts) = IMellowVault(vault).underlyingTvl();
+        if (tokens.length > 1 || tokens[0] != depositToken) {
+            revert MellowVaultHasInvalidAssets();
+        }
+
+        tvl = amounts[0];
+        supply = IERC20(vault).totalSupply();
     }
 
     function assetInfo()
         external
         view
         virtual
+        override
         returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
     {
-        return (AssetType.TOKEN, vault, IERC20Metadata(vault).decimals());
-    }
-
-    function getAbsoluteSupplyCap() external view virtual returns (uint256) {
-        return IMellowVaultConfigurator(configurator).maximalTotalSupply();
-    }
-
-    function getAbsoluteTotalSupply() external view virtual returns (uint256) {
-        return IERC20(vault).totalSupply();
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                        OFF-CHAIN USAGE ONLY
-            (NO SECURITY RELATED && CAN BE LEFT UNAUDITED)
-    //////////////////////////////////////////////////////////////*/
-
-    function setPricingHelper(address _pricingHelper) external onlyOwner {
-        _setPricingHelper(_pricingHelper);
-    }
-
-    function _setPricingHelper(address _pricingHelper) internal {
-        pricingHelper = _pricingHelper;
-        emit SetPricingHelper(_pricingHelper);
-    }
-
-    function getPrice() external view returns (uint256) {
-        return IPPriceFeed(pricingHelper).getPrice();
+        return (AssetType.TOKEN, depositToken, IERC20Metadata(depositToken).decimals());
     }
 }

package/contracts/core/StandardizedYield/implementations/Mellow/{PendleMellowVaultWstETHSY.sol → PendleMellowVaultERC4626SYUpg.sol}

@@ -1,17 +1,26 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import "./PendleMellowVaultERC20SYUpg.sol";
+import "./PendleMellowVaultSYBaseUpg.sol";
+import "../../../../interfaces/IERC4626.sol";
 
-/// @dev This SY implementation intends to ignore native interest from Mellow Vault's underlying
-contract PendleMellowVaultWstETHSYUpg is PendleMellowVaultERC20SYUpg, StEthHelper {
+contract PendleMellowVaultERC4626SYUpg is PendleMellowVaultSYBaseUpg {
     error MellowVaultHasInvalidAssets();
     error SupplyCapExceeded(uint256 totalSupply, uint256 supplyCap);
 
+    using PMath for uint256;
+
+    // solhint-disable immutable-vars-naming
+    address public immutable erc4626;
+    address public immutable asset;
+
     // solhint-disable immutable-vars-naming
     uint256 public immutable interfaceVersion;
 
-    constructor(address _vault, uint256 _interfaceVersion) PendleMellowVaultERC20SYUpg(_vault) {
+    constructor(address _erc4626, address _vault, uint256 _interfaceVersion) PendleMellowVaultSYBaseUpg(_vault) {
+        erc4626 = _erc4626;
+        asset = IERC4626(_erc4626).asset();
+
         if (_interfaceVersion > 1) {
             revert("invalid interface version");
         }
@@ -24,8 +33,8 @@ contract PendleMellowVaultWstETHSYUpg is PendleMellowVaultERC20SYUpg, StEthHelpe
         address _pricingHelper
     ) external override initializer {
         __SYBaseUpg_init(_name, _symbol);
-        _safeApproveInf(STETH, WSTETH);
-        _safeApproveInf(WSTETH, vault);
+        _safeApproveInf(asset, erc4626);
+        _safeApproveInf(erc4626, vault);
         _setPricingHelper(_pricingHelper);
     }
 
@@ -36,8 +45,8 @@ contract PendleMellowVaultWstETHSYUpg is PendleMellowVaultERC20SYUpg, StEthHelpe
         if (tokenIn == vault) {
             return amountDeposited;
         }
-        if (tokenIn != WSTETH) {
-            (tokenIn, amountDeposited) = (WSTETH, _depositWstETH(tokenIn, amountDeposited));
+        if (tokenIn != erc4626) {
+            (tokenIn, amountDeposited) = (erc4626, IERC4626(erc4626).deposit(amountDeposited, address(this)));
         }
 
         if (interfaceVersion == 0) {
@@ -58,8 +67,11 @@ contract PendleMellowVaultWstETHSYUpg is PendleMellowVaultERC20SYUpg, StEthHelpe
         }
     }
 
-    /// @dev Mellow uses math calculations under 2**96 base. Also they are taking into account oracle prices
-    /// even with one asset. So a discrepancy of 1e-6 in the result should be expected.
+    function exchangeRate() public view virtual override returns (uint256 res) {
+        (uint256 tvl, uint256 supply) = _getMellowVaultTvl();
+        return IERC4626(erc4626).convertToAssets(tvl * PMath.ONE / supply);
+    }
+
     function _previewDeposit(
         address tokenIn,
         uint256 amountTokenToDeposit
@@ -67,9 +79,11 @@ contract PendleMellowVaultWstETHSYUpg is PendleMellowVaultERC20SYUpg, StEthHelpe
         if (tokenIn == vault) {
             return amountTokenToDeposit;
         }
-        if (tokenIn != WSTETH) {
-            (tokenIn, amountTokenToDeposit) = (WSTETH, _previewDepositWstETH(tokenIn, amountTokenToDeposit));
+
+        if (tokenIn != erc4626) {
+            (tokenIn, amountTokenToDeposit) = (erc4626, IERC4626(erc4626).previewDeposit(amountTokenToDeposit));
         }
+
         (uint256 tvl, uint256 supply) = _getMellowVaultTvl();
         amountSharesOut = (amountTokenToDeposit * supply) / tvl;
 
@@ -80,23 +94,33 @@ contract PendleMellowVaultWstETHSYUpg is PendleMellowVaultERC20SYUpg, StEthHelpe
         }
     }
 
-    function getTokensIn() public view override returns (address[] memory res) {
-        return ArrayLib.create(NATIVE, STETH, WSTETH, vault);
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        return ArrayLib.create(asset, erc4626, vault);
     }
 
-    function isValidTokenIn(address token) public view override returns (bool) {
-        return token == NATIVE || token == STETH || token == WSTETH || token == vault;
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == asset || token == erc4626 || token == vault;
     }
 
-    /// @dev returns mellow TVL in WSTETH
+    /// @dev returns mellow TVL in erc4626
     /// @dev reverts if the vault contains more than 1 token
     function _getMellowVaultTvl() internal view returns (uint256 tvl, uint256 supply) {
         (address[] memory tokens, uint256[] memory amounts) = IMellowVault(vault).underlyingTvl();
-        if (tokens.length > 1 || tokens[0] != WSTETH) {
+        if (tokens.length > 1 || tokens[0] != erc4626) {
             revert MellowVaultHasInvalidAssets();
         }
 
         tvl = amounts[0];
         supply = IERC20(vault).totalSupply();
     }
+
+    function assetInfo()
+        external
+        view
+        virtual
+        override
+        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
+    {
+        return (AssetType.TOKEN, asset, IERC20Metadata(asset).decimals());
+    }
 }

package/contracts/core/StandardizedYield/implementations/Mellow/PendleMellowVaultSYBaseUpg.sol

@@ -0,0 +1,119 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "../../SYBaseUpg.sol";
+import "../../StEthHelper.sol";
+import "../../../../interfaces/IPTokenWithSupplyCap.sol";
+import "../../../../interfaces/Mellow/IMellowVault.sol";
+import "../../../../interfaces/Mellow/IMellowVaultConfigurator.sol";
+import "../../../../interfaces/IPPriceFeed.sol";
+
+/// @dev This SY implementation intends to ignore native interest from Mellow Vault's underlying
+contract PendleMellowVaultSYBaseUpg is SYBaseUpg, IPTokenWithSupplyCap {
+    event SetPricingHelper(address newPricingHelper);
+
+    // solhint-disable immutable-vars-naming
+    address public immutable vault;
+    address public immutable configurator;
+    address public pricingHelper;
+
+    constructor(address _vault) SYBaseUpg(_vault) {
+        vault = _vault;
+        configurator = IMellowVault(_vault).configurator();
+        _disableInitializers();
+    }
+
+    function initialize(
+        string memory _name,
+        string memory _symbol,
+        address _pricingHelper
+    ) external virtual initializer {
+        __SYBaseUpg_init(_name, _symbol);
+        _setPricingHelper(_pricingHelper);
+    }
+
+    function _deposit(
+        address /*tokenIn*/,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 amountSharesOut) {
+        return amountDeposited;
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256) {
+        _transferOut(vault, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    function exchangeRate() public view virtual override returns (uint256 res) {
+        return PMath.ONE;
+    }
+
+    function _previewDeposit(
+        address /*tokenIn*/,
+        uint256 amountTokenToDeposit
+    ) internal view virtual override returns (uint256 /*amountSharesOut*/) {
+        return amountTokenToDeposit;
+    }
+
+    function _previewRedeem(
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal view virtual override returns (uint256 /*amountTokenOut*/) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        return ArrayLib.create(vault);
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        return ArrayLib.create(vault);
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == vault;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == vault;
+    }
+
+    function assetInfo()
+        external
+        view
+        virtual
+        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
+    {
+        return (AssetType.TOKEN, vault, IERC20Metadata(vault).decimals());
+    }
+
+    function getAbsoluteSupplyCap() external view virtual returns (uint256) {
+        return IMellowVaultConfigurator(configurator).maximalTotalSupply();
+    }
+
+    function getAbsoluteTotalSupply() external view virtual returns (uint256) {
+        return IERC20(vault).totalSupply();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                        OFF-CHAIN USAGE ONLY
+            (NO SECURITY RELATED && CAN BE LEFT UNAUDITED)
+    //////////////////////////////////////////////////////////////*/
+
+    function setPricingHelper(address _pricingHelper) external onlyOwner {
+        _setPricingHelper(_pricingHelper);
+    }
+
+    function _setPricingHelper(address _pricingHelper) internal {
+        pricingHelper = _pricingHelper;
+        emit SetPricingHelper(_pricingHelper);
+    }
+
+    function getPrice() external view returns (uint256) {
+        return IPPriceFeed(pricingHelper).getPrice();
+    }
+}