@pendle/core-v2 0.8.1-beta → 0.9.0-gamma-2

package/contracts/core/YieldContracts/PendlePrincipalToken.sol

@@ -4,11 +4,11 @@ pragma solidity 0.8.15;
 import "../../interfaces/IPPrincipalToken.sol";
 import "../../interfaces/IPYieldToken.sol";
 
-import "../PendleERC20Permit.sol";
+import "../PendleERC20.sol";
 import "../../libraries/helpers/MiniHelpers.sol";
 import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 
-contract PendlePrincipalToken is PendleERC20Permit, Initializable, IPPrincipalToken {
+contract PendlePrincipalToken is PendleERC20, Initializable, IPPrincipalToken {
     address public immutable SCY;
     address public immutable factory;
     uint256 public immutable expiry;
@@ -30,7 +30,7 @@ contract PendlePrincipalToken is PendleERC20Permit, Initializable, IPPrincipalTo
         string memory _symbol,
         uint8 __decimals,
         uint256 _expiry
-    ) PendleERC20Permit(_name, _symbol, __decimals) {
+    ) PendleERC20(_name, _symbol, __decimals) {
         SCY = _SCY;
         expiry = _expiry;
         factory = msg.sender;

package/contracts/core/YieldContracts/PendleYieldContractFactory.sol

@@ -98,7 +98,7 @@ contract PendleYieldContractFactory is PermissionsV2Upg, Initializable, IPYieldC
         // no need salt since PT (and also YT) existence has been checked before hand
         PT = SSTORE2Deployer.create2(
             type(PendlePrincipalToken).creationCode,
-            bytes32(0),
+            bytes32(block.chainid),
             abi.encode(
                 SCY,
                 PT_PREFIX.concat(_SCY.name(), expiry, " "),
@@ -110,7 +110,7 @@ contract PendleYieldContractFactory is PermissionsV2Upg, Initializable, IPYieldC
 
         YT = SSTORE2Deployer.create2(
             pendleYtCreationCodePointer,
-            bytes32(0),
+            bytes32(block.chainid),
             abi.encode(
                 SCY,
                 PT,

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,7 +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);
+        return SCYUtils.scyToAsset(pyIndexCurrent(), amountScy);
     }
 
     function _calcScyRedeemableFromPY(uint256 amountPY, uint256 indexCurrent)
@@ -260,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;
         }
     }
@@ -281,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++) {
@@ -299,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
@@ -120,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/ActionCore.sol

@@ -13,8 +13,8 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
     using Math for int256;
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variabless
-    constructor(address _joeFactory, address _marketFactory)
-        ActionSCYAndPYBase(_joeFactory) //solhint-disable-next-line no-empty-blocks
+    constructor(address _kyberSwapRouter, address _marketFactory)
+        ActionSCYAndPYBase(_kyberSwapRouter) //solhint-disable-next-line no-empty-blocks
     {}
 
     /// @dev refer to the internal function
@@ -48,7 +48,7 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
         address market,
         uint256 netPtIn,
         uint256 minLpOut,
-        ApproxParams memory guessPtSwapToScy
+        ApproxParams calldata guessPtSwapToScy
     ) external returns (uint256 netLpOut) {
         require(false, "NOT IMPLEMENTED");
     }
@@ -58,18 +58,17 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
         address market,
         uint256 netScyIn,
         uint256 minLpOut,
-        ApproxParams memory guessPtReceivedFromScy
+        ApproxParams calldata guessPtReceivedFromScy
     ) external returns (uint256 netLpOut) {
         require(false, "NOT IMPLEMENTED");
     }
 
-    function addLiquiditySingleRawToken(
+    function addLiquiditySingleToken(
         address receiver,
         address market,
-        uint256 netRawTokenIn,
         uint256 minLpOut,
-        address[] calldata path,
-        ApproxParams memory guessPtReceivedFromScy
+        ApproxParams calldata guessPtReceivedFromScy,
+        TokenInput calldata input
     ) external returns (uint256 netLpOut) {
         require(false, "NOT IMPLEMENTED");
     }
@@ -98,7 +97,7 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
         address market,
         uint256 lpToRemove,
         uint256 minPtOut,
-        ApproxParams memory guessPtOut
+        ApproxParams calldata guessPtOut
     ) external returns (uint256 netPtOut) {
         require(false, "NOT IMPLEMENTED");
     }
@@ -112,13 +111,12 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
         require(false, "NOT IMPLEMENTED");
     }
 
-    function removeLiquiditySingleRawToken(
+    function removeLiquiditySingleToken(
         address receiver,
         address market,
         uint256 lpToRemove,
-        uint256 minRawTokenOut,
-        address[] memory path
-    ) external returns (uint256 netRawTokenOut) {
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut) {
         require(false, "NOT IMPLEMENTED");
     }
 
@@ -139,7 +137,7 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
         address market,
         uint256 exactScyOut,
         uint256 maxPtIn,
-        ApproxParams memory guessPtIn
+        ApproxParams calldata guessPtIn
     ) external returns (uint256 netPtIn) {
         netPtIn = _swapPtForExactScy(receiver, market, exactScyOut, maxPtIn, guessPtIn, true);
         emit SwapPtAndScy(msg.sender, market, receiver, netPtIn.neg(), exactScyOut.Int());
@@ -162,71 +160,62 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
         address market,
         uint256 exactScyIn,
         uint256 minPtOut,
-        ApproxParams memory guessPtOut
+        ApproxParams calldata guessPtOut
     ) external returns (uint256 netPtOut) {
         netPtOut = _swapExactScyForPt(receiver, market, exactScyIn, minPtOut, guessPtOut, true);
         emit SwapPtAndScy(msg.sender, market, receiver, netPtOut.Int(), exactScyIn.neg());
     }
 
     /// @dev refer to the internal function
-    function mintScyFromRawToken(
+    function mintScyFromToken(
         address receiver,
         address SCY,
-        uint256 netRawTokenIn,
         uint256 minScyOut,
-        address[] calldata path
+        TokenInput calldata input
     ) external returns (uint256 netScyOut) {
-        return _mintScyFromRawToken(receiver, SCY, netRawTokenIn, minScyOut, path, true);
+        netScyOut = _mintScyFromToken(receiver, SCY, minScyOut, input);
+
+        emit MintScyFromToken(
+            msg.sender,
+            receiver,
+            SCY,
+            input.tokenIn,
+            input.netTokenIn,
+            netScyOut
+        );
     }
 
     /// @dev refer to the internal function
-    function redeemScyToRawToken(
+    function redeemScyToToken(
         address receiver,
         address SCY,
         uint256 netScyIn,
-        uint256 minRawTokenOut,
-        address[] memory path
-    ) external returns (uint256 netRawTokenOut) {
-        netRawTokenOut = _redeemScyToRawToken(receiver, SCY, netScyIn, minRawTokenOut, path, true);
-        emit RedeemScyToRawToken(
-            msg.sender,
-            receiver,
-            SCY,
-            netScyIn,
-            path[path.length - 1],
-            netRawTokenOut
-        );
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut) {
+        netTokenOut = _redeemScyToToken(receiver, SCY, netScyIn, output, true);
+        emit RedeemScyToToken(msg.sender, receiver, SCY, netScyIn, output.tokenOut, netTokenOut);
     }
 
     /// @dev refer to the internal function
-    function mintPyFromRawToken(
+    function mintPyFromToken(
         address receiver,
         address YT,
-        uint256 netRawTokenIn,
         uint256 minPyOut,
-        address[] calldata path
+        TokenInput calldata input
     ) external returns (uint256 netPyOut) {
-        netPyOut = _mintPyFromRawToken(receiver, YT, netRawTokenIn, minPyOut, path, true);
-        emit MintPyFromRawToken(msg.sender, receiver, YT, path[0], netRawTokenIn, netPyOut);
+        netPyOut = _mintPyFromToken(receiver, YT, minPyOut, input);
+        emit MintPyFromToken(msg.sender, receiver, YT, input.tokenIn, input.netTokenIn, netPyOut);
     }
 
     /// @dev refer to the internal function
-    function redeemPyToRawToken(
+    function redeemPyToToken(
         address receiver,
         address YT,
         uint256 netPyIn,
-        uint256 minRawTokenOut,
-        address[] memory path
-    ) external returns (uint256 netRawTokenOut) {
-        netRawTokenOut = _redeemPyToRawToken(receiver, YT, netPyIn, minRawTokenOut, path, true);
-        emit RedeemPyToRawToken(
-            msg.sender,
-            receiver,
-            YT,
-            netPyIn,
-            path[path.length - 1],
-            netRawTokenOut
-        );
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut) {
+        netTokenOut = _redeemPyToToken(receiver, YT, netPyIn, output, true);
+        emit RedeemPyToToken(msg.sender, receiver, YT, netPyIn, output.tokenOut, netTokenOut);
     }
 
     function mintPyFromScy(
@@ -250,57 +239,41 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
     }
 
     /// @dev refer to the internal function
-    function swapExactRawTokenForPt(
+    function swapExactTokenForPt(
         address receiver,
         address market,
-        uint256 exactRawTokenIn,
         uint256 minPtOut,
-        address[] calldata path,
-        ApproxParams memory guessPtOut
+        ApproxParams calldata guessPtOut,
+        TokenInput calldata input
     ) external returns (uint256 netPtOut) {
-        netPtOut = _swapExactRawTokenForPt(
-            receiver,
-            market,
-            exactRawTokenIn,
-            minPtOut,
-            path,
-            guessPtOut,
-            true
-        );
+        netPtOut = _swapExactTokenForPt(receiver, market, minPtOut, guessPtOut, input);
 
-        emit SwapPtAndRawToken(
+        emit SwapPtAndToken(
             msg.sender,
             market,
-            path[0],
+            input.tokenIn,
             receiver,
             netPtOut.Int(),
-            exactRawTokenIn.neg()
+            input.netTokenIn.neg()
         );
     }
 
     /// @dev refer to the internal function
-    function swapExactPtForRawToken(
+    function swapExactPtForToken(
         address receiver,
         address market,
         uint256 exactPtIn,
-        uint256 minRawTokenOut,
-        address[] calldata path
-    ) external returns (uint256 netRawTokenOut) {
-        netRawTokenOut = _swapExactPtForRawToken(
-            receiver,
-            market,
-            exactPtIn,
-            minRawTokenOut,
-            path,
-            true
-        );
-        emit SwapPtAndRawToken(
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut) {
+        netTokenOut = _swapExactPtForToken(receiver, market, exactPtIn, output, true);
+
+        emit SwapPtAndToken(
             msg.sender,
             market,
-            path[path.length - 1],
+            output.tokenOut,
             receiver,
             exactPtIn.neg(),
-            netRawTokenOut.Int()
+            netTokenOut.Int()
         );
     }
 

package/contracts/core/actions/ActionYT.sol

@@ -12,12 +12,9 @@ contract ActionYT is IPActionYT, ActionSCYAndYTBase {
     using Math for int256;
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
-    constructor(address _joeFactory)
-        ActionSCYAndPYBase(_joeFactory)
-    //solhint-disable-next-line no-empty-blocks
-    {
-
-    }
+    constructor(address _kyberSwapRouter)
+        ActionSCYAndPYBase(_kyberSwapRouter) //solhint-disable-next-line no-empty-blocks
+    {}
 
     /// @dev refer to the internal function
     function swapExactYtForScy(
@@ -66,48 +63,31 @@ contract ActionYT is IPActionYT, ActionSCYAndYTBase {
     }
 
     /// @dev refer to the internal function
-    function swapExactRawTokenForYt(
+    function swapExactTokenForYt(
         address receiver,
         address market,
-        uint256 exactRawTokenIn,
         uint256 minYtOut,
-        address[] calldata path,
-        ApproxParams memory guessYtOut
+        ApproxParams memory guessYtOut,
+        TokenInput calldata input
     ) external returns (uint256 netYtOut) {
-        netYtOut = _swapExactRawTokenForYt(
+        netYtOut = _swapExactTokenForYt(receiver, market, minYtOut, guessYtOut, input);
+        emit SwapYTAndToken(
             receiver,
             market,
-            exactRawTokenIn,
-            minYtOut,
-            path,
-            guessYtOut,
-            true
+            input.tokenIn,
+            netYtOut.Int(),
+            input.netTokenIn.neg()
         );
-        emit SwapYTAndRawToken(receiver, market, path[0], netYtOut.Int(), exactRawTokenIn.neg());
     }
 
     /// @dev refer to the internal function
-    function swapExactYtForRawToken(
+    function swapExactYtForToken(
         address receiver,
         address market,
-        uint256 exactYtIn,
-        uint256 minRawTokenOut,
-        address[] calldata path
-    ) external returns (uint256 netRawTokenOut) {
-        netRawTokenOut = _swapExactYtForRawToken(
-            receiver,
-            market,
-            exactYtIn,
-            minRawTokenOut,
-            path,
-            true
-        );
-        emit SwapYTAndRawToken(
-            receiver,
-            market,
-            path[path.length - 1],
-            exactYtIn.neg(),
-            netRawTokenOut.Int()
-        );
+        uint256 netYtIn,
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut) {
+        netTokenOut = _swapExactYtForToken(receiver, market, netYtIn, output, true);
+        emit SwapYTAndToken(receiver, market, output.tokenOut, netYtIn.neg(), netTokenOut.Int());
     }
 }