@pendle/core-v2 0.16.5-testnet → 0.17.0-daily

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

@@ -0,0 +1,128 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../SYBase.sol";
+import "../../../interfaces/ILooksFeeSharing.sol";
+import "../../../interfaces/ILooksStaking.sol";
+
+contract PendleLooksStakingSY is SYBase {
+    using Math for uint256;
+
+    address public immutable looks;
+    address public immutable stakingContract;
+    address public immutable feeSharingContract;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _looks,
+        address _stakingContract,
+        address _feeSharingContract
+    ) SYBase(_name, _symbol, _looks) {
+        looks = _looks;
+        stakingContract = _stakingContract;
+        feeSharingContract = _feeSharingContract;
+
+        _safeApproveInf(_looks, _stakingContract);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address, uint256 amountDeposited)
+        internal
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
+        uint256 previousShare = ILooksStaking(stakingContract).userInfo(address(this));
+        ILooksStaking(stakingContract).deposit(amountDeposited);
+        amountSharesOut = ILooksStaking(stakingContract).userInfo(address(this)) - previousShare;
+    }
+
+    function _redeem(
+        address receiver,
+        address,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 amountTokenOut) {
+        uint256 previousBalance = _selfBalance(looks);
+        ILooksStaking(stakingContract).withdraw(amountSharesToRedeem);
+        amountTokenOut = _selfBalance(looks) - previousBalance;
+        _transferOut(looks, receiver, amountTokenOut);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        (uint256 totalShares, uint256 totalLooks) = _getLooksStakingParams();
+        return totalLooks.divDown(totalShares);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(address, uint256 amountTokenToDeposit)
+        internal
+        view
+        override
+        returns (uint256 amountSharesOut)
+    {
+        (uint256 totalShares, uint256 totalLooks) = _getLooksStakingParams();
+        amountSharesOut = (amountTokenToDeposit * totalShares) / totalLooks;
+    }
+
+    function _previewRedeem(address, uint256 amountSharesToRedeem)
+        internal
+        view
+        override
+        returns (uint256 amountTokenOut)
+    {
+        (uint256 totalShares, uint256 totalLooks) = _getLooksStakingParams();
+        amountTokenOut = (amountSharesToRedeem * totalLooks) / totalShares;
+    }
+
+    function _getLooksStakingParams()
+        private
+        view
+        returns (uint256 totalShares, uint256 totalLooks)
+    {
+        totalShares = ILooksStaking(stakingContract).totalShares();
+        totalLooks = ILooksFeeSharing(feeSharingContract).calculateSharesValueInLOOKS(
+            stakingContract
+        );
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = looks;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = looks;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == looks;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == looks;
+    }
+
+    function assetInfo()
+        external
+        view
+        returns (
+            AssetType assetType,
+            address assetAddress,
+            uint8 assetDecimals
+        )
+    {
+        return (AssetType.TOKEN, looks, IERC20Metadata(looks).decimals());
+    }
+}

package/contracts/core/YieldContracts/PendlePrincipalToken.sol

@@ -9,7 +9,7 @@ import "../libraries/Errors.sol";
 
 import "../erc20/PendleERC20Permit.sol";
 
-import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 
 contract PendlePrincipalToken is PendleERC20Permit, Initializable, IPPrincipalToken {
     address public immutable SY;
@@ -22,7 +22,7 @@ contract PendlePrincipalToken is PendleERC20Permit, Initializable, IPPrincipalTo
         _;
     }
 
-    modifier onlYieldFactory() {
+    modifier onlyYieldFactory() {
         if (msg.sender != factory) revert Errors.OnlyYCFactory();
         _;
     }
@@ -39,7 +39,7 @@ contract PendlePrincipalToken is PendleERC20Permit, Initializable, IPPrincipalTo
         factory = msg.sender;
     }
 
-    function initialize(address _YT) external initializer onlYieldFactory {
+    function initialize(address _YT) external initializer onlyYieldFactory {
         YT = _YT;
     }
 

package/contracts/core/YieldContracts/PendleYieldContractFactory.sol

@@ -46,7 +46,8 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContract
 
     string private constant PT_PREFIX = "PT";
     string private constant YT_PREFIX = "YT";
-    string private constant SY_PREF = "SY-";
+    string private constant SY_SYMBOL_PREF = "SY-";
+    string private constant SY_NAME_PREF = "SY ";
 
     address public immutable ytCreationCodeContractA;
     uint256 public immutable ytCreationCodeSizeA;
@@ -62,11 +63,15 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContract
     uint96 public expiryDivisor;
 
     // SY => expiry => address
+    // returns address(0) if not created
     mapping(address => mapping(uint256 => address)) public getPT;
     mapping(address => mapping(uint256 => address)) public getYT;
     mapping(address => bool) public isPT;
     mapping(address => bool) public isYT;
 
+    uint256 public constant maxInterestFeeRate = 2e17; // 20%
+    uint256 public constant maxRewardFeeRate = 2e17; // 20%
+
     constructor(
         address _ytCreationCodeContractA,
         uint256 _ytCreationCodeSizeA,
@@ -96,10 +101,11 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContract
      * @notice Create a pair of (PT, YT) from any SY and valid expiry. Anyone can create a yield contract
      * @dev It's intentional to make expiry an uint32 to guard against fat fingers. uint32.max is year 2106
      */
-    function createYieldContract(address SY, uint32 expiry)
-        external
-        returns (address PT, address YT)
-    {
+    function createYieldContract(
+        address SY,
+        uint32 expiry,
+        bool doCacheIndexSameBlock
+    ) external returns (address PT, address YT) {
         if (MiniHelpers.isTimeInThePast(expiry) || expiry % expiryDivisor != 0)
             revert Errors.YCFactoryInvalidExpiry();
 
@@ -136,7 +142,8 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContract
                 YT_PREFIX.concat(syCoreName, expiry, " "),
                 YT_PREFIX.concat(syCoreSymbol, expiry, "-"),
                 assetDecimals,
-                expiry
+                expiry,
+                doCacheIndexSameBlock
             ),
             ytCreationCodeContractA,
             ytCreationCodeSizeA,
@@ -151,32 +158,43 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContract
         isPT[PT] = true;
         isYT[YT] = true;
 
-        emit CreateYieldContract(SY, PT, YT, expiry);
+        emit CreateYieldContract(SY, expiry, PT, YT);
     }
 
     function setExpiryDivisor(uint96 newExpiryDivisor) public onlyOwner {
+        if (newExpiryDivisor == 0) revert Errors.YCFactoryZeroExpiryDivisor();
+
         expiryDivisor = newExpiryDivisor;
         emit SetExpiryDivisor(newExpiryDivisor);
     }
 
     function setInterestFeeRate(uint128 newInterestFeeRate) public onlyOwner {
+        if (newInterestFeeRate > maxInterestFeeRate)
+            revert Errors.YCFactoryInterestFeeRateTooHigh(newInterestFeeRate, maxInterestFeeRate);
+
         interestFeeRate = newInterestFeeRate;
         emit SetInterestFeeRate(newInterestFeeRate);
     }
 
-    function setRewardFeeRate(uint128 newInterestFeeRate) public onlyOwner {
-        rewardFeeRate = newInterestFeeRate;
-        emit SetInterestFeeRate(newInterestFeeRate);
+    function setRewardFeeRate(uint128 newRewardFeeRate) public onlyOwner {
+        if (newRewardFeeRate > maxRewardFeeRate)
+            revert Errors.YCFactoryRewardFeeRateTooHigh(newRewardFeeRate, maxRewardFeeRate);
+
+        rewardFeeRate = newRewardFeeRate;
+        emit SetRewardFeeRate(newRewardFeeRate);
     }
 
     function setTreasury(address newTreasury) public onlyOwner {
+        if (newTreasury == address(0)) revert Errors.YCFactoryZeroTreasury();
+
         treasury = newTreasury;
         emit SetTreasury(newTreasury);
     }
 
     function _stripSYPrefix(string memory _str) internal pure returns (string memory) {
         StringLib.slice memory str = _str.toSlice();
-        StringLib.slice memory delim = SY_PREF.toSlice();
-        return str.beyond(delim).toString();
+        StringLib.slice memory delim_name = SY_NAME_PREF.toSlice();
+        StringLib.slice memory delim_symbol = SY_SYMBOL_PREF.toSlice();
+        return str.beyond(delim_name).beyond(delim_symbol).toString();
     }
 }

package/contracts/core/YieldContracts/PendleYieldToken.sol

@@ -45,7 +45,11 @@ contract PendleYieldToken is
     address public immutable factory;
     uint256 public immutable expiry;
 
-    uint128 public syReserve;
+    bool public immutable doCacheIndexSameBlock;
+
+    uint256 public syReserve;
+
+    uint128 public pyIndexLastUpdatedBlock;
     uint128 internal _pyIndexStored;
 
     PostExpiryData public postExpiry;
@@ -61,21 +65,31 @@ contract PendleYieldToken is
         _;
     }
 
+    /**
+     * @param _doCacheIndexSameBlock if true, the PY index is cached for each block, and thus is 
+     * constant for all txs within the same block. Otherwise, the PY index is recalculated for 
+     * every tx.
+     */
     constructor(
         address _SY,
         address _PT,
         string memory _name,
         string memory _symbol,
         uint8 __decimals,
-        uint256 _expiry
+        uint256 _expiry,
+        bool _doCacheIndexSameBlock
     ) PendleERC20Permit(_name, _symbol, __decimals) {
         SY = _SY;
         PT = _PT;
         expiry = _expiry;
         factory = msg.sender;
+        doCacheIndexSameBlock = _doCacheIndexSameBlock;
     }
 
-    /// @notice Tokenize SY into PT + YT of equal qty. Every unit of underlying of SY will create 1 PT + 1 YT
+    /**
+     * @notice Tokenize SY into PT + YT of equal qty. Every unit of asset of SY will create 1 PT + 1 YT
+     * @dev SY must be transferred to this contract prior to calling
+     */
     function mintPY(address receiverPT, address receiverYT)
         external
         nonReentrant
@@ -97,7 +111,7 @@ contract PendleYieldToken is
         amountPYOut = amountPYOuts[0];
     }
 
-    /// @notice Tokenize SY into PT + YT of equal qty. Every unit of underlying of SY will create 1 PT + 1 YT
+    /// @notice Tokenize SY into PT + YT for multiple receivers. See `mintPY()` for more details
     function mintPYMulti(
         address[] calldata receiverPTs,
         address[] calldata receiverYTs,
@@ -116,7 +130,11 @@ contract PendleYieldToken is
         amountPYOuts = _mintPY(receiverPTs, receiverYTs, amountSyToMints);
     }
 
-    /// @dev this function converts PY tokens into sy, but interests & rewards are not redeemed at the same time
+    /**
+     * @notice converts PT(+YT) tokens into SY, but interests & rewards are not redeemed at the 
+     * same time
+     * @dev PT/YT must be transferred to this contract prior to calling
+     */
     function redeemPY(address receiver)
         external
         nonReentrant
@@ -133,9 +151,11 @@ contract PendleYieldToken is
         amountSyOut = amountSyOuts[0];
     }
 
-    /// @dev this function limit how much each receiver will receive. For example, if the totalOut is 100,
-    /// and the max are 50 30 INF, the first receiver will receive 50, the second will receive 30, and the third will receive 20.
-    /// @dev intended to mostly be used by Pendle router
+    /**
+     * @notice redeems PT(+YT) for multiple users. See `redeemPY()`
+     * @dev PT/YT must be transferred to this contract prior to calling
+     * @dev fails if unable to redeem the total PY amount in `amountPYToRedeems`
+     */
     function redeemPYMulti(address[] calldata receivers, uint256[] calldata amountPYToRedeems)
         external
         nonReentrant
@@ -148,12 +168,15 @@ contract PendleYieldToken is
     }
 
     /**
-    * @dev With YT yielding interest in the form of SY, which is redeemable by users, the reward
-    distribution should be based on the amount of SYs that their YT currently represent, plus their
-    dueInterest. It has been proven and tested that _rewardSharesUser will not change over time,
-    unless users redeem their dueInterest or redeemPY. Due to this, it is required to update users'
-    accruedReward STRICTLY BEFORE transferring out their interest.
-    */
+     * @notice Redeems interests and rewards for `user`
+     * @param redeemInterest will only transfer out interest for user if true
+     * @param redeemRewards will only transfer out rewards for user if true
+     * @dev With YT yielding interest in the form of SY, which is redeemable by users, the reward
+     * distribution should be based on the amount of SYs that their YT currently represent, plus 
+     * their dueInterest. It has been proven and tested that _rewardSharesUser will not change over 
+     * time, unless users redeem their dueInterest or redeemPY. Due to this, it is required to 
+     * update users' accruedReward STRICTLY BEFORE transferring out their interest.
+     */
     function redeemDueInterestAndRewards(
         address user,
         bool redeemInterest,
@@ -182,6 +205,10 @@ contract PendleYieldToken is
         }
     }
 
+    /**
+     * @dev All rewards and interests accrued post-expiry goes to the treasury.
+     * Reverts if called pre-expiry.
+     */
     function redeemInterestAndRewardsPostExpiryForTreasury()
         external
         nonReentrant
@@ -208,21 +235,46 @@ contract PendleYieldToken is
         _transferOut(SY, treasury, interestOut);
     }
 
+    /// @notice updates and returns the reward indexes
     function rewardIndexesCurrent() external override nonReentrant returns (uint256[] memory) {
         return IStandardizedYield(SY).rewardIndexesCurrent();
     }
 
-    /// @dev maximize the current rate with the previous rate to guarantee non-decreasing rate
+    /**
+     * @notice updates and returns the current PY index
+     * @dev this function maximizes the current PY index with the previous index, guaranteeing
+     * non-decreasing PY index
+     * @dev if `doCacheIndexSameBlock` is true, PY index only updates at most once per block,
+     * and has no state changes on the second call onwards (within the same block).
+     * @dev see `pyIndexStored()` for view function for cached value.
+     */
     function pyIndexCurrent() public nonReentrant returns (uint256 currentIndex) {
         currentIndex = _pyIndexCurrent();
     }
 
+    /// @notice returns the last-updated PY index
+    function pyIndexStored() public view returns (uint256) {
+        return _pyIndexStored;
+    }
+
+    /**
+     * @notice do a final rewards redeeming, and sets post-expiry data
+     * @dev has no effect if called pre-expiry
+     */
     function setPostExpiryData() external nonReentrant {
         if (isExpired()) {
             _setPostExpiryData();
         }
     }
 
+    /**
+     * @notice returns the current data post-expiry, if exists
+     * @dev reverts if post-expiry data not set (see `setPostExpiryData()`)
+     * @return firstPYIndex the earliest PY index post-expiry
+     * @return totalSyInterestForTreasury current amount of SY interests post-expiry for treasury
+     * @return firstRewardIndexes the earliest reward indices post-expiry, for each reward token
+     * @return userRewardOwed amount of unclaimed user rewards, for each reward token
+     */
     function getPostExpiryData()
         external
         view
@@ -273,10 +325,6 @@ contract PendleYieldToken is
         }
     }
 
-    function pyIndexStored() public view returns (uint256) {
-        return _pyIndexStored;
-    }
-
     function isExpired() public view returns (bool) {
         return MiniHelpers.isCurrentlyExpired(expiry);
     }
@@ -336,7 +384,7 @@ contract PendleYieldToken is
     }
 
     function _updateSyReserve() internal virtual {
-        syReserve = _selfBalance(SY).Uint128();
+        syReserve = _selfBalance(SY);
     }
 
     function _getFloatingSyAmount() internal view returns (uint256 amount) {
@@ -369,8 +417,17 @@ contract PendleYieldToken is
     }
 
     function _pyIndexCurrent() internal returns (uint256 currentIndex) {
-        currentIndex = Math.max(IStandardizedYield(SY).exchangeRate(), _pyIndexStored);
-        _pyIndexStored = currentIndex.Uint128();
+        if (doCacheIndexSameBlock && pyIndexLastUpdatedBlock == block.number)
+            return _pyIndexStored;
+
+        uint128 index128 = Math
+            .max(IStandardizedYield(SY).exchangeRate(), _pyIndexStored)
+            .Uint128();
+
+        currentIndex = index128;
+        _pyIndexStored = index128;
+        pyIndexLastUpdatedBlock = uint128(block.number);
+
         emit NewInterestIndex(currentIndex);
     }
 

package/contracts/core/erc20/PendleERC20.sol

@@ -13,7 +13,7 @@ import "@openzeppelin/contracts/utils/Context.sol";
  * - comes with built-in reentrancy protection, storage-packed with totalSupply variable
  * - delete increaseAllowance / decreaseAllowance
  * - add nonReentrancy protection to transfer / transferFrom functions
- * - allow decimals to by passed in
+ * - allow decimals to be passed in
  * - block self-transfer by default
  */
 // solhint-disable
@@ -26,7 +26,7 @@ contract PendleERC20 is Context, IERC20, IERC20Metadata {
     mapping(address => mapping(address => uint256)) private _allowances;
 
     uint248 private _totalSupply;
-    uint8 private _status;
+    uint8 private _status; 
 
     string private _name;
     string private _symbol;
@@ -54,12 +54,9 @@ contract PendleERC20 is Context, IERC20, IERC20Metadata {
     }
 
     /**
-     * @dev Sets the values for {name} and {symbol}.
+     * @dev Sets the values for {name}, {symbol} and {decimals}.
      *
-     * The default value of {decimals} is 18. To select a different value for
-     * {decimals} you should overload it.
-     *
-     * All two of these values are immutable: they can only be set once during
+     * All three of these values are immutable: they can only be set once during
      * construction.
      */
     constructor(

package/contracts/core/libraries/BaseSplitCodeFactory.sol

@@ -164,7 +164,7 @@ library BaseSplitCodeFactory {
         uint256 creationCodeSizeA,
         address creationCodeContractB,
         uint256 creationCodeSizeB
-    ) public view returns (bytes memory) {
+    ) internal view returns (bytes memory) {
         return
             _getCreationCodeWithArgs(
                 "",

package/contracts/core/libraries/BoringOwnableUpgradeable.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity 0.8.17;
 
-import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 
 contract BoringOwnableUpgradeableData {
     address public owner;

package/contracts/core/libraries/Errors.sol

@@ -21,6 +21,12 @@ library Errors {
     // APPROX
     error ApproxFail();
     error ApproxParamsInvalid(uint256 guessMin, uint256 guessMax, uint256 eps);
+    error ApproxBinarySearchInputInvalid(
+        uint256 approxGuessMin,
+        uint256 approxGuessMax,
+        uint256 minGuessMin,
+        uint256 maxGuessMax
+    );
 
     // MARKET + MARKET MATH CORE
     error MarketExpired();
@@ -45,8 +51,13 @@ library Errors {
     error MarketFactoryInvalidPt();
     error MarketFactoryMarketExists();
 
-    error MFactoryLnFeeRateRootTooHigh(uint88 lnFeeRateRoot, uint256 maxLnFeeRateRoot);
-    error MFactoryReserveFeePercentTooHigh(uint8 reserveFeePercent, uint8 maxReserveFeePercent);
+    error MarketFactoryLnFeeRateRootTooHigh(uint80 lnFeeRateRoot, uint256 maxLnFeeRateRoot);
+    error MarketFactoryReserveFeePercentTooHigh(
+        uint8 reserveFeePercent,
+        uint8 maxReserveFeePercent
+    );
+    error MarketFactoryZeroTreasury();
+    error MarketFactoryInitialAnchorTooLow(int256 initialAnchor, int256 minInitialAnchor);
 
     // ROUTER
     error RouterInsufficientLpOut(uint256 actualLpOut, uint256 requiredLpOut);
@@ -79,6 +90,10 @@ library Errors {
     // YieldFactory
     error YCFactoryInvalidExpiry();
     error YCFactoryYieldContractExisted();
+    error YCFactoryZeroExpiryDivisor();
+    error YCFactoryZeroTreasury();
+    error YCFactoryInterestFeeRateTooHigh(uint256 interestFeeRate, uint256 maxInterestFeeRate);
+    error YCFactoryRewardFeeRateTooHigh(uint256 newRewardFeeRate, uint256 maxRewardFeeRate);
 
     // SY
     error SYInvalidTokenIn(address token);
@@ -113,6 +128,7 @@ library Errors {
     error VEPositionNotExpired();
     error VEZeroPosition();
     error VEZeroSlope(uint128 bias, uint128 slope);
+    error VEReceiveOldSupply(uint256 msgTime);
 
     error GCNotPendleMarket(address caller);
     error GCNotVotingController(address caller);

package/contracts/interfaces/ConvexCurve/IBooster.sol

@@ -10,7 +10,7 @@ interface IBooster {
         external
         view
         returns (
-            address,
+            address lpToken,
             address,
             address,
             address,

package/contracts/interfaces/Curve/ICrvPool.sol

@@ -22,20 +22,19 @@ interface ICrvPool {
         int128 i,
         int128 j,
         uint256 dx,
-        uint256 min_dy, // The amount of i being exchanged.
-        address _receiver
+        uint256 min_dy // The amount of i being exchanged.
     ) external returns (uint256);
 
     function add_liquidity(
         uint256[2] memory _deposit_amount,
         uint256 _min_amount
-    ) external;
+    ) external returns (uint256 lpOut);
 
     function remove_liquidity_one_coin(
         uint256 _burn_amount,
         int128 i,
         uint256 _min_amount
-    ) external;
+    ) external returns (uint256 tokenOut);
 
     function calc_token_amount(uint256[2] memory _amounts, bool _is_deposit)
         external

package/contracts/interfaces/Curve/ITriCrvPool.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface ITriCrvPool {
+    function coins(uint256 i) external view returns (address);
+
+    function get_virtual_price() external view returns (uint256);
+
+    function lp_token() external view returns (address);
+
+    function fee() external view returns (uint256);
+
+    function admin_fee() external view returns (uint256);
+
+    function exchange(
+        int128 i,
+        int128 j,
+        uint256 dx,
+        uint256 min_dy // The amount of i being exchanged.
+    ) external returns (uint256);
+
+    function add_liquidity(
+        uint256[3] memory _deposit_amount,
+        uint256 _min_amount
+    ) external;
+
+    function remove_liquidity_one_coin(
+        uint256 _burn_amount,
+        int128 i,
+        uint256 _min_amount
+    ) external;
+
+    function calc_withdraw_one_coin(uint256 _burn_amount, int128 i)
+        external
+        view
+        returns (uint256);
+
+    function balances(uint256 i) external view returns (uint256);
+
+    function A() external view returns (uint256);
+}

package/contracts/interfaces/IERC4626.sol

@@ -30,7 +30,7 @@ interface IERC4626 is IERC20Metadata {
     function deposit(uint256 assets, address receiver) external returns (uint256);
 
     function redeem(
-        uint256 assets,
+        uint256 shares,
         address receiver,
         address owner
     ) external returns (uint256);

package/contracts/interfaces/ILooksFeeSharing.sol

@@ -0,0 +1,5 @@
+pragma solidity 0.8.17;
+
+interface ILooksFeeSharing {
+    function calculateSharesValueInLOOKS(address user) external view returns (uint256);
+}

package/contracts/interfaces/ILooksStaking.sol

@@ -0,0 +1,13 @@
+pragma solidity 0.8.17;
+
+interface ILooksStaking {
+    function totalShares() external view returns (uint256);
+
+    function deposit(uint256 amount) external;
+
+    function userInfo(address user) external view returns (uint256);
+
+    function withdraw(uint256 shares) external;
+
+    function harvestAndSellAndCompound() external;
+}