@pendle/core-v2 0.13.1-testnet → 0.14.0-testnet

package/contracts/core/Market/MarketMathCore.sol

@@ -4,13 +4,13 @@ pragma solidity 0.8.17;
 import "../libraries/math/Math.sol";
 import "../libraries/math/LogExpMath.sol";
 
-import "../SuperComposableYield/PYIndex.sol";
+import "../StandardizedYield/PYIndex.sol";
 import "../libraries/MiniHelpers.sol";
 import "../libraries/Errors.sol";
 
 struct MarketState {
     int256 totalPt;
-    int256 totalScy;
+    int256 totalSy;
     int256 totalLp;
     address treasury;
     /// immutable variables ///
@@ -53,7 +53,7 @@ library MarketMathCore {
 
     function addLiquidity(
         MarketState memory market,
-        uint256 scyDesired,
+        uint256 syDesired,
         uint256 ptDesired,
         uint256 blockTime
     )
@@ -62,69 +62,66 @@ library MarketMathCore {
         returns (
             uint256 lpToReserve,
             uint256 lpToAccount,
-            uint256 scyUsed,
+            uint256 syUsed,
             uint256 ptUsed
         )
     {
         (
             int256 _lpToReserve,
             int256 _lpToAccount,
-            int256 _scyUsed,
+            int256 _syUsed,
             int256 _ptUsed
-        ) = addLiquidityCore(market, scyDesired.Int(), ptDesired.Int(), blockTime);
+        ) = addLiquidityCore(market, syDesired.Int(), ptDesired.Int(), blockTime);
 
         lpToReserve = _lpToReserve.Uint();
         lpToAccount = _lpToAccount.Uint();
-        scyUsed = _scyUsed.Uint();
+        syUsed = _syUsed.Uint();
         ptUsed = _ptUsed.Uint();
     }
 
     function removeLiquidity(MarketState memory market, uint256 lpToRemove)
         internal
         pure
-        returns (uint256 scyToAccount, uint256 netPtToAccount)
+        returns (uint256 syToAccount, uint256 netPtToAccount)
     {
-        (int256 _scyToAccount, int256 _ptToAccount) = removeLiquidityCore(
-            market,
-            lpToRemove.Int()
-        );
+        (int256 _syToAccount, int256 _ptToAccount) = removeLiquidityCore(market, lpToRemove.Int());
 
-        scyToAccount = _scyToAccount.Uint();
+        syToAccount = _syToAccount.Uint();
         netPtToAccount = _ptToAccount.Uint();
     }
 
-    function swapExactPtForScy(
+    function swapExactPtForSy(
         MarketState memory market,
         PYIndex index,
         uint256 exactPtToMarket,
         uint256 blockTime
-    ) internal pure returns (uint256 netScyToAccount, uint256 netScyToReserve) {
-        (int256 _netScyToAccount, int256 _netScyToReserve) = executeTradeCore(
+    ) internal pure returns (uint256 netSyToAccount, uint256 netSyToReserve) {
+        (int256 _netSyToAccount, int256 _netSyToReserve) = executeTradeCore(
             market,
             index,
             exactPtToMarket.neg(),
             blockTime
         );
 
-        netScyToAccount = _netScyToAccount.Uint();
-        netScyToReserve = _netScyToReserve.Uint();
+        netSyToAccount = _netSyToAccount.Uint();
+        netSyToReserve = _netSyToReserve.Uint();
     }
 
-    function swapScyForExactPt(
+    function swapSyForExactPt(
         MarketState memory market,
         PYIndex index,
         uint256 exactPtToAccount,
         uint256 blockTime
-    ) internal pure returns (uint256 netScyToMarket, uint256 netScyToReserve) {
-        (int256 _netScyToAccount, int256 _netScyToReserve) = executeTradeCore(
+    ) internal pure returns (uint256 netSyToMarket, uint256 netSyToReserve) {
+        (int256 _netSyToAccount, int256 _netSyToReserve) = executeTradeCore(
             market,
             index,
             exactPtToAccount.Int(),
             blockTime
         );
 
-        netScyToMarket = _netScyToAccount.neg().Uint();
-        netScyToReserve = _netScyToReserve.Uint();
+        netSyToMarket = _netSyToAccount.neg().Uint();
+        netSyToReserve = _netSyToReserve.Uint();
     }
 
     /*///////////////////////////////////////////////////////////////
@@ -133,7 +130,7 @@ library MarketMathCore {
 
     function addLiquidityCore(
         MarketState memory market,
-        int256 scyDesired,
+        int256 syDesired,
         int256 ptDesired,
         uint256 blockTime
     )
@@ -142,34 +139,34 @@ library MarketMathCore {
         returns (
             int256 lpToReserve,
             int256 lpToAccount,
-            int256 scyUsed,
+            int256 syUsed,
             int256 ptUsed
         )
     {
         /// ------------------------------------------------------------
         /// CHECKS
         /// ------------------------------------------------------------
-        if (scyDesired == 0 || ptDesired == 0) revert Errors.MarketZeroAmountsInput();
+        if (syDesired == 0 || ptDesired == 0) revert Errors.MarketZeroAmountsInput();
         if (MiniHelpers.isExpired(market.expiry, blockTime)) revert Errors.MarketExpired();
 
         /// ------------------------------------------------------------
         /// MATH
         /// ------------------------------------------------------------
         if (market.totalLp == 0) {
-            lpToAccount = Math.sqrt((scyDesired * ptDesired).Uint()).Int() - MINIMUM_LIQUIDITY;
+            lpToAccount = Math.sqrt((syDesired * ptDesired).Uint()).Int() - MINIMUM_LIQUIDITY;
             lpToReserve = MINIMUM_LIQUIDITY;
-            scyUsed = scyDesired;
+            syUsed = syDesired;
             ptUsed = ptDesired;
         } else {
             int256 netLpByPt = (ptDesired * market.totalLp) / market.totalPt;
-            int256 netLpByScy = (scyDesired * market.totalLp) / market.totalScy;
-            if (netLpByPt < netLpByScy) {
+            int256 netLpBySy = (syDesired * market.totalLp) / market.totalSy;
+            if (netLpByPt < netLpBySy) {
                 lpToAccount = netLpByPt;
                 ptUsed = ptDesired;
-                scyUsed = (market.totalScy * lpToAccount) / market.totalLp;
+                syUsed = (market.totalSy * lpToAccount) / market.totalLp;
             } else {
-                lpToAccount = netLpByScy;
-                scyUsed = scyDesired;
+                lpToAccount = netLpBySy;
+                syUsed = syDesired;
                 ptUsed = (market.totalPt * lpToAccount) / market.totalLp;
             }
         }
@@ -179,7 +176,7 @@ library MarketMathCore {
         /// ------------------------------------------------------------
         /// WRITE
         /// ------------------------------------------------------------
-        market.totalScy += scyUsed;
+        market.totalSy += syUsed;
         market.totalPt += ptUsed;
         market.totalLp += lpToAccount + lpToReserve;
     }
@@ -187,7 +184,7 @@ library MarketMathCore {
     function removeLiquidityCore(MarketState memory market, int256 lpToRemove)
         internal
         pure
-        returns (int256 netScyToAccount, int256 netPtToAccount)
+        returns (int256 netSyToAccount, int256 netPtToAccount)
     {
         /// ------------------------------------------------------------
         /// CHECKS
@@ -197,17 +194,17 @@ library MarketMathCore {
         /// ------------------------------------------------------------
         /// MATH
         /// ------------------------------------------------------------
-        netScyToAccount = (lpToRemove * market.totalScy) / market.totalLp;
+        netSyToAccount = (lpToRemove * market.totalSy) / market.totalLp;
         netPtToAccount = (lpToRemove * market.totalPt) / market.totalLp;
 
-        if (netScyToAccount == 0 || netPtToAccount == 0) revert Errors.MarketZeroAmountsOutput();
+        if (netSyToAccount == 0 || netPtToAccount == 0) revert Errors.MarketZeroAmountsOutput();
 
         /// ------------------------------------------------------------
         /// WRITE
         /// ------------------------------------------------------------
         market.totalLp = market.totalLp.subNoNeg(lpToRemove);
         market.totalPt = market.totalPt.subNoNeg(netPtToAccount);
-        market.totalScy = market.totalScy.subNoNeg(netScyToAccount);
+        market.totalSy = market.totalSy.subNoNeg(netSyToAccount);
     }
 
     function executeTradeCore(
@@ -215,7 +212,7 @@ library MarketMathCore {
         PYIndex index,
         int256 netPtToAccount,
         uint256 blockTime
-    ) internal pure returns (int256 netScyToAccount, int256 netScyToReserve) {
+    ) internal pure returns (int256 netSyToAccount, int256 netSyToReserve) {
         /// ------------------------------------------------------------
         /// CHECKS
         /// ------------------------------------------------------------
@@ -228,7 +225,7 @@ library MarketMathCore {
         /// ------------------------------------------------------------
         MarketPreCompute memory comp = getMarketPreCompute(market, index, blockTime);
 
-        (netScyToAccount, netScyToReserve) = calcTrade(market, comp, index, netPtToAccount);
+        (netSyToAccount, netSyToReserve) = calcTrade(market, comp, index, netPtToAccount);
 
         /// ------------------------------------------------------------
         /// WRITE
@@ -238,8 +235,8 @@ library MarketMathCore {
             comp,
             index,
             netPtToAccount,
-            netScyToAccount,
-            netScyToReserve,
+            netSyToAccount,
+            netSyToReserve,
             blockTime
         );
     }
@@ -254,7 +251,7 @@ library MarketMathCore {
         uint256 timeToExpiry = market.expiry - blockTime;
 
         res.rateScalar = _getRateScalar(market, timeToExpiry);
-        res.totalAsset = index.scyToAsset(market.totalScy);
+        res.totalAsset = index.syToAsset(market.totalSy);
 
         if (market.totalPt == 0 || res.totalAsset == 0)
             revert Errors.MarketZeroTotalPtOrTotalAsset(market.totalPt, res.totalAsset);
@@ -274,7 +271,7 @@ library MarketMathCore {
         MarketPreCompute memory comp,
         PYIndex index,
         int256 netPtToAccount
-    ) internal pure returns (int256 netScyToAccount, int256 netScyToReserve) {
+    ) internal pure returns (int256 netSyToAccount, int256 netSyToReserve) {
         int256 preFeeExchangeRate = _getExchangeRate(
             market.totalPt,
             comp.totalAsset,
@@ -299,10 +296,10 @@ library MarketMathCore {
         int256 netAssetToReserve = (fee * market.reserveFeePercent.Int()) / PERCENTAGE_DECIMALS;
         int256 netAssetToAccount = preFeeAssetToAccount - fee;
 
-        netScyToAccount = netAssetToAccount < 0
-            ? index.assetToScyUp(netAssetToAccount)
-            : index.assetToScy(netAssetToAccount);
-        netScyToReserve = index.assetToScy(netAssetToReserve);
+        netSyToAccount = netAssetToAccount < 0
+            ? index.assetToSyUp(netAssetToAccount)
+            : index.assetToSy(netAssetToAccount);
+        netSyToReserve = index.assetToSy(netAssetToReserve);
     }
 
     function _setNewMarketStateTrade(
@@ -310,18 +307,18 @@ library MarketMathCore {
         MarketPreCompute memory comp,
         PYIndex index,
         int256 netPtToAccount,
-        int256 netScyToAccount,
-        int256 netScyToReserve,
+        int256 netSyToAccount,
+        int256 netSyToReserve,
         uint256 blockTime
     ) internal pure {
         uint256 timeToExpiry = market.expiry - blockTime;
 
         market.totalPt = market.totalPt.subNoNeg(netPtToAccount);
-        market.totalScy = market.totalScy.subNoNeg(netScyToAccount + netScyToReserve);
+        market.totalSy = market.totalSy.subNoNeg(netSyToAccount + netSyToReserve);
 
         market.lastLnImpliedRate = _getLnImpliedRate(
             market.totalPt,
-            index.scyToAsset(market.totalScy),
+            index.syToAsset(market.totalSy),
             comp.rateScalar,
             comp.rateAnchor,
             timeToExpiry
@@ -432,7 +429,7 @@ library MarketMathCore {
         /// ------------------------------------------------------------
         /// MATH
         /// ------------------------------------------------------------
-        int256 totalAsset = index.scyToAsset(market.totalScy);
+        int256 totalAsset = index.syToAsset(market.totalSy);
         uint256 timeToExpiry = market.expiry - blockTime;
         int256 rateScalar = _getRateScalar(market, timeToExpiry);
 

package/contracts/core/Market/PendleGauge.sol

@@ -4,7 +4,7 @@ pragma solidity 0.8.17;
 import "../../interfaces/IPGauge.sol";
 import "../../interfaces/IPVeToken.sol";
 import "../../interfaces/IPGaugeController.sol";
-import "../../interfaces/ISuperComposableYield.sol";
+import "../../interfaces/IStandardizedYield.sol";
 
 import "../RewardManager/RewardManager.sol";
 
@@ -17,7 +17,7 @@ abstract contract PendleGauge is RewardManager, IPGauge {
     using SafeERC20 for IERC20;
     using ArrayLib for address[];
 
-    address private immutable SCY;
+    address private immutable SY;
 
     uint256 internal constant TOKENLESS_PRODUCTION = 40;
 
@@ -29,11 +29,11 @@ abstract contract PendleGauge is RewardManager, IPGauge {
     mapping(address => uint256) public activeBalance;
 
     constructor(
-        address _SCY,
+        address _SY,
         address _vePendle,
         address _gaugeController
     ) {
-        SCY = _SCY;
+        SY = _SY;
         vePENDLE = IPVeToken(_vePendle);
         gaugeController = _gaugeController;
         PENDLE = IPGaugeController(gaugeController).pendle();
@@ -94,7 +94,7 @@ abstract contract PendleGauge is RewardManager, IPGauge {
     }
 
     function _redeemExternalReward() internal virtual override {
-        ISuperComposableYield(SCY).claimRewards(address(this));
+        IStandardizedYield(SY).claimRewards(address(this));
         IPGaugeController(gaugeController).redeemMarketReward();
     }
 
@@ -111,9 +111,9 @@ abstract contract PendleGauge is RewardManager, IPGauge {
     }
 
     function _getRewardTokens() internal view virtual override returns (address[] memory) {
-        address[] memory SCYRewards = ISuperComposableYield(SCY).getRewardTokens();
-        if (SCYRewards.contains(PENDLE)) return SCYRewards;
-        return SCYRewards.append(PENDLE);
+        address[] memory SYRewards = IStandardizedYield(SY).getRewardTokens();
+        if (SYRewards.contains(PENDLE)) return SYRewards;
+        return SYRewards.append(PENDLE);
     }
 
     function _beforeTokenTransfer(

package/contracts/core/Market/PendleMarket.sol

@@ -11,7 +11,7 @@ import "./OracleLib.sol";
 
 /**
 Invariance to maintain:
-- Internal balances totalPt & totalScy not interfered by people transferring tokens in directly
+- Internal balances totalPt & totalSy not interfered by people transferring tokens in directly
 - 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
 */
@@ -25,7 +25,7 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
 
     struct MarketStorage {
         int128 totalPt;
-        int128 totalScy;
+        int128 totalSy;
         // 1 SLOT = 256 bits
         uint96 lastLnImpliedRate;
         uint16 observationIndex;
@@ -38,7 +38,7 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
     string private constant SYMBOL = "PENDLE-LPT";
 
     IPPrincipalToken internal immutable PT;
-    ISuperComposableYield internal immutable SCY;
+    IStandardizedYield internal immutable SY;
     IPYieldToken internal immutable YT;
 
     address public immutable factory;
@@ -63,10 +63,10 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
         address _gaugeController
     )
         PendleERC20Permit(NAME, SYMBOL, 18)
-        PendleGauge(IPPrincipalToken(_PT).SCY(), _vePendle, _gaugeController)
+        PendleGauge(IPPrincipalToken(_PT).SY(), _vePendle, _gaugeController)
     {
         PT = IPPrincipalToken(_PT);
-        SCY = ISuperComposableYield(PT.SCY());
+        SY = IStandardizedYield(PT.SY());
         YT = IPYieldToken(PT.YT());
 
         (_storage.observationCardinality, _storage.observationCardinalityNext) = observations
@@ -81,12 +81,12 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
     }
 
     /**
-     * @notice PendleMarket allows users to provide in PT & SCY in exchange for LPs, which
+     * @notice PendleMarket allows users to provide in PT & SY in exchange for LPs, which
      * will grant LP holders more exchange fee over time
      */
     function mint(
         address receiver,
-        uint256 netScyDesired,
+        uint256 netSyDesired,
         uint256 netPtDesired
     )
         external
@@ -94,7 +94,7 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
         notExpired
         returns (
             uint256 netLpOut,
-            uint256 netScyUsed,
+            uint256 netSyUsed,
             uint256 netPtUsed
         )
     {
@@ -103,8 +103,8 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
 
         uint256 lpToReserve;
 
-        (lpToReserve, netLpOut, netScyUsed, netPtUsed) = market.addLiquidity(
-            netScyDesired,
+        (lpToReserve, netLpOut, netSyUsed, netPtUsed) = market.addLiquidity(
+            netSyDesired,
             netPtDesired,
             block.timestamp
         );
@@ -119,120 +119,120 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
 
         _writeState(market);
 
-        if (_selfBalance(SCY) < market.totalScy.Uint())
-            revert Errors.MarketInsufficientScyReceived(_selfBalance(SCY), market.totalScy.Uint());
+        if (_selfBalance(SY) < market.totalSy.Uint())
+            revert Errors.MarketInsufficientSyReceived(_selfBalance(SY), market.totalSy.Uint());
         if (_selfBalance(PT) < market.totalPt.Uint())
             revert Errors.MarketInsufficientPtReceived(_selfBalance(PT), market.totalPt.Uint());
 
-        emit Mint(receiver, netLpOut, netScyUsed, netPtUsed);
+        emit Mint(receiver, netLpOut, netSyUsed, netPtUsed);
     }
 
     /**
-     * @notice LP Holders can burn their LP to receive back SCY & PT proportionally
+     * @notice LP Holders can burn their LP to receive back SY & PT proportionally
      * to their share of market
      */
     function burn(
-        address receiverScy,
+        address receiverSy,
         address receiverPt,
         uint256 netLpToBurn
-    ) external nonReentrant returns (uint256 netScyOut, uint256 netPtOut) {
+    ) external nonReentrant returns (uint256 netSyOut, uint256 netPtOut) {
         MarketState memory market = readState();
 
         _burn(address(this), netLpToBurn);
 
-        (netScyOut, netPtOut) = market.removeLiquidity(netLpToBurn);
+        (netSyOut, netPtOut) = market.removeLiquidity(netLpToBurn);
 
-        if (receiverScy != address(this)) IERC20(SCY).safeTransfer(receiverScy, netScyOut);
+        if (receiverSy != address(this)) IERC20(SY).safeTransfer(receiverSy, netSyOut);
         if (receiverPt != address(this)) IERC20(PT).safeTransfer(receiverPt, netPtOut);
 
         _writeState(market);
 
-        emit Burn(receiverScy, receiverPt, netLpToBurn, netScyOut, netPtOut);
+        emit Burn(receiverSy, receiverPt, netLpToBurn, netSyOut, netPtOut);
     }
 
     /**
-     * @notice Pendle Market allows swaps between PT & SCY it is holding. This function
-     * aims to swap an exact amount of PT to SCY.
+     * @notice Pendle Market allows swaps between PT & SY it is holding. This function
+     * aims to swap an exact amount of PT to SY.
      * @dev steps working of this contract
-       - The outcome amount of SCY will be precomputed by MarketMathLib
-       - Release the calculated amount of SCY to receiver
+       - The outcome amount of SY will be precomputed by MarketMathLib
+       - Release the calculated amount of SY to receiver
        - Callback to msg.sender if data.length > 0
        - Ensure exactPtIn amount of PT has been transferred to this address
      * @param data bytes data to be sent in the callback
      */
-    function swapExactPtForScy(
+    function swapExactPtForSy(
         address receiver,
         uint256 exactPtIn,
         bytes calldata data
-    ) external nonReentrant notExpired returns (uint256 netScyOut, uint256 netScyToReserve) {
+    ) external nonReentrant notExpired returns (uint256 netSyOut, uint256 netSyToReserve) {
         MarketState memory market = readState();
 
-        (netScyOut, netScyToReserve) = market.swapExactPtForScy(
+        (netSyOut, netSyToReserve) = market.swapExactPtForSy(
             YT.newIndex(),
             exactPtIn,
             block.timestamp
         );
 
-        if (receiver != address(this)) IERC20(SCY).safeTransfer(receiver, netScyOut);
-        IERC20(SCY).safeTransfer(market.treasury, netScyToReserve);
+        if (receiver != address(this)) IERC20(SY).safeTransfer(receiver, netSyOut);
+        IERC20(SY).safeTransfer(market.treasury, netSyToReserve);
 
         _writeState(market);
 
         if (data.length > 0) {
-            IPMarketSwapCallback(msg.sender).swapCallback(exactPtIn.neg(), netScyOut.Int(), data);
+            IPMarketSwapCallback(msg.sender).swapCallback(exactPtIn.neg(), netSyOut.Int(), data);
         }
 
         if (_selfBalance(PT) < market.totalPt.Uint())
             revert Errors.MarketInsufficientPtReceived(_selfBalance(PT), market.totalPt.Uint());
 
-        emit Swap(receiver, exactPtIn.neg(), netScyOut.Int(), netScyToReserve);
+        emit Swap(receiver, exactPtIn.neg(), netSyOut.Int(), netSyToReserve);
     }
 
     /**
-     * @notice Pendle Market allows swaps between PT & SCY it is holding. This function
-     * aims to swap an exact amount of SCY to PT.
+     * @notice Pendle Market allows swaps between PT & SY it is holding. This function
+     * aims to swap an exact amount of SY to PT.
      * @dev steps working of this function
        - The exact outcome amount of PT will be transferred to receiver
        - Callback to msg.sender if data.length > 0
-       - Ensure the calculated required amount of SCY is transferred to this address
+       - Ensure the calculated required amount of SY is transferred to this address
      * @param data bytes data to be sent in the callback
      */
-    function swapScyForExactPt(
+    function swapSyForExactPt(
         address receiver,
         uint256 exactPtOut,
         bytes calldata data
-    ) external nonReentrant notExpired returns (uint256 netScyIn, uint256 netScyToReserve) {
+    ) external nonReentrant notExpired returns (uint256 netSyIn, uint256 netSyToReserve) {
         MarketState memory market = readState();
 
-        (netScyIn, netScyToReserve) = market.swapScyForExactPt(
+        (netSyIn, netSyToReserve) = market.swapSyForExactPt(
             YT.newIndex(),
             exactPtOut,
             block.timestamp
         );
 
         if (receiver != address(this)) IERC20(PT).safeTransfer(receiver, exactPtOut);
-        IERC20(SCY).safeTransfer(market.treasury, netScyToReserve);
+        IERC20(SY).safeTransfer(market.treasury, netSyToReserve);
 
         _writeState(market);
 
         if (data.length > 0) {
-            IPMarketSwapCallback(msg.sender).swapCallback(exactPtOut.Int(), netScyIn.neg(), data);
+            IPMarketSwapCallback(msg.sender).swapCallback(exactPtOut.Int(), netSyIn.neg(), data);
         }
 
-        // have received enough SCY
-        if (_selfBalance(SCY) < market.totalScy.Uint())
-            revert Errors.MarketInsufficientScyReceived(_selfBalance(SCY), market.totalScy.Uint());
+        // have received enough SY
+        if (_selfBalance(SY) < market.totalSy.Uint())
+            revert Errors.MarketInsufficientSyReceived(_selfBalance(SY), market.totalSy.Uint());
 
-        emit Swap(receiver, exactPtOut.Int(), netScyIn.neg(), netScyToReserve);
+        emit Swap(receiver, exactPtOut.Int(), netSyIn.neg(), netSyToReserve);
     }
 
     /// @notice force balances to match reserves
     function skim() external nonReentrant {
         MarketState memory market = readState();
         uint256 excessPt = _selfBalance(PT) - market.totalPt.Uint();
-        uint256 excessScy = _selfBalance(SCY) - market.totalScy.Uint();
+        uint256 excessSy = _selfBalance(SY) - market.totalSy.Uint();
         IERC20(PT).safeTransfer(market.treasury, excessPt);
-        IERC20(SCY).safeTransfer(market.treasury, excessScy);
+        IERC20(SY).safeTransfer(market.treasury, excessSy);
     }
 
     function redeemRewards(address user) external nonReentrant returns (uint256[] memory) {
@@ -280,7 +280,7 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
      */
     function readState() public view returns (MarketState memory market) {
         market.totalPt = _storage.totalPt;
-        market.totalScy = _storage.totalScy;
+        market.totalSy = _storage.totalSy;
         market.totalLp = totalSupply().Int();
 
         (market.treasury, market.lnFeeRateRoot, market.reserveFeePercent) = IPMarketFactory(
@@ -297,7 +297,7 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
     function _writeState(MarketState memory market) internal {
         uint96 lastLnImpliedRate96 = market.lastLnImpliedRate.Uint96();
         int128 totalPt128 = market.totalPt.Int128();
-        int128 totalScy128 = market.totalScy.Int128();
+        int128 totalSy128 = market.totalSy.Int128();
 
         (uint16 observationIndex, uint16 observationCardinality) = observations.write(
             _storage.observationIndex,
@@ -308,7 +308,7 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
         );
 
         _storage.totalPt = totalPt128;
-        _storage.totalScy = totalScy128;
+        _storage.totalSy = totalSy128;
         _storage.lastLnImpliedRate = lastLnImpliedRate96;
         _storage.observationIndex = observationIndex;
         _storage.observationCardinality = observationCardinality;
@@ -324,12 +324,12 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
         external
         view
         returns (
-            ISuperComposableYield _SCY,
+            IStandardizedYield _SY,
             IPPrincipalToken _PT,
             IPYieldToken _YT
         )
     {
-        _SCY = SCY;
+        _SY = SY;
         _PT = PT;
         _YT = YT;
     }

package/contracts/core/Market/PendleMarketFactory.sol

@@ -72,7 +72,7 @@ contract PendleMarketFactory is BoringOwnableUpgradeable, IPMarketFactory {
     }
 
     /**
-     * @notice Create a market between PT and its corresponding SCY
+     * @notice Create a market between PT and its corresponding SY
      * with scalar & anchor config. Anyone is allowed to create a market on their own.
      */
     function createNewMarket(

package/contracts/core/RewardManager/RewardManager.sol

@@ -3,7 +3,7 @@ pragma solidity 0.8.17;
 
 import "./RewardManagerAbstract.sol";
 
-/// NOTE: This RewardManager is used with PendleMarket & SCY. For YT, it will use RewardManagerAbstract
+/// NOTE: This RewardManager is used with PendleMarket & SY. For YT, it will use RewardManagerAbstract
 /// NOTE: RewardManager must not have duplicated rewardTokens
 abstract contract RewardManager is RewardManagerAbstract {
     using Math for uint256;