@pendle/core-v2 0.13.1-testnet → 0.15.0-mainnet

package/contracts/interfaces/IPActionMintRedeem.sol

@@ -5,38 +5,38 @@ import "../router/base/MarketApproxLib.sol";
 import "../router/kyberswap/KyberSwapHelper.sol";
 
 interface IPActionMintRedeem {
-    event MintScyFromToken(
+    event MintSyFromToken(
         address indexed caller,
         address indexed receiver,
-        address indexed SCY,
+        address indexed SY,
         address tokenIn,
         uint256 netTokenIn,
-        uint256 netScyOut
+        uint256 netSyOut
     );
 
-    event RedeemScyToToken(
+    event RedeemSyToToken(
         address indexed caller,
         address indexed receiver,
-        address indexed SCY,
-        uint256 netScyIn,
+        address indexed SY,
+        uint256 netSyIn,
         address tokenOut,
         uint256 netTokenOut
     );
 
-    event MintPyFromScy(
+    event MintPyFromSy(
         address indexed caller,
         address indexed receiver,
         address indexed YT,
-        uint256 netScyIn,
+        uint256 netSyIn,
         uint256 netPyOut
     );
 
-    event RedeemPyToScy(
+    event RedeemPyToSy(
         address indexed caller,
         address indexed receiver,
         address indexed YT,
         uint256 netPyIn,
-        uint256 netScyOut
+        uint256 netSyOut
     );
 
     event MintPyFromToken(
@@ -59,10 +59,10 @@ interface IPActionMintRedeem {
 
     event RedeemDueInterestAndRewards(
         address indexed user,
-        address[] scys,
+        address[] sys,
         address[] yts,
         address[] markets,
-        uint256[][] scyRewards,
+        uint256[][] syRewards,
         uint256[] ytInterests,
         uint256[][] ytRewards,
         uint256[][] marketRewards
@@ -70,24 +70,24 @@ interface IPActionMintRedeem {
 
     event RedeemDueInterestAndRewardsThenSwapAll(
         address indexed user,
-        address[] scys,
+        address[] sys,
         address[] yts,
         address[] markets,
         address indexed tokenOut,
         uint256 netTokenOut
     );
 
-    function mintScyFromToken(
+    function mintSyFromToken(
         address receiver,
-        address SCY,
-        uint256 minScyOut,
+        address SY,
+        uint256 minSyOut,
         TokenInput calldata input
-    ) external payable returns (uint256 netScyOut);
+    ) external payable returns (uint256 netSyOut);
 
-    function redeemScyToToken(
+    function redeemSyToToken(
         address receiver,
-        address SCY,
-        uint256 netScyIn,
+        address SY,
+        uint256 netSyIn,
         TokenOutput calldata output
     ) external returns (uint256 netTokenOut);
 
@@ -105,29 +105,29 @@ interface IPActionMintRedeem {
         TokenOutput calldata output
     ) external returns (uint256 netTokenOut);
 
-    function mintPyFromScy(
+    function mintPyFromSy(
         address receiver,
         address YT,
-        uint256 netScyIn,
+        uint256 netSyIn,
         uint256 minPyOut
     ) external returns (uint256 netPyOut);
 
-    function redeemPyToScy(
+    function redeemPyToSy(
         address receiver,
         address YT,
         uint256 netPyIn,
-        uint256 minScyOut
-    ) external returns (uint256 netScyOut);
+        uint256 minSyOut
+    ) external returns (uint256 netSyOut);
 
     function redeemDueInterestAndRewards(
         address user,
-        address[] calldata scys,
+        address[] calldata sys,
         address[] calldata yts,
         address[] calldata markets
     )
         external
         returns (
-            uint256[][] memory scyRewards,
+            uint256[][] memory syRewards,
             uint256[] memory ytInterests,
             uint256[][] memory ytRewards,
             uint256[][] memory marketRewards
@@ -136,8 +136,8 @@ interface IPActionMintRedeem {
     struct RouterYtRedeemStruct {
         address[] yts;
         // key-value pair
-        address[] scyAddrs;
-        address[] tokenRedeemScys;
+        address[] syAddrs;
+        address[] tokenRedeemSys;
         //
     }
 
@@ -151,7 +151,7 @@ interface IPActionMintRedeem {
     }
 
     function redeemDueInterestAndRewardsThenSwapAll(
-        address[] calldata scys,
+        address[] calldata sys,
         RouterYtRedeemStruct calldata dataYT,
         address[] calldata markets,
         RouterSwapAllStruct calldata dataSwap

package/contracts/interfaces/IPActionSwapPT.sol

@@ -5,12 +5,12 @@ import "../router/base/MarketApproxLib.sol";
 import "../router/kyberswap/KyberSwapHelper.sol";
 
 interface IPActionSwapPT {
-    event SwapPtAndScy(
+    event SwapPtAndSy(
         address indexed caller,
         address indexed market,
         address indexed receiver,
         int256 netPtToAccount,
-        int256 netScyToAccount
+        int256 netSyToAccount
     );
 
     event SwapPtAndToken(
@@ -22,35 +22,35 @@ interface IPActionSwapPT {
         int256 netTokenToAccount
     );
 
-    function swapExactPtForScy(
+    function swapExactPtForSy(
         address receiver,
         address market,
         uint256 exactPtIn,
-        uint256 minScyOut
-    ) external returns (uint256 netScyOut, uint256 netScyFee);
+        uint256 minSyOut
+    ) external returns (uint256 netSyOut, uint256 netSyFee);
 
-    function swapPtForExactScy(
+    function swapPtForExactSy(
         address receiver,
         address market,
-        uint256 exactScyOut,
+        uint256 exactSyOut,
         uint256 maxPtIn,
         ApproxParams calldata guessPtIn
-    ) external returns (uint256 netPtIn, uint256 netScyFee);
+    ) external returns (uint256 netPtIn, uint256 netSyFee);
 
-    function swapScyForExactPt(
+    function swapSyForExactPt(
         address receiver,
         address market,
         uint256 exactPtOut,
-        uint256 maxScyIn
-    ) external returns (uint256 netScyIn, uint256 netScyFee);
+        uint256 maxSyIn
+    ) external returns (uint256 netSyIn, uint256 netSyFee);
 
-    function swapExactScyForPt(
+    function swapExactSyForPt(
         address receiver,
         address market,
-        uint256 exactScyIn,
+        uint256 exactSyIn,
         uint256 minPtOut,
         ApproxParams calldata guessPtOut
-    ) external returns (uint256 netPtOut, uint256 netScyFee);
+    ) external returns (uint256 netPtOut, uint256 netSyFee);
 
     function swapExactTokenForPt(
         address receiver,
@@ -58,12 +58,12 @@ interface IPActionSwapPT {
         uint256 minPtOut,
         ApproxParams calldata guessPtOut,
         TokenInput calldata input
-    ) external payable returns (uint256 netPtOut, uint256 netScyFee);
+    ) external payable returns (uint256 netPtOut, uint256 netSyFee);
 
     function swapExactPtForToken(
         address receiver,
         address market,
         uint256 exactPtIn,
         TokenOutput calldata output
-    ) external returns (uint256 netTokenOut, uint256 netScyFee);
+    ) external returns (uint256 netTokenOut, uint256 netSyFee);
 }

package/contracts/interfaces/IPActionSwapPTYT.sol

@@ -19,7 +19,7 @@ interface IPActionSwapPTYT {
         uint256 exactPtIn,
         uint256 minYtOut,
         ApproxParams calldata guessTotalPtToSwap
-    ) external returns (uint256 netYtOut, uint256 netScyFee);
+    ) external returns (uint256 netYtOut, uint256 netSyFee);
 
     function swapExactYtForPt(
         address receiver,
@@ -27,5 +27,5 @@ interface IPActionSwapPTYT {
         uint256 exactYtIn,
         uint256 minPtOut,
         ApproxParams calldata guessTotalPtSwapped
-    ) external returns (uint256 netPtOut, uint256 netScyFee);
+    ) external returns (uint256 netPtOut, uint256 netSyFee);
 }

package/contracts/interfaces/IPActionSwapYT.sol

@@ -5,12 +5,12 @@ import "../router/base/MarketApproxLib.sol";
 import "../router/kyberswap/KyberSwapHelper.sol";
 
 interface IPActionSwapYT {
-    event SwapYtAndScy(
+    event SwapYtAndSy(
         address indexed caller,
         address indexed market,
         address indexed receiver,
         int256 netYtToAccount,
-        int256 netScyToAccount
+        int256 netSyToAccount
     );
 
     event SwapYtAndToken(
@@ -22,35 +22,35 @@ interface IPActionSwapYT {
         int256 netTokenToAccount
     );
 
-    function swapExactScyForYt(
+    function swapExactSyForYt(
         address receiver,
         address market,
-        uint256 exactScyIn,
+        uint256 exactSyIn,
         uint256 minYtOut,
         ApproxParams memory guessYtOut
-    ) external returns (uint256 netYtOut, uint256 netScyFee);
+    ) external returns (uint256 netYtOut, uint256 netSyFee);
 
-    function swapExactYtForScy(
+    function swapExactYtForSy(
         address receiver,
         address market,
         uint256 exactYtIn,
-        uint256 minScyOut
-    ) external returns (uint256 netScyOut, uint256 netScyFee);
+        uint256 minSyOut
+    ) external returns (uint256 netSyOut, uint256 netSyFee);
 
-    function swapScyForExactYt(
+    function swapSyForExactYt(
         address receiver,
         address market,
         uint256 exactYtOut,
-        uint256 maxScyIn
-    ) external returns (uint256 netScyIn, uint256 netScyFee);
+        uint256 maxSyIn
+    ) external returns (uint256 netSyIn, uint256 netSyFee);
 
-    function swapYtForExactScy(
+    function swapYtForExactSy(
         address receiver,
         address market,
-        uint256 exactScyOut,
+        uint256 exactSyOut,
         uint256 maxYtIn,
         ApproxParams memory guessYtIn
-    ) external returns (uint256 netYtIn, uint256 netScyFee);
+    ) external returns (uint256 netYtIn, uint256 netSyFee);
 
     function swapExactTokenForYt(
         address receiver,
@@ -58,12 +58,12 @@ interface IPActionSwapYT {
         uint256 minYtOut,
         ApproxParams memory guessYtOut,
         TokenInput calldata input
-    ) external payable returns (uint256 netYtOut, uint256 netScyFee);
+    ) external payable returns (uint256 netYtOut, uint256 netSyFee);
 
     function swapExactYtForToken(
         address receiver,
         address market,
         uint256 netYtIn,
         TokenOutput calldata output
-    ) external returns (uint256 netTokenOut, uint256 netScyFee);
+    ) external returns (uint256 netTokenOut, uint256 netSyFee);
 }

package/contracts/interfaces/IPMarket.sol

@@ -4,7 +4,7 @@ pragma solidity 0.8.17;
 import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import "./IPPrincipalToken.sol";
 import "./IPYieldToken.sol";
-import "./ISuperComposableYield.sol";
+import "./IStandardizedYield.sol";
 import "./IPGauge.sol";
 import "../core/Market/MarketMathCore.sol";
 
@@ -12,24 +12,19 @@ interface IPMarket is IERC20Metadata, IPGauge {
     event Mint(
         address indexed receiver,
         uint256 netLpMinted,
-        uint256 netScyUsed,
+        uint256 netSyUsed,
         uint256 netPtUsed
     );
 
     event Burn(
-        address indexed receiverScy,
+        address indexed receiverSy,
         address indexed receiverPt,
         uint256 netLpBurned,
-        uint256 netScyOut,
+        uint256 netSyOut,
         uint256 netPtOut
     );
 
-    event Swap(
-        address indexed receiver,
-        int256 netPtOut,
-        int256 netScyOut,
-        uint256 netScyToReserve
-    );
+    event Swap(address indexed receiver, int256 netPtOut, int256 netSyOut, uint256 netSyToReserve);
 
     event UpdateImpliedRate(uint256 indexed timestamp, uint256 lnLastImpliedRate);
 
@@ -40,33 +35,33 @@ interface IPMarket is IERC20Metadata, IPGauge {
 
     function mint(
         address receiver,
-        uint256 netScyDesired,
+        uint256 netSyDesired,
         uint256 netPtDesired
     )
         external
         returns (
             uint256 netLpOut,
-            uint256 netScyUsed,
+            uint256 netSyUsed,
             uint256 netPtUsed
         );
 
     function burn(
-        address receiverScy,
+        address receiverSy,
         address receiverPt,
         uint256 netLpToBurn
-    ) external returns (uint256 netScyOut, uint256 netPtOut);
+    ) external returns (uint256 netSyOut, uint256 netPtOut);
 
-    function swapExactPtForScy(
+    function swapExactPtForSy(
         address receiver,
         uint256 exactPtIn,
         bytes calldata data
-    ) external returns (uint256 netScyOut, uint256 netScyToReserve);
+    ) external returns (uint256 netSyOut, uint256 netSyToReserve);
 
-    function swapScyForExactPt(
+    function swapSyForExactPt(
         address receiver,
         uint256 exactPtOut,
         bytes calldata data
-    ) external returns (uint256 netScyIn, uint256 netScyToReserve);
+    ) external returns (uint256 netSyIn, uint256 netSyToReserve);
 
     function redeemRewards(address user) external returns (uint256[] memory);
 
@@ -83,7 +78,7 @@ interface IPMarket is IERC20Metadata, IPGauge {
         external
         view
         returns (
-            ISuperComposableYield _SCY,
+            IStandardizedYield _SY,
             IPPrincipalToken _PT,
             IPYieldToken _YT
         );

package/contracts/interfaces/IPMarketSwapCallback.sol

@@ -4,7 +4,7 @@ pragma solidity 0.8.17;
 interface IPMarketSwapCallback {
     function swapCallback(
         int256 ptToAccount,
-        int256 scyToAccount,
+        int256 syToAccount,
         bytes calldata data
     ) external;
 }

package/contracts/interfaces/IPPrincipalToken.sol

@@ -9,7 +9,7 @@ interface IPPrincipalToken is IERC20Metadata {
 
     function initialize(address _YT) external;
 
-    function SCY() external view returns (address);
+    function SY() external view returns (address);
 
     function YT() external view returns (address);
 

package/contracts/interfaces/IPYieldContractFactory.sol

@@ -24,7 +24,7 @@
 pragma solidity 0.8.17;
 
 interface IPYieldContractFactory {
-    event CreateYieldContract(address indexed SCY, address PT, address YT, uint256 expiry);
+    event CreateYieldContract(address indexed SY, address PT, address YT, uint256 expiry);
 
     event SetExpiryDivisor(uint256 newExpiryDivisor);
 
@@ -34,9 +34,9 @@ interface IPYieldContractFactory {
 
     event SetTreasury(address indexed treasury);
 
-    function getPT(address SCY, uint256 expiry) external view returns (address);
+    function getPT(address SY, uint256 expiry) external view returns (address);
 
-    function getYT(address SCY, uint256 expiry) external view returns (address);
+    function getYT(address SY, uint256 expiry) external view returns (address);
 
     function expiryDivisor() external view returns (uint96);
 

package/contracts/interfaces/IPYieldToken.sol

@@ -5,15 +5,13 @@ import "./IRewardManager.sol";
 import "./IPInterestManagerYT.sol";
 
 interface IPYieldToken is IERC20Metadata, IRewardManager, IPInterestManagerYT {
-    event NewInterestIndex(
-        uint256 indexed newIndex
-    );
+    event NewInterestIndex(uint256 indexed newIndex);
 
     event Mint(
         address indexed caller,
         address indexed receiverPT,
         address indexed receiverYT,
-        uint256 amountScyToMint,
+        uint256 amountSyToMint,
         uint256 amountPYOut
     );
 
@@ -21,22 +19,22 @@ interface IPYieldToken is IERC20Metadata, IRewardManager, IPInterestManagerYT {
         address indexed caller,
         address indexed receiver,
         uint256 amountPYToRedeem,
-        uint256 amountScyOut
+        uint256 amountSyOut
     );
 
     event RedeemRewards(address indexed user, uint256[] amountRewardsOut);
 
     event RedeemInterest(address indexed user, uint256 interestOut);
 
-    event WithdrawFeeToTreasury(uint256[] amountRewardsOut, uint256 scyOut);
+    event WithdrawFeeToTreasury(uint256[] amountRewardsOut, uint256 syOut);
 
     function mintPY(address receiverPT, address receiverYT) external returns (uint256 amountPYOut);
 
-    function redeemPY(address receiver) external returns (uint256 amountScyOut);
+    function redeemPY(address receiver) external returns (uint256 amountSyOut);
 
     function redeemPYMulti(address[] calldata receivers, uint256[] calldata amountPYToRedeems)
         external
-        returns (uint256[] memory amountScyOuts);
+        returns (uint256[] memory amountSyOuts);
 
     function redeemDueInterestAndRewards(
         address user,
@@ -52,7 +50,7 @@ interface IPYieldToken is IERC20Metadata, IRewardManager, IPInterestManagerYT {
 
     function getRewardTokens() external view returns (address[] memory);
 
-    function SCY() external view returns (address);
+    function SY() external view returns (address);
 
     function PT() external view returns (address);
 

package/contracts/interfaces/{ISuperComposableYield.sol → IStandardizedYield.sol}

@@ -24,14 +24,14 @@
 pragma solidity 0.8.17;
 import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 
-interface ISuperComposableYield is IERC20Metadata {
+interface IStandardizedYield is IERC20Metadata {
     /// @dev Emitted when any base tokens is deposited to mint shares
     event Deposit(
         address indexed caller,
         address indexed receiver,
         address indexed tokenIn,
         uint256 amountDeposited,
-        uint256 amountScyOut
+        uint256 amountSyOut
     );
 
     /// @dev Emitted when any shares are redeemed for base tokens
@@ -39,7 +39,7 @@ interface ISuperComposableYield is IERC20Metadata {
         address indexed caller,
         address indexed receiver,
         address indexed tokenOut,
-        uint256 amountScyToRedeem,
+        uint256 amountSyToRedeem,
         uint256 amountTokenOut
     );
 
@@ -92,10 +92,10 @@ interface ISuperComposableYield is IERC20Metadata {
     ) external returns (uint256 amountTokenOut);
 
     /**
-     * @notice exchangeRate * scyBalance / 1e18 must return the asset balance of the account
-     * @notice vice-versa, if a user uses some amount of tokens equivalent to X asset, the amount of scy
+     * @notice exchangeRate * syBalance / 1e18 must return the asset balance of the account
+     * @notice vice-versa, if a user uses some amount of tokens equivalent to X asset, the amount of sy
      he can mint must be X * exchangeRate / 1e18
-     * @dev SCYUtils's assetToScy & scyToAsset should be used instead of raw multiplication
+     * @dev SYUtils's assetToSy & syToAsset should be used instead of raw multiplication
      & division
      */
     function exchangeRate() external view returns (uint256 res);