@pendle/core-v2 0.8.0-beta-12 → 0.8.1-gamma

package/contracts/core/YieldContracts/PendleYieldToken.sol

@@ -13,7 +13,7 @@ import "../../interfaces/IPYieldContractFactory.sol";
 import "../../libraries/SCY/SCYUtils.sol";
 import "../../libraries/helpers/MiniHelpers.sol";
 import "../../libraries/RewardManagerAbstract.sol";
-import "../PendleERC20Permit.sol";
+import "../PendleERC20.sol";
 import "./InterestManagerYT.sol";
 
 /**
@@ -21,18 +21,13 @@ Invariances to maintain:
 - address(0) & address(this) should never have any rewards & activeBalance accounting done. This is
     guaranteed by address(0) & address(this) check in each updateForTwo function
 */
-contract PendleYieldToken is
-    IPYieldToken,
-    PendleERC20Permit,
-    RewardManagerAbstract,
-    InterestManagerYT
-{
+contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, InterestManagerYT {
     using Math for uint256;
     using SafeERC20 for IERC20;
     using ArrayLib for uint256[];
 
     struct PostExpiryData {
-        uint128 firstScyIndex;
+        uint128 firstPYIndex;
         uint128 totalScyInterestForTreasury;
         mapping(address => uint256) firstRewardIndex;
         mapping(address => uint256) userRewardOwed;
@@ -44,7 +39,7 @@ contract PendleYieldToken is
     uint256 public immutable expiry;
 
     uint128 public scyReserve;
-    uint128 internal _scyIndexStored;
+    uint128 internal _pyIndexStored;
 
     PostExpiryData public postExpiry;
 
@@ -61,7 +56,7 @@ contract PendleYieldToken is
         string memory _symbol,
         uint8 __decimals,
         uint256 _expiry
-    ) PendleERC20Permit(_name, _symbol, __decimals) {
+    ) PendleERC20(_name, _symbol, __decimals) {
         SCY = _SCY;
         PT = _PT;
         expiry = _expiry;
@@ -84,6 +79,8 @@ contract PendleYieldToken is
         _mint(receiverYT, amountPYOut);
 
         IPPrincipalToken(PT).mintByYT(receiverPT, amountPYOut);
+
+        emit Mint(msg.sender, receiverPT, receiverYT, amountScyToMint, amountPYOut);
     }
 
     /// @dev this function converts PY tokens into scy, but interests & rewards are not redeemed at the same time
@@ -183,14 +180,14 @@ contract PendleYieldToken is
     }
 
     /// @dev maximize the current rate with the previous rate to guarantee non-decreasing rate
-    function scyIndexCurrent() public returns (uint256 currentIndex) {
-        currentIndex = Math.max(ISuperComposableYield(SCY).exchangeRate(), _scyIndexStored);
-        _scyIndexStored = currentIndex.Uint128();
+    function pyIndexCurrent() public returns (uint256 currentIndex) {
+        currentIndex = Math.max(ISuperComposableYield(SCY).exchangeRate(), _pyIndexStored);
+        _pyIndexStored = currentIndex.Uint128();
         emit NewInterestIndex(currentIndex);
     }
 
-    function scyIndexStored() public view returns (uint256) {
-        return _scyIndexStored;
+    function pyIndexStored() public view returns (uint256) {
+        return _pyIndexStored;
     }
 
     function isExpired() public view returns (bool) {
@@ -201,15 +198,15 @@ contract PendleYieldToken is
         external
         view
         returns (
-            uint256 firstScyIndex,
+            uint256 firstPYIndex,
             uint256 totalScyInterestForTreasury,
             uint256[] memory firstRewardIndexes,
             uint256[] memory userRewardOwed
         )
     {
-        require(postExpiry.firstScyIndex != 0, "PostExpiry data not set");
+        require(postExpiry.firstPYIndex != 0, "PostExpiry data not set");
 
-        firstScyIndex = postExpiry.firstScyIndex;
+        firstPYIndex = postExpiry.firstPYIndex;
         totalScyInterestForTreasury = postExpiry.totalScyInterestForTreasury;
 
         address[] memory tokens = getRewardTokens();
@@ -230,7 +227,7 @@ contract PendleYieldToken is
         IPPrincipalToken(PT).burnByYT(address(this), totalAmountPYToRedeem);
         if (!isExpired()) _burn(address(this), totalAmountPYToRedeem);
 
-        uint256 index = scyIndexCurrent();
+        uint256 index = pyIndexCurrent();
         uint256 totalScyInterestPostExpiry;
         amountScyOuts = new uint256[](receivers.length);
 
@@ -242,6 +239,8 @@ contract PendleYieldToken is
             );
             _transferOut(SCY, receivers[i], amountScyOuts[i]);
             totalScyInterestPostExpiry += scyInterestPostExpiry;
+
+            emit Burn(msg.sender, receivers[i], amountPYToRedeems[i], amountScyOuts[i]);
         }
         if (totalScyInterestPostExpiry != 0) {
             postExpiry.totalScyInterestForTreasury += totalScyInterestPostExpiry.Uint128();
@@ -250,14 +249,7 @@ contract PendleYieldToken is
 
     function _calcPYToMint(uint256 amountScy) internal returns (uint256 amountPY) {
         // doesn't matter before or after expiry, since mintPY is only allowed before expiry
-        return SCYUtils.scyToAsset(scyIndexCurrent(), amountScy);
-    }
-
-    function _calcScyRedeemableFromPY(uint256 amountPY)
-        internal
-        returns (uint256 scyToUser, uint256 scyInterestPostExpiry)
-    {
-        return _calcScyRedeemableFromPY(amountPY, scyIndexCurrent());
+        return SCYUtils.scyToAsset(pyIndexCurrent(), amountScy);
     }
 
     function _calcScyRedeemableFromPY(uint256 amountPY, uint256 indexCurrent)
@@ -267,7 +259,7 @@ contract PendleYieldToken is
     {
         scyToUser = SCYUtils.assetToScy(indexCurrent, amountPY);
         if (isExpired()) {
-            uint256 totalScyRedeemable = SCYUtils.assetToScy(postExpiry.firstScyIndex, amountPY);
+            uint256 totalScyRedeemable = SCYUtils.assetToScy(postExpiry.firstPYIndex, amountPY);
             scyInterestPostExpiry = totalScyRedeemable - scyToUser;
         }
     }
@@ -288,11 +280,11 @@ contract PendleYieldToken is
 
     function _setPostExpiryData() internal {
         PostExpiryData storage local = postExpiry;
-        if (local.firstScyIndex != 0) return; // already set
+        if (local.firstPYIndex != 0) return; // already set
 
         _redeemExternalReward(); // do a final redeem. All the future reward income will belong to the treasury
 
-        local.firstScyIndex = scyIndexCurrent().Uint128();
+        local.firstPYIndex = pyIndexCurrent().Uint128();
         address[] memory rewardTokens = ISuperComposableYield(SCY).getRewardTokens();
         uint256[] memory rewardIndexes = ISuperComposableYield(SCY).rewardIndexesCurrent();
         for (uint256 i = 0; i < rewardTokens.length; i++) {
@@ -306,8 +298,8 @@ contract PendleYieldToken is
     //////////////////////////////////////////////////////////////*/
 
     function _getInterestIndex() internal virtual override returns (uint256 index) {
-        if (isExpired()) index = postExpiry.firstScyIndex;
-        else index = scyIndexCurrent();
+        if (isExpired()) index = postExpiry.firstPYIndex;
+        else index = pyIndexCurrent();
     }
 
     function _YTbalance(address user) internal view override returns (uint256) {

package/contracts/core/actions/ActionCallback.sol

@@ -16,8 +16,8 @@ contract ActionCallback is IPMarketSwapCallback, CallbackHelper {
     using SafeERC20 for ISuperComposableYield;
     using SafeERC20 for IPYieldToken;
     using SafeERC20 for IERC20;
-    using SCYIndexLib for SCYIndex;
-    using SCYIndexLib for ISuperComposableYield;
+    using PYIndexLib for PYIndex;
+    using PYIndexLib for IPYieldToken;
 
     address public immutable marketFactory;
 
@@ -90,9 +90,9 @@ contract ActionCallback is IPMarketSwapCallback, CallbackHelper {
         /// ------------------------------------------------------------
         /// calc totalScyNeed
         /// ------------------------------------------------------------
-        SCYIndex scyIndex = SCY.newIndex();
+        PYIndex pyIndex = YT.newIndex();
         uint256 ptOwed = ptToAccount.abs();
-        uint256 totalScyNeed = scyIndex.assetToScyUp(ptOwed);
+        uint256 totalScyNeed = pyIndex.assetToScyUp(ptOwed);
 
         /// ------------------------------------------------------------
         /// calc netScyToPull
@@ -104,7 +104,9 @@ contract ActionCallback is IPMarketSwapCallback, CallbackHelper {
         /// ------------------------------------------------------------
         /// mint & transfer
         /// ------------------------------------------------------------
-        SCY.safeTransferFrom(vars.payer, address(YT), netScyToPull);
+        if (netScyToPull > 0) {
+            SCY.safeTransferFrom(vars.payer, address(YT), netScyToPull);
+        }
 
         uint256 amountPYout = YT.mintPY(market, vars.receiver);
         require(amountPYout >= ptOwed, "insufficient pt to pay");
@@ -118,15 +120,15 @@ contract ActionCallback is IPMarketSwapCallback, CallbackHelper {
         bytes calldata data
     ) internal {
         (address receiver, uint256 minScyOut) = _decodeSwapYtForScy(data);
-        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
-        SCYIndex scyIndex = SCY.newIndex();
+        (, , IPYieldToken YT) = IPMarket(market).readTokens();
+        PYIndex pyIndex = YT.newIndex();
 
         uint256 scyOwed = scyToAccount.neg().Uint();
 
         address[] memory receivers = new address[](2);
         uint256[] memory amountPYToRedeems = new uint256[](2);
 
-        (receivers[0], amountPYToRedeems[0]) = (market, scyIndex.scyToAssetUp(scyOwed));
+        (receivers[0], amountPYToRedeems[0]) = (market, pyIndex.scyToAssetUp(scyOwed));
         (receivers[1], amountPYToRedeems[1]) = (
             receiver,
             ptToAccount.Uint() - amountPYToRedeems[0]

package/contracts/core/actions/base/ActionSCYAndPTBase.sol

@@ -14,7 +14,7 @@ abstract contract ActionSCYAndPTBase is ActionSCYAndPYBase {
     using MarketMathCore for MarketState;
     using MarketApproxLib for MarketState;
     using SafeERC20 for IERC20;
-    using SCYIndexLib for ISuperComposableYield;
+    using PYIndexLib for IPYieldToken;
 
     bytes private constant EMPTY_BYTES = abi.encode();
 
@@ -38,11 +38,12 @@ abstract contract ActionSCYAndPTBase is ActionSCYAndPYBase {
             uint256 ptUsed
         )
     {
-        (ISuperComposableYield SCY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
+        (ISuperComposableYield SCY, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market)
+            .readTokens();
 
         MarketState memory state = IPMarket(market).readState(false);
         (, netLpOut, scyUsed, ptUsed) = state.addLiquidity(
-            SCY.newIndex(),
+            YT.newIndex(),
             scyDesired,
             ptDesired,
             block.timestamp
@@ -119,10 +120,10 @@ abstract contract ActionSCYAndPTBase is ActionSCYAndPYBase {
         bool doPull
     ) internal returns (uint256 netPtIn) {
         MarketState memory state = IPMarket(market).readState(false);
-        (ISuperComposableYield SCY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
+        (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
 
         (netPtIn, , ) = state.approxSwapPtForExactScy(
-            SCY.newIndex(),
+            YT.newIndex(),
             exactScyOut,
             block.timestamp,
             guessPtIn
@@ -147,9 +148,9 @@ abstract contract ActionSCYAndPTBase is ActionSCYAndPYBase {
         bool doPull
     ) internal returns (uint256 netScyIn) {
         MarketState memory state = IPMarket(market).readState(false);
-        (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
+        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
-        (netScyIn, ) = state.swapScyForExactPt(SCY.newIndex(), exactPtOut, block.timestamp);
+        (netScyIn, ) = state.swapScyForExactPt(YT.newIndex(), exactPtOut, block.timestamp);
 
         require(netScyIn <= maxScyIn, "exceed limit SCY in");
 
@@ -175,10 +176,10 @@ abstract contract ActionSCYAndPTBase is ActionSCYAndPYBase {
         bool doPull
     ) internal returns (uint256 netPtOut) {
         MarketState memory state = IPMarket(market).readState(false);
-        (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
+        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         (netPtOut, , ) = state.approxSwapExactScyForPt(
-            SCY.newIndex(),
+            YT.newIndex(),
             exactScyIn,
             block.timestamp,
             guessPtOut

package/contracts/core/actions/base/ActionSCYAndYTBase.sol

@@ -16,7 +16,7 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, CallbackHelper {
     using MarketApproxLib for MarketState;
     using SafeERC20 for ISuperComposableYield;
     using SafeERC20 for IPYieldToken;
-    using SCYIndexLib for ISuperComposableYield;
+    using PYIndexLib for IPYieldToken;
 
     /**
     * @notice swap exact SCY to YT with the help of flashswaps & YT tokenization / redemption
@@ -40,7 +40,7 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, CallbackHelper {
         MarketState memory state = IPMarket(market).readState(false);
 
         (netYtOut, , ) = state.approxSwapExactScyForYt(
-            SCY.newIndex(),
+            YT.newIndex(),
             exactScyIn,
             block.timestamp,
             guessYtOut
@@ -118,6 +118,7 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, CallbackHelper {
             exactYtOut, // exactPtIn = exactYtOut
             _encodeSwapScyForExactYt(msg.sender, receiver, maxScyIn)
         );
+
         netScyIn = preScyBalance - SCY.balanceOf(msg.sender);
     }
 
@@ -140,10 +141,10 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, CallbackHelper {
         bool doPull
     ) internal returns (uint256 netYtIn) {
         MarketState memory state = IPMarket(market).readState(false);
-        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
+        (, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         (netYtIn, , ) = state.approxSwapYtForExactScy(
-            SCY.newIndex(),
+            YT.newIndex(),
             exactScyOut,
             block.timestamp,
             guessYtIn

package/contracts/core/actions/base/CallbackHelper.sol

@@ -76,6 +76,6 @@ abstract contract CallbackHelper {
     /// Misc functions
     /// ------------------------------------------------------------
     function _getActionType(bytes memory data) internal pure returns (ActionType actionType) {
-        (actionType, ) = abi.decode(data, (ActionType, address));
+        actionType = abi.decode(data, (ActionType));
     }
 }

package/contracts/interfaces/IEulerEToken.sol

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+/*
+ * MIT License
+ * ===========
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ */
+
+pragma solidity 0.8.15;
+
+interface IEulerEToken {
+    /// @notice Address of underlying asset
+    function underlyingAsset() external view returns (address);
+
+    /// @notice Sum of all balances, in internal book-keeping units (non-increasing)
+    function totalSupply() external view returns (uint256);
+
+    /// @notice Sum of all balances, in underlying units (increases as interest is earned)
+    function totalSupplyUnderlying() external view returns (uint256);
+
+    /// @notice Transfer underlying tokens from sender to the Euler pool, and increase account's eTokens
+    /// @param subAccountId 0 for primary, 1-255 for a sub-account
+    /// @param amount In underlying units (use max uint256 for full underlying token balance)
+    function deposit(uint256 subAccountId, uint256 amount) external;
+
+    function balanceOf(address) external view returns (uint256);
+
+    /// @notice Balance of a particular account, in underlying units (increases as interest is earned)
+    function balanceOfUnderlying(address) external view returns (uint256);
+
+    /// @notice Convert an underlying amount to an eToken balance, taking into account current exchange rate
+    /// @param underlyingAmount Amount in underlying units (same decimals as underlying token)
+    /// @return eToken balance, in internal book-keeping units (18 decimals)
+    function convertUnderlyingToBalance(uint256 underlyingAmount) external view returns (uint256);
+
+    /// @notice Convert an eToken balance to an underlying amount, taking into account current exchange rate
+    /// @param balance eToken balance, in internal book-keeping units (18 decimals)
+    /// @return Amount in underlying units, (same decimals as underlying token)
+    function convertBalanceToUnderlying(uint256 balance) external view returns (uint256);
+
+    /// @notice Transfer underlying tokens from Euler pool to sender, and decrease account's eTokens
+    /// @param subAccountId 0 for primary, 1-255 for a sub-account
+    /// @param amount In underlying units (use max uint256 for full pool balance)
+    function withdraw(uint256 subAccountId, uint256 amount) external;
+}

package/contracts/interfaces/IEulerMarkets.sol

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+/*
+ * MIT License
+ * ===========
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ */
+
+pragma solidity 0.8.15;
+
+interface IEulerMarkets {
+    /// @notice Given an EToken address, looks up the associated underlying
+    /// @param eToken EToken address
+    /// @return underlying Token address
+    function eTokenToUnderlying(address eToken) external view returns (address underlying);
+
+    /// @notice Given an underlying, lookup the associated EToken
+    /// @param underlying Token address
+    /// @return EToken address, or address(0) if not activated
+    function underlyingToEToken(address underlying) external view returns (address);
+
+    /// @notice Given an underlying, lookup the associated DToken
+    /// @param underlying Token address
+    /// @return DToken address, or address(0) if not activated
+    function underlyingToDToken(address underlying) external view returns (address);
+
+    /// @notice Retrieves the current interest rate for an asset
+    /// @param underlying Token address
+    /// @return The interest rate in yield-per-second, scaled by 10**27
+    function interestRate(address underlying) external view returns (int96);
+}

package/contracts/interfaces/IPGaugeController.sol

@@ -23,6 +23,6 @@ interface IPGaugeController {
             uint128,
             uint128
         );
-    
+
 
 }

package/contracts/interfaces/IPInterestManagerYT.sol

@@ -5,5 +5,5 @@ interface IPInterestManagerYT {
     function userInterest(address user)
         external
         view
-        returns (uint128 lastScyIndex, uint128 accruedInterest);
+        returns (uint128 lastPYIndex, uint128 accruedInterest);
 }

package/contracts/interfaces/IPMarket.sol

@@ -4,6 +4,7 @@ pragma solidity 0.8.15;
 import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import "./IPPrincipalToken.sol";
 import "./IPYieldToken.sol";
+import "./ISuperComposableYield.sol";
 import "../libraries/math/MarketMathCore.sol";
 
 interface IPMarket is IERC20Metadata {

package/contracts/interfaces/IPRouterStatic.sol

@@ -59,7 +59,6 @@ interface IPRouterStatic {
 
     function getMarketInfo(address market)
         external
-        view
         returns (
             address pt,
             address scy,
@@ -93,7 +92,6 @@ interface IPRouterStatic {
         uint256 ptDesired
     )
         external
-        view
         returns (
             uint256 netLpOut,
             uint256 scyUsed,
@@ -107,26 +105,35 @@ interface IPRouterStatic {
 
     function swapExactPtForScyStatic(address market, uint256 exactPtIn)
         external
-        view
-        returns (uint256 netScyOut, uint256 netScyFee);
+        returns (
+            uint256 netScyOut,
+            uint256 netScyFee,
+            uint256 priceImpact
+        );
 
     function swapScyForExactPtStatic(address market, uint256 exactPtOut)
         external
-        view
-        returns (uint256 netScyIn, uint256 netScyFee);
+        returns (
+            uint256 netScyIn,
+            uint256 netScyFee,
+            uint256 priceImpact
+        );
 
     function swapExactScyForPtStatic(address market, uint256 exactScyIn)
         external
-        view
-        returns (uint256 netPtOut, uint256 netScyFee);
+        returns (
+            uint256 netPtOut,
+            uint256 netScyFee,
+            uint256 priceImpact
+        );
 
     // ============= OTHER HELPERS =============
 
-    function scyIndex(address market) external view returns (SCYIndex index);
+    function pyIndex(address market) external returns (PYIndex index);
 
     function getPY(address py) external view returns (address pt, address yt);
 
-    function getPtImpliedYield(address market) external view returns (int256);
+    function getPtImpliedYield(address market) external returns (int256);
 
     function getUserPYInfo(address py, address user)
         external

package/contracts/interfaces/IPVeToken.sol

@@ -14,4 +14,6 @@ interface IPVeToken {
     function totalSupplyStored() external view returns (uint128);
 
     function totalSupplyCurrent() external returns (uint128);
+
+    function totalSupplyAndBlanaceCurrent(address user) external returns (uint128, uint128);
 }

package/contracts/interfaces/IPYieldToken.sol

@@ -46,9 +46,9 @@ interface IPYieldToken is IERC20Metadata, IRewardManager, IPInterestManagerYT {
 
     function rewardIndexesCurrent() external returns (uint256[] memory);
 
-    function scyIndexCurrent() external returns (uint256);
+    function pyIndexCurrent() external returns (uint256);
 
-    function scyIndexStored() external view returns (uint256);
+    function pyIndexStored() external view returns (uint256);
 
     function getRewardTokens() external view returns (address[] memory);
 

package/contracts/interfaces/ISAvax.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+interface ISAvax {
+    function decimals() external pure returns (uint8);
+
+    function balanceOf(address account) external view returns (uint256);
+
+    function totalPooledAvax() external returns (uint256);
+
+    function totalShares() external returns (uint256);
+
+    /**
+     * @return The amount of AVAX that corresponds to `shareAmount` sAVAX token shares.
+     */
+    function getPooledAvaxByShares(uint256 shareAmount) external view returns (uint256);
+
+    function cooldownPeriod() external returns (uint256);
+
+    function redeemPeriod() external returns (uint256);
+
+    /**
+     * @notice Process user deposit, mints liquid tokens and increase the pool buffer -> Will be called when NATIVE AVAX is transferred to SAVAX (Dont need to call this function explicitly)
+     * @return Amount of sAVAX shares generated
+     */
+    function submit() external payable returns (uint256);
+
+    /**
+     * @notice Redeem all redeemable AVAX from all unlocks
+     */
+    function redeem() external;
+
+    /**
+     * @notice Redeem AVAX after cooldown has finished
+     * @param unlockIndex Index number of the redeemed unlock request
+     */
+    function redeem(uint256 unlockIndex) external;
+
+    /**
+     * @notice Redeem all sAVAX held in custody for overdue unlock requests
+     */
+    function redeemOverdueShares() external;
+
+    /**
+     * @notice Redeem sAVAX held in custody for the given unlock request
+     * @param unlockIndex Unlock request array index
+     */
+    function redeemOverdueShares(uint256 unlockIndex) external;
+
+    /**
+     * @notice Start unlocking cooldown period for `shareAmount` AVAX
+     * @param shareAmount Amount of shares to unlock
+     */
+    function requestUnlock(uint256 shareAmount) external;
+
+    /**
+     * @notice Get the number of active unlock requests by user
+     * @param user User address
+     */
+    function getUnlockRequestCount(address user) external view returns (uint256);
+}

package/contracts/interfaces/ISJoe.sol

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
+
+interface ISJoe {
+    function joe() external view returns (address);
+
+    function depositFeePercent() external view returns (uint256);
+
+    function internalJoeBalance() external view returns (uint256);
+
+    /**
+     * @notice Deposit JOE for reward token allocation
+     * @param _amount The amount of JOE to deposit
+     */
+    function deposit(uint256 _amount) external;
+
+    /**
+     * @notice Get user info
+     * @param _user The address of the user
+     * @param _rewardToken The address of the reward token
+     * @return The amount of JOE user has deposited
+     * @return The reward debt for the chosen token
+     */
+    function getUserInfo(address _user, IERC20Upgradeable _rewardToken)
+        external
+        view
+        returns (uint256, uint256);
+
+    /**
+     * @notice Get the number of reward tokens
+     * @return The length of the array
+     */
+    function rewardTokensLength() external view returns (uint256);
+
+    function rewardTokens(uint256 _index) external view returns (address);
+
+    /**
+     * @notice View function to see pending reward token on frontend
+     * @param _user The address of the user
+     * @param _token The address of the token
+     * @return `_user`'s pending reward token
+     */
+    function pendingReward(address _user, IERC20Upgradeable _token)
+        external
+        view
+        returns (uint256);
+
+    /**
+     * @notice Withdraw JOE and harvest the rewards
+     * @param _amount The amount of JOE to withdraw
+     */
+    function withdraw(uint256 _amount) external;
+
+    /**
+     * @notice Withdraw without caring about rewards. EMERGENCY ONLY
+     */
+    function emergencyWithdraw() external;
+}