@pendle/core-v2 0.16.6-testnet → 0.17.0-testnet

package/contracts/core/StandardizedYield/implementations/Convex/README.md

@@ -0,0 +1,29 @@
+# PENDLE Curve/Convex SY 
+
+For the simplicity of the writeup, we will describe only the noticable properties of `PendleCurveUSDD3CrvSY`. `PendleCurveFraxUsdcSY` contract should contain only a subset of those properties compared to USDD one.
+
+## Token in/out flow
+
+We support USDD/USDC/DAI/USDT and the two LPs as in and out tokens. Tokens after being deposited to Curve to get back LP USDD/3Crv will be staked into Convex reward system to gain rewards of:
+
+- USDD
+- CRV
+- CVX
+
+![](https://i.ibb.co/9rgWfvg/curve.png)
+
+## Exchange Rate
+
+Asset type for this SY should be in type of Liquidity. For exchange rate, we use Curve's `pool.get_virtual_price()` as it shows the growth in price of LP token respecting to the swap fees earned by the pool.
+
+## Preview functions
+
+Before getting to this, we would like to note that preview functions will play an important role in Pendle's off-chain system. Hence, it is essential for preview function returns the actual outcome that user can get by calling `deposit/redeem`.
+
+For preview redeem, Curve provides a view function of `calc_withdraw_one_coin` which accurately returns the amount of token can be redeem by user with a particular amount of LP.
+
+For previde deposit, Curve's provided function `calc_token_amount` does not take into account the fee, thus, it does not return the actual amount of lp token user can get. 
+
+We implemented a workaround for previewDeposit in `CurveUsdd3CrvPoolHelper` and `Curve3CrvPoolHelper` to simulate the calculation happened in Curve's code base. 
+
+Another thing to note is that `CurveUsdd3CrvPoolHelper`'s preivew deposit result has a dependency on the `3crv.get_virtual_price`. So the simulation should also take into account the case when user deposits with DAI/USDC/USDT, the state of 3Crv pool changes, and thus the `get_virtual_price` of 3crv changes.

package/contracts/core/StandardizedYield/implementations/Convex/base/Curve3CrvPoolHelper.sol

@@ -0,0 +1,215 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../../../libraries/math/Math.sol";
+import "../../../../../interfaces/Curve/ITriCrvPool.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+library Curve3CrvPoolHelper {
+    using Math for uint256;
+
+    uint256 internal constant N_COINS = 3;
+    uint256 internal constant PRECISION = 10**18;
+    uint256 internal constant RATE_0 = 1000000000000000000;
+    uint256 internal constant RATE_1 = 1000000000000000000000000000000;
+    uint256 internal constant RATE_2 = 1000000000000000000000000000000;
+    uint256 internal constant FEE_DENOMINATOR = 10**10;
+
+    address internal constant LP = 0x6c3F90f043a72FA612cbac8115EE7e52BDe6E490;
+    address internal constant POOL = 0xbEbc44782C7dB0a1A60Cb6fe97d0b483032FF1C7;
+    address internal constant DAI = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
+    address internal constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
+    address internal constant USDT = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
+
+    // previewDeposit at the end of the file
+
+    function preview3CrvRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        view
+        returns (uint256)
+    {
+        return
+            ITriCrvPool(POOL).calc_withdraw_one_coin(
+                amountSharesToRedeem,
+                _get3CrvTokenIndex(tokenOut).Int128()
+            );
+    }
+
+    function deposit3Crv(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        returns (uint256)
+    {
+        uint256 balBefore = IERC20(LP).balanceOf(address(this));
+        ITriCrvPool(POOL).add_liquidity(_getTokenAmounts(tokenIn, amountTokenToDeposit), 0);
+        uint256 balAfter = IERC20(LP).balanceOf(address(this));
+        return balAfter - balBefore;
+    }
+
+    function redeem3Crv(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        returns (uint256)
+    {
+        uint256 balBefore = IERC20(tokenOut).balanceOf(address(this));
+        ITriCrvPool(POOL).remove_liquidity_one_coin(
+            amountSharesToRedeem,
+            _get3CrvTokenIndex(tokenOut).Int128(),
+            0
+        );
+        uint256 balAfter = IERC20(tokenOut).balanceOf(address(this));
+        return balAfter - balBefore;
+    }
+
+    function _getTokenAmounts(address token, uint256 amount)
+        internal
+        pure
+        returns (uint256[N_COINS] memory res)
+    {
+        res[_get3CrvTokenIndex(token)] = amount;
+    }
+
+    function _get3CrvTokenIndex(address token) internal pure returns (uint256) {
+        if (token == DAI) return 0;
+        if (token == USDC) return 1;
+        if (token == USDT) return 2;
+        revert("Pendle3CrvHelper: not valid token");
+    }
+
+    function is3CrvToken(address token) internal pure returns (bool) {
+        return (token == DAI || token == USDC || token == USDT);
+    }
+
+    function get_virtual_price() internal view returns (uint256) {
+        return ITriCrvPool(POOL).get_virtual_price();
+    }
+
+    // ----------------- Forking StableSwap3Pool's calculation -----------------
+
+    // fork of StableSwap3Pool.vy
+    function preview3CrvDeposit(address token, uint256 amount)
+        internal
+        view
+        returns (uint256 netLpOut, uint256 new_virtual_price)
+    {
+        uint256[N_COINS] memory amounts = _getTokenAmounts(token, amount);
+        uint256[N_COINS] memory self_balances = _getBalances();
+
+        uint256[N_COINS] memory fees;
+        uint256 _fee = (ITriCrvPool(POOL).fee() * N_COINS) / (4 * (N_COINS - 1));
+        uint256 _admin_fee = ITriCrvPool(POOL).admin_fee();
+        uint256 amp = ITriCrvPool(POOL).A();
+
+        uint256 token_supply = IERC20(LP).totalSupply();
+        // Initial invariant
+        uint256 D0 = 0;
+        uint256[N_COINS] memory old_balances = arrayClone(self_balances);
+        D0 = get_D_mem(old_balances, amp);
+
+        uint256[N_COINS] memory new_balances = arrayClone(old_balances);
+
+        for (uint256 i = 0; i < N_COINS; ++i) {
+            new_balances[i] += amounts[i];
+        }
+
+        uint256 D1 = get_D_mem(new_balances, amp);
+        assert(D1 > D0);
+
+        // We need to recalculate the invariant accounting for fees
+        // to calculate fair user's share
+        uint256 D2 = D1;
+        for (uint256 i = 0; i < N_COINS; ++i) {
+            uint256 ideal_balance = (D1 * old_balances[i]) / D0;
+            uint256 difference = 0;
+            if (ideal_balance > new_balances[i]) {
+                difference = ideal_balance - new_balances[i];
+            } else {
+                difference = new_balances[i] - ideal_balance;
+            }
+            fees[i] = (_fee * difference) / FEE_DENOMINATOR;
+            self_balances[i] = new_balances[i] - ((fees[i] * _admin_fee) / FEE_DENOMINATOR);
+            new_balances[i] -= fees[i];
+            D2 = get_D_mem(new_balances, amp);
+        }
+
+        netLpOut = (token_supply * (D2 - D0)) / D0;
+        new_virtual_price = _get_virtual_price_with_balances(
+            self_balances,
+            token_supply + netLpOut
+        );
+    }
+
+    function _get_virtual_price_with_balances(
+        uint256[N_COINS] memory balances,
+        uint256 token_supply
+    ) internal view returns (uint256) {
+        uint256 amp = ITriCrvPool(POOL).A();
+        uint256 D = get_D_mem(balances, amp);
+        return (D * PRECISION) / token_supply;
+    }
+
+    function get_D_mem(uint256[N_COINS] memory balances, uint256 amp)
+        internal
+        pure
+        returns (uint256)
+    {
+        return get_D(_xp_mem(balances), amp);
+    }
+
+    function _xp_mem(uint256[N_COINS] memory balances)
+        internal
+        pure
+        returns (uint256[N_COINS] memory)
+    {
+        uint256[N_COINS] memory result;
+        result[0] = (RATE_0 * balances[0]) / PRECISION;
+        result[1] = (RATE_1 * balances[1]) / PRECISION;
+        result[2] = (RATE_2 * balances[2]) / PRECISION;
+
+        return result;
+    }
+
+    function get_D(uint256[N_COINS] memory _xp, uint256 _amp) internal pure returns (uint256) {
+        uint256 S = 0;
+        for (uint256 k = 0; k < N_COINS; ++k) S += _xp[k];
+        if (S == 0) return 0;
+
+        uint256 Dprev = 0;
+        uint256 D = S;
+        uint256 Ann = _amp * N_COINS;
+
+        for (uint256 _i = 0; _i < 255; ++_i) {
+            uint256 D_P = D;
+            for (uint256 k = 0; k < N_COINS; ++k) {
+                D_P = (D_P * D) / (_xp[k] * N_COINS);
+            }
+            Dprev = D;
+            D = ((Ann * S + D_P * N_COINS) * D) / (((Ann - 1) * D) + (N_COINS + 1) * D_P);
+
+            if (D > Dprev) {
+                if (D - Dprev <= 1) {
+                    break;
+                }
+            } else {
+                if (Dprev - D <= 1) {
+                    break;
+                }
+            }
+        }
+        return D;
+    }
+
+    function _getBalances() internal view returns (uint256[N_COINS] memory balances) {
+        balances[0] = ITriCrvPool(POOL).balances(0);
+        balances[1] = ITriCrvPool(POOL).balances(1);
+        balances[2] = ITriCrvPool(POOL).balances(2);
+    }
+
+    function arrayClone(uint256[N_COINS] memory a)
+        internal
+        pure
+        returns (uint256[N_COINS] memory res)
+    {
+        for (uint256 i = 0; i < N_COINS; ++i) {
+            res[i] = a[i];
+        }
+    }
+}

package/contracts/core/StandardizedYield/implementations/Convex/base/CurveFraxUsdcPoolHelper.sol

@@ -6,43 +6,44 @@ import "../../../../../interfaces/Curve/ICrvPool.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
 library CurveFraxUsdcPoolHelper {
-    uint256 public constant N_COINS = 2;
-    uint256 public constant A_PRECISION = 100;
-    uint256 public constant PRECISION = 10 ** 18;
-    uint256 public constant RATE_0 = 1000000000000000000;
-    uint256 public constant RATE_1 = 1000000000000000000000000000000;
-    uint256 public constant FEE_DENOMINATOR = 10 ** 10;
+    uint256 internal constant N_COINS = 2;
+    uint256 internal constant A_PRECISION = 100;
+    uint256 internal constant PRECISION = 10**18;
+    uint256 internal constant RATE_0 = 1000000000000000000;
+    uint256 internal constant RATE_1 = 1000000000000000000000000000000;
+    uint256 internal constant FEE_DENOMINATOR = 10**10;
+
+    address internal constant POOL = 0xDcEF968d416a41Cdac0ED8702fAC8128A64241A2;
+    address internal constant LP = 0x3175Df0976dFA876431C2E9eE6Bc45b65d3473CC;
+    address internal constant FRAX = 0x853d955aCEf822Db058eb8505911ED77F175b99e;
+    address internal constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
 
     using Math for uint256;
 
-    function previewAddLiquidity(address pool, uint256[N_COINS] memory _amounts) internal view returns (uint256) {
-        uint256 amp = ICrvPool(pool).A_precise();
-        uint256[N_COINS] memory old_balances;
-        old_balances[0] = ICrvPool(pool).balances(0);
-        old_balances[1] = ICrvPool(pool).balances(1);
-        uint256 D0 = _get_D_mem(old_balances, amp);
-        
-        address lp_token = ICrvPool(pool).lp_token();
-        uint256 total_supply = IERC20(lp_token).totalSupply();
-
+    function previewAddLiquidity(address token, uint256 amount) internal view returns (uint256) {
+        uint256 amp = ICrvPool(POOL).A_precise();
+        uint256[N_COINS] memory _amounts = _getTokenAmounts(token, amount);
+        uint256[N_COINS] memory old_balances = _getBalances();
         uint256[N_COINS] memory new_balances;
-        new_balances[0] = old_balances[0];
-        new_balances[1] = old_balances[1];
+        memcpy(new_balances, old_balances);
+
+        uint256 D0 = _get_D_mem(old_balances, amp);
+        uint256 total_supply = IERC20(LP).totalSupply();
 
-        for(uint256 i = 0; i < N_COINS; ++i) {
+        for (uint256 i = 0; i < N_COINS; ++i) {
             // skip totalSupply = 0 check
             new_balances[i] += _amounts[i];
         }
 
         uint256 D1 = _get_D_mem(new_balances, amp);
-        assert (D1 > D0);
+        assert(D1 > D0);
 
         uint256[N_COINS] memory fees;
 
         // skip total_supply > 0 check
-        uint256 fee = ICrvPool(pool).fee() * N_COINS / (4 * (N_COINS - 1));
+        uint256 fee = (ICrvPool(POOL).fee() * N_COINS) / (4 * (N_COINS - 1));
         for (uint256 i = 0; i < N_COINS; ++i) {
-            uint256 ideal_balance = D1 * old_balances[i] / D0;
+            uint256 ideal_balance = (D1 * old_balances[i]) / D0;
             uint256 difference = 0;
             uint256 new_balance = new_balances[i];
 
@@ -51,11 +52,11 @@ library CurveFraxUsdcPoolHelper {
             } else {
                 difference = new_balance - ideal_balance;
             }
-            fees[i] = fee * difference / FEE_DENOMINATOR;
+            fees[i] = (fee * difference) / FEE_DENOMINATOR;
             new_balances[i] -= fees[i];
         }
         uint256 D2 = _get_D_mem(new_balances, amp);
-        return total_supply * (D2 - D0) / D0;
+        return (total_supply * (D2 - D0)) / D0;
     }
 
     function _get_D_mem(uint256[N_COINS] memory balances, uint256 _amp)
@@ -64,8 +65,8 @@ library CurveFraxUsdcPoolHelper {
         returns (uint256)
     {
         uint256[N_COINS] memory _xp;
-        _xp[0] = RATE_0 * balances[0] / PRECISION;
-        _xp[1] = RATE_1 * balances[1] / PRECISION;
+        _xp[0] = (RATE_0 * balances[0]) / PRECISION;
+        _xp[1] = (RATE_1 * balances[1]) / PRECISION;
 
         return _get_D(_xp, _amp);
     }
@@ -104,4 +105,23 @@ library CurveFraxUsdcPoolHelper {
         }
         assert(false);
     }
+
+    function _getBalances() internal view returns (uint256[N_COINS] memory balances) {
+        balances[0] = ICrvPool(POOL).balances(0);
+        balances[1] = ICrvPool(POOL).balances(1);
+    }
+
+    function memcpy(uint256[N_COINS] memory a, uint256[N_COINS] memory b) internal pure {
+        for (uint256 i = 0; i < N_COINS; ++i) {
+            a[i] = b[i];
+        }
+    }
+
+    function _getTokenAmounts(address token, uint256 amount)
+        internal
+        pure
+        returns (uint256[N_COINS] memory res)
+    {
+        res[token == FRAX ? 0 : 1] = amount;
+    }
 }

package/contracts/core/StandardizedYield/implementations/Convex/base/CurveUsdd3CrvPoolHelper.sol

@@ -0,0 +1,152 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../../../libraries/math/Math.sol";
+import "../../../../../interfaces/Curve/ICrvPool.sol";
+import "./Curve3CrvPoolHelper.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+library CurveUsdd3CrvPoolHelper {
+    using Math for uint256;
+
+    uint256 internal constant N_COINS = 2;
+    uint256 internal constant A_PRECISION = 100;
+    uint256 internal constant PRECISION = 10**18;
+    uint256 internal constant rate_multiplier = 10**18;
+    uint256 internal constant FEE_DENOMINATOR = 10**10;
+
+    // LP == POOL
+    address internal constant POOL = 0xe6b5CC1B4b47305c58392CE3D359B10282FC36Ea;
+    address internal constant USDD = 0x0C10bF8FcB7Bf5412187A595ab97a3609160b5c6;
+    address internal constant LP_3CRV = 0x6c3F90f043a72FA612cbac8115EE7e52BDe6E490;
+
+    function _getBalances() internal view returns (uint256[N_COINS] memory balances) {
+        balances[0] = ICrvPool(POOL).balances(0);
+        balances[1] = ICrvPool(POOL).balances(1);
+    }
+
+    function _getTokenAmounts(address token, uint256 amount)
+        internal
+        pure
+        returns (uint256[N_COINS] memory res)
+    {
+        res[token == USDD ? 0 : 1] = amount;
+    }
+
+    // ----------------- Forked from https://etherscan.io/address/0xe6b5CC1B4b47305c58392CE3D359B10282FC36Ea#code -----------------
+    function previewAddLiquidity(address token, uint256 amount) internal view returns (uint256) {
+        uint256 amp = ICrvPool(POOL).A_precise();
+
+        uint256[N_COINS] memory rates;
+
+        rates[0] = rate_multiplier;
+
+        if (token == USDD || token == LP_3CRV) {
+            rates[1] = Curve3CrvPoolHelper.get_virtual_price();
+        } else {
+            (amount, rates[1]) = Curve3CrvPoolHelper.preview3CrvDeposit(token, amount);
+            token = LP_3CRV;
+        }
+
+        uint256[N_COINS] memory amounts = _getTokenAmounts(token, amount);
+
+        uint256[N_COINS] memory old_balances = _getBalances();
+        uint256 D0 = get_D_mem(rates, old_balances, amp);
+        uint256[N_COINS] memory new_balances = arrayClone(old_balances);
+
+        uint256 total_supply = IERC20(POOL).totalSupply();
+        for (uint256 i = 0; i < N_COINS; ++i) {
+            new_balances[i] += amounts[i];
+        }
+
+        // Invariant after change
+        uint256 D1 = get_D_mem(rates, new_balances, amp);
+        assert(D1 > D0);
+
+        // We need to recalculate the invariant accounting for fees
+        // to calculate fair user's share
+        uint256[N_COINS] memory fees;
+        uint256 mint_amount = 0;
+
+        uint256 base_fee = (ICrvPool(POOL).fee() * N_COINS) / (4 * (N_COINS - 1));
+        for (uint256 i = 0; i < N_COINS; ++i) {
+            uint256 ideal_balance = (D1 * old_balances[i]) / D0;
+            uint256 difference = 0;
+            uint256 new_balance = new_balances[i];
+            if (ideal_balance > new_balance) {
+                difference = ideal_balance - new_balance;
+            } else {
+                difference = new_balance - ideal_balance;
+            }
+            fees[i] = (base_fee * difference) / FEE_DENOMINATOR;
+            new_balances[i] -= fees[i];
+        }
+        uint256 D2 = get_D_mem(rates, new_balances, amp);
+        mint_amount = (total_supply * (D2 - D0)) / D0;
+        return mint_amount;
+    }
+
+    function get_D_mem(
+        uint256[N_COINS] memory _rates,
+        uint256[N_COINS] memory _balances,
+        uint256 _amp
+    ) internal pure returns (uint256) {
+        uint256[N_COINS] memory xp = _xp_mem(_rates, _balances);
+        return get_D(xp, _amp);
+    }
+
+    function _xp_mem(uint256[N_COINS] memory _rates, uint256[N_COINS] memory balances)
+        internal
+        pure
+        returns (uint256[N_COINS] memory)
+    {
+        uint256[N_COINS] memory result;
+        for (uint256 i = 0; i < N_COINS; ++i) {
+            result[i] = balances[i] * _rates[i] / PRECISION;
+        }
+        return result;
+    }
+
+    function get_D(uint256[N_COINS] memory _xp, uint256 _amp) internal pure returns (uint256) {
+        uint256 S = 0;
+        uint256 Dprev = 0;
+        for (uint256 k = 0; k < N_COINS; ++k) {
+            S += _xp[k];
+        }
+        if (S == 0) return 0;
+
+        uint256 D = S;
+        uint256 Ann = _amp * N_COINS;
+        for (uint256 _i = 0; _i < 255; ++_i) {
+            uint256 D_P = D;
+            for (uint256 k = 0; k < N_COINS; ++k) {
+                D_P = (D_P * D) / (_xp[k] * N_COINS);
+            }
+            Dprev = D;
+            D =
+                (((Ann * S) / A_PRECISION + D_P * N_COINS) * D) /
+                (((Ann - A_PRECISION) * D) / A_PRECISION + (N_COINS + 1) * D_P);
+
+            if (D > Dprev) {
+                if (D - Dprev <= 1) {
+                    return D;
+                }
+            } else {
+                if (Dprev - D <= 1) {
+                    return D;
+                }
+            }
+        }
+        assert(false);
+    }
+
+    function arrayClone(uint256[N_COINS] memory a)
+        internal
+        pure
+        returns (uint256[N_COINS] memory res)
+    {
+        for (uint256 i = 0; i < N_COINS; ++i) {
+            res[i] = a[i];
+        }
+    }
+}

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;
     }