@pendle/core-v2 0.4.0 → 0.5.0

package/contracts/SuperComposableYield/implementations/IRewardManager.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+
+interface IRewardManager {
+    function getGlobalReward(address rewardToken)
+        external
+        view
+        returns (uint256 index, uint256 lastBalance);
+
+    function getUserReward(address user, address rewardToken)
+        external
+        view
+        returns (uint256 lastIndex, uint256 accruedReward);
+
+    function getRewardTokens() external view returns (address[] memory);
+}

package/contracts/SuperComposableYield/implementations/RewardManager.sol

@@ -1,10 +1,11 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.9;
 import "../ISuperComposableYield.sol";
+import "./IRewardManager.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import "../../libraries/math/Math.sol";
 
-abstract contract RewardManager {
+abstract contract RewardManager is IRewardManager {
     using SafeERC20 for IERC20;
     using Math for uint256;
 
@@ -20,8 +21,28 @@ abstract contract RewardManager {
 
     uint256 internal constant INITIAL_REWARD_INDEX = 1;
 
-    mapping(address => GlobalReward) public globalReward;
-    mapping(address => mapping(address => UserReward)) public userReward;
+    mapping(address => GlobalReward) internal globalReward;
+    mapping(address => mapping(address => UserReward)) internal userReward;
+
+    function getGlobalReward(address rewardToken)
+        external
+        view
+        returns (uint256 index, uint256 lastBalance)
+    {
+        GlobalReward memory reward = globalReward[rewardToken];
+        return (reward.index, reward.lastBalance);
+    }
+
+    function getUserReward(address user, address rewardToken)
+        external
+        view
+        returns (uint256 lastIndex, uint256 accruedReward)
+    {
+        UserReward memory reward = userReward[user][rewardToken];
+        return (reward.lastIndex, reward.accruedReward);
+    }
+
+    function getRewardTokens() public view virtual override returns (address[] memory);
 
     function _doTransferOutRewardsForUser(address user, address receiver)
         internal
@@ -111,7 +132,5 @@ abstract contract RewardManager {
         }
     }
 
-    function getRewardTokens() public view virtual returns (address[] memory);
-
     function _redeemExternalReward() internal virtual;
 }

package/contracts/core/PendleMarket.sol

@@ -34,31 +34,19 @@ contract PendleMarket is PendleBaseToken, IPMarket, ReentrancyGuard {
     address public immutable YT;
 
     int256 public immutable scalarRoot;
-    uint256 public immutable feeRateRoot; // allow fee to be changable?
     int256 public immutable initialAnchor;
 
-    uint256 public immutable rateOracleTimeWindow;
-    int8 public immutable reserveFeePercent;
-
     MarketStorage public marketStorage;
 
     constructor(
         address _OT,
-        uint256 _rateOracleTimeWindow,
-        uint256 _feeRateRoot,
         int256 _scalarRoot,
-        int256 _initialAnchor,
-        uint8 _reserveFeePercent
+        int256 _initialAnchor
     ) PendleBaseToken(NAME, SYMBOL, 18, IPOwnershipToken(_OT).expiry()) {
         OT = _OT;
         SCY = IPOwnershipToken(_OT).SCY();
         YT = IPOwnershipToken(_OT).YT();
-        feeRateRoot = _feeRateRoot;
         scalarRoot = _scalarRoot;
-        rateOracleTimeWindow = _rateOracleTimeWindow;
-
-        require(_reserveFeePercent <= 100, "invalid fee rate");
-        reserveFeePercent = int8(_reserveFeePercent);
         initialAnchor = _initialAnchor;
     }
 
@@ -154,7 +142,7 @@ contract PendleMarket is PendleBaseToken, IPMarket, ReentrancyGuard {
         );
         require(netScyOut >= minScyOut, "insufficient scy out");
         IERC20(SCY).safeTransfer(receiver, netScyOut);
-        IERC20(SCY).safeTransfer(IPMarketFactory(factory).treasury(), netScyToReserve);
+        IERC20(SCY).safeTransfer(market.treasury, netScyToReserve);
 
         if (data.length > 0) {
             IPMarketSwapCallback(msg.sender).swapCallback(exactOtIn.neg(), netScyOut.Int(), data);
@@ -183,7 +171,7 @@ contract PendleMarket is PendleBaseToken, IPMarket, ReentrancyGuard {
         );
         require(netScyIn <= maxScyIn, "scy in exceed limit");
         IERC20(OT).safeTransfer(receiver, exactOtOut);
-        IERC20(SCY).safeTransfer(IPMarketFactory(factory).treasury(), netScyToReserve);
+        IERC20(SCY).safeTransfer(market.treasury, netScyToReserve);
 
         if (data.length > 0) {
             IPMarketSwapCallback(msg.sender).swapCallback(exactOtOut.Int(), netScyIn.neg(), data);
@@ -206,11 +194,15 @@ contract PendleMarket is PendleBaseToken, IPMarket, ReentrancyGuard {
         market.totalScy = store.totalScy;
         market.totalLp = totalSupply().Int();
         market.oracleRate = store.oracleRate;
-        market.reserveFeePercent = reserveFeePercent;
+
+        (
+            market.treasury,
+            market.feeRateRoot,
+            market.rateOracleTimeWindow,
+            market.reserveFeePercent
+        ) = IPMarketFactory(factory).marketConfig();
 
         market.scalarRoot = scalarRoot;
-        market.feeRateRoot = feeRateRoot;
-        market.rateOracleTimeWindow = rateOracleTimeWindow;
         market.expiry = expiry;
 
         market.lastImpliedRate = store.lastImpliedRate;

package/contracts/core/PendleMarketFactory.sol

@@ -10,24 +10,40 @@ import "./PendleMarket.sol";
 contract PendleMarketFactory is PermissionsV2Upg, IPMarketFactory {
     using EnumerableSet for EnumerableSet.AddressSet;
 
+    struct MarketConfig {
+        address treasury; // 160 bit
+        uint96 feeRateRoot; // 96 bit
+        // 1 SLOT
+        uint32 rateOracleTimeWindow;
+        uint8 reserveFeePercent;
+    }
+
     mapping(address => EnumerableSet.AddressSet) internal markets;
 
     address public immutable yieldContractFactory;
-    address public treasury;
 
-    constructor(address _governanceManager, address _yieldContractFactory)
-        PermissionsV2Upg(_governanceManager)
-    {
+    MarketConfig public marketConfig;
+
+    constructor(
+        address _governanceManager,
+        address _yieldContractFactory,
+        address _treasury,
+        uint96 _feeRateRoot,
+        uint32 _rateOracleTimeWindow,
+        uint8 _reserveFeePercent
+    ) PermissionsV2Upg(_governanceManager) {
         yieldContractFactory = _yieldContractFactory;
+
+        setTreasury(_treasury);
+        setFeeRateRoot(_feeRateRoot);
+        setRateOracleTimeWindow(_rateOracleTimeWindow);
+        setReserveFeePercent(_reserveFeePercent);
     }
 
     function createNewMarket(
         address OT,
-        uint256 feeRateRoot,
         int256 scalarRoot,
-        int256 initialAnchor,
-        uint8 reserveFeePercent,
-        uint256 rateOracleTimeWindow
+        int256 initialAnchor
     ) external returns (address market) {
         address SCY = IPOwnershipToken(OT).SCY();
         uint256 expiry = IPOwnershipToken(OT).expiry();
@@ -37,25 +53,36 @@ contract PendleMarketFactory is PermissionsV2Upg, IPMarketFactory {
             "INVALID_OT"
         );
 
-        market = address(
-            new PendleMarket(
-                OT,
-                rateOracleTimeWindow,
-                feeRateRoot,
-                scalarRoot,
-                initialAnchor,
-                reserveFeePercent
-            )
-        );
+        market = address(new PendleMarket(OT, scalarRoot, initialAnchor));
         markets[OT].add(market);
     }
 
-    function setTreasury(address newTreasury) external onlyGovernance {
-        treasury = newTreasury;
-    }
-
     function isValidMarket(address market) external view returns (bool) {
         address OT = IPMarket(market).OT();
         return markets[OT].contains(market);
     }
+
+    function treasury() external view returns (address) {
+        return marketConfig.treasury;
+    }
+
+    function setTreasury(address newTreasury) public onlyGovernance {
+        require(newTreasury != address(0), "zero address");
+        marketConfig.treasury = newTreasury;
+    }
+
+    function setFeeRateRoot(uint96 newFeeRateRoot) public onlyGovernance {
+        // TODO: hard cap on the fee
+        marketConfig.feeRateRoot = newFeeRateRoot;
+    }
+
+    function setRateOracleTimeWindow(uint32 newRateOracleTimeWindow) public onlyGovernance {
+        // TODO: hard min for the time window
+        marketConfig.rateOracleTimeWindow = newRateOracleTimeWindow;
+    }
+
+    function setReserveFeePercent(uint8 newReserveFeePercent) public onlyGovernance {
+        require(newReserveFeePercent <= 100, "invalid fee rate");
+        marketConfig.reserveFeePercent = newReserveFeePercent;
+    }
 }

package/contracts/core/PendleRouter.sol

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts/proxy/Proxy.sol";
+import "../interfaces/IPActionCore.sol";
+import "../interfaces/IPActionYT.sol";
+import "../interfaces/IPRouterStatic.sol";
+import "../interfaces/IPMarketSwapCallback.sol";
+import "../periphery/PermissionsV2Upg.sol";
+
+/// @dev this contract will be deployed behind an ERC1967 proxy
+/// calls to the ERC1967 proxy will be resolved at this contract, and proxied again to the
+/// corresponding implementation contracts
+
+// solhint-disable no-empty-blocks
+contract PendleRouter is Proxy, Initializable, UUPSUpgradeable, PermissionsV2Upg {
+    address public immutable ACTION_CORE;
+    address public immutable ACTION_YT;
+    address public immutable ACTION_CALLBACK;
+
+    constructor(
+        address _ACTION_CORE,
+        address _ACTION_YT,
+        address _ACTION_CALLBACK,
+        address _governanceManager
+    ) PermissionsV2Upg(_governanceManager) initializer {
+        ACTION_CORE = _ACTION_CORE;
+        ACTION_YT = _ACTION_YT;
+        ACTION_CALLBACK = _ACTION_CALLBACK;
+    }
+
+    function initialize() external initializer {
+        __UUPSUpgradeable_init();
+        // no need to initialize PermissionsV2Upg
+    }
+
+    function getRouterImplementation(bytes4 sig) public view returns (address) {
+        if (
+            sig == IPActionCore.mintScyFromRawToken.selector ||
+            sig == IPActionCore.redeemScyToRawToken.selector ||
+            sig == IPActionCore.mintYoFromRawToken.selector ||
+            sig == IPActionCore.redeemYoToRawToken.selector ||
+            sig == IPActionCore.addLiquidity.selector ||
+            sig == IPActionCore.removeLiquidity.selector ||
+            sig == IPActionCore.swapExactOtForScy.selector ||
+            sig == IPActionCore.swapOtForExactScy.selector ||
+            sig == IPActionCore.swapScyForExactOt.selector ||
+            sig == IPActionCore.swapExactScyForOt.selector ||
+            sig == IPActionCore.swapExactRawTokenForOt.selector ||
+            sig == IPActionCore.swapExactOtForRawToken.selector
+        ) {
+            return ACTION_CORE;
+        } else if (
+            sig == IPActionYT.swapExactYtForScy.selector ||
+            sig == IPActionYT.swapScyForExactYt.selector ||
+            sig == IPActionYT.swapExactScyForYt.selector ||
+            sig == IPActionYT.swapExactRawTokenForYt.selector ||
+            sig == IPActionYT.swapExactYtForRawToken.selector
+        ) {
+            return ACTION_YT;
+        } else if (sig == IPMarketSwapCallback.swapCallback.selector) {
+            return ACTION_CALLBACK;
+        }
+        require(false, "invalid market sig");
+    }
+
+    function _implementation() internal view override returns (address) {
+        return getRouterImplementation(msg.sig);
+    }
+
+    function _authorizeUpgrade(address newImplementation) internal override onlyGovernance {}
+}

package/contracts/core/PendleYieldToken.sol

@@ -19,11 +19,11 @@ It has been proven and tested that impliedScyBalance will not change over time,
 
 Due to this, it is required to update users' accruedReward STRICTLY BEFORE redeeming their interest.
 */
-contract PendleYieldToken is PendleBaseToken, IPYieldToken, RewardManager {
+contract PendleYieldToken is PendleBaseToken, RewardManager, IPYieldToken {
     using Math for uint256;
     using SafeERC20 for IERC20;
 
-    struct UserData {
+    struct InterestData {
         uint256 lastScyIndex;
         uint256 dueInterest;
     }
@@ -40,7 +40,7 @@ contract PendleYieldToken is PendleBaseToken, IPYieldToken, RewardManager {
     mapping(address => uint256) public totalRewardsPostExpiry;
     uint256 public totalProtocolFee;
 
-    mapping(address => UserData) public data;
+    mapping(address => InterestData) internal interestData;
 
     constructor(
         address _SCY,
@@ -118,13 +118,13 @@ contract PendleYieldToken is PendleBaseToken, IPYieldToken, RewardManager {
     }
 
     function updateUserInterest(address user) public {
-        uint256 prevIndex = data[user].lastScyIndex;
+        uint256 prevIndex = interestData[user].lastScyIndex;
 
         uint256 currentIndex = getScyIndexBeforeExpiry();
 
         if (prevIndex == currentIndex) return;
         if (prevIndex == 0) {
-            data[user].lastScyIndex = currentIndex;
+            interestData[user].lastScyIndex = currentIndex;
             return;
         }
 
@@ -134,8 +134,16 @@ contract PendleYieldToken is PendleBaseToken, IPYieldToken, RewardManager {
             prevIndex * currentIndex
         );
 
-        data[user].dueInterest += interestFromYT;
-        data[user].lastScyIndex = currentIndex;
+        interestData[user].dueInterest += interestFromYT;
+        interestData[user].lastScyIndex = currentIndex;
+    }
+
+    function getInterestData(address user)
+        external
+        view
+        returns (uint256 lastScyIndex, uint256 dueInterest)
+    {
+        return (interestData[user].lastScyIndex, interestData[user].dueInterest);
     }
 
     function _updateGlobalReward(address[] memory rewardTokens, uint256 totalSupply)
@@ -165,8 +173,8 @@ contract PendleYieldToken is PendleBaseToken, IPYieldToken, RewardManager {
     }
 
     function _doTransferOutDueInterest(address user) internal returns (uint256 interestOut) {
-        uint256 interestPreFee = data[user].dueInterest;
-        data[user].dueInterest = 0;
+        uint256 interestPreFee = interestData[user].dueInterest;
+        interestData[user].dueInterest = 0;
 
         uint256 feeRate = IPYieldContractFactory(factory).interestFeeRate();
         uint256 feeAmount = interestPreFee.mulDown(feeRate);
@@ -185,7 +193,7 @@ contract PendleYieldToken is PendleBaseToken, IPYieldToken, RewardManager {
         public
         view
         virtual
-        override(RewardManager)
+        override(RewardManager, IRewardManager)
         returns (address[] memory)
     {
         return ISuperComposableYield(SCY).getRewardTokens();
@@ -247,9 +255,9 @@ contract PendleYieldToken is PendleBaseToken, IPYieldToken, RewardManager {
     }
 
     function getImpliedScyBalance(address user) public view returns (uint256) {
-        uint256 scyIndex = data[user].lastScyIndex;
+        uint256 scyIndex = interestData[user].lastScyIndex;
         if (scyIndex == 0) return 0;
-        return SCYUtils.assetToScy(scyIndex, balanceOf(user)) + data[user].dueInterest;
+        return SCYUtils.assetToScy(scyIndex, balanceOf(user)) + interestData[user].dueInterest;
     }
 
     function _beforeTokenTransfer(

package/contracts/core/{router/PendleRouterStaticUpg.sol → RouterStatic.sol}

@@ -1,15 +1,15 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.9;
 
-import "../../interfaces/IPRouterStatic.sol";
-import "../../interfaces/IPMarket.sol";
-import "../../interfaces/IPYieldContractFactory.sol";
-import "../../interfaces/IPMarketFactory.sol";
-import "../../libraries/math/MarketMathAux.sol";
+import "../interfaces/IPRouterStatic.sol";
+import "../interfaces/IPMarket.sol";
+import "../interfaces/IPYieldContractFactory.sol";
+import "../interfaces/IPMarketFactory.sol";
+import "../libraries/math/MarketMathAux.sol";
 import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
 import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
 
-contract PendleRouterStaticUpg is IPRouterStatic {
+contract RouterStatic is IPRouterStatic {
     using MarketMathCore for MarketState;
     using MarketMathAux for MarketState;
     using Math for uint256;

package/contracts/core/actions/ActionCallback.sol

@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+
+import "../../interfaces/IPMarketFactory.sol";
+import "../../interfaces/IPMarket.sol";
+import "../../interfaces/IPMarketAddRemoveCallback.sol";
+import "../../interfaces/IPMarketSwapCallback.sol";
+import "../../SuperComposableYield/SCYUtils.sol";
+import "../../libraries/math/MarketApproxLib.sol";
+import "../../libraries/math/MarketMathAux.sol";
+import "./base/ActionSCYAndYOBase.sol";
+import "./base/ActionType.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+contract ActionCallback is IPMarketSwapCallback, ActionType {
+    address public immutable marketFactory;
+    using Math for int256;
+    using Math for uint256;
+    using SafeERC20 for ISuperComposableYield;
+    using SafeERC20 for IPYieldToken;
+
+    modifier onlyPendleMarket(address market) {
+        require(IPMarketFactory(marketFactory).isValidMarket(market), "INVALID_MARKET");
+        _;
+    }
+
+    /// @dev since this contract will be proxied, it must not contains non-immutable variables
+    constructor(address _marketFactory) {
+        marketFactory = _marketFactory;
+    }
+
+    function swapCallback(
+        int256 otToAccount,
+        int256 scyToAccount,
+        bytes calldata data
+    ) external override onlyPendleMarket(msg.sender) {
+        (ACTION_TYPE swapType, ) = abi.decode(data, (ACTION_TYPE, bytes));
+
+        if (swapType == ACTION_TYPE.SwapExactScyForYt) {
+            _swapExactScyForYt_callback(msg.sender, data);
+        } else if (swapType == ACTION_TYPE.SwapSCYForExactYt) {
+            _swapScyForExactYt_callback(msg.sender, otToAccount, scyToAccount, data);
+        } else if (
+            swapType == ACTION_TYPE.SwapYtForExactScy || swapType == ACTION_TYPE.SwapExactYtForScy
+        ) {
+            _swapYtForScy_callback(msg.sender, scyToAccount, data);
+        } else {
+            require(false, "unknown swapType");
+        }
+    }
+
+    function _swapExactScyForYt_callback(address market, bytes calldata data) internal {
+        (, , IPYieldToken YT) = IPMarket(market).readTokens();
+        (, address receiver) = abi.decode(data, (ACTION_TYPE, address));
+
+        YT.mintYO(market, receiver);
+    }
+
+    function _swapScyForExactYt_callback(
+        address market,
+        int256 otToAccount,
+        int256 scyToAccount,
+        bytes calldata data
+    ) internal {
+        (, address payer, address receiver) = abi.decode(data, (ACTION_TYPE, address, address));
+        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
+
+        uint256 otOwed = otToAccount.neg().Uint();
+        uint256 scyReceived = scyToAccount.Uint();
+
+        // otOwed = totalAsset
+        uint256 scyNeedTotal = SCYUtils.assetToScy(SCY.scyIndexCurrent(), otOwed);
+
+        uint256 netScyToPull = scyNeedTotal.subMax0(scyReceived);
+        SCY.safeTransferFrom(payer, address(YT), netScyToPull);
+
+        YT.mintYO(market, receiver);
+    }
+
+    /**
+    @dev receive OT -> pair with YT to redeem SCY -> payback SCY
+    */
+    function _swapYtForScy_callback(
+        address market,
+        int256 scyToAccount,
+        bytes calldata data
+    ) internal {
+        (, address receiver) = abi.decode(data, (ACTION_TYPE, address));
+        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
+
+        uint256 scyOwed = scyToAccount.neg().Uint();
+
+        uint256 netScyReceived = YT.redeemYO(address(this));
+
+        SCY.safeTransfer(market, scyOwed);
+
+        if (receiver != address(this)) {
+            SCY.safeTransfer(receiver, netScyReceived - scyOwed);
+        }
+    }
+}

package/contracts/core/{router/PendleRouterCoreUpg.sol → actions/ActionCore.sol}

@@ -1,18 +1,14 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.9;
 
-import "./base/PendleRouterSCYAndForgeBaseUpg.sol";
-import "./base/PendleRouterOTBaseUpg.sol";
+import "./base/ActionSCYAndOTBase.sol";
+import "./base/ActionSCYAndYOBase.sol";
 import "../../interfaces/IPOwnershipToken.sol";
 import "../../interfaces/IPYieldToken.sol";
-import "../../interfaces/IPRouterCore.sol";
+import "../../interfaces/IPActionCore.sol";
 import "../../libraries/math/MarketMathAux.sol";
 
-contract PendleRouterCoreUpg is
-    IPRouterCore,
-    PendleRouterSCYAndForgeBaseUpg,
-    PendleRouterOTBaseUpg
-{
+contract ActionCore is IPActionCore, ActionSCYAndOTBase, ActionSCYAndYOBase {
     using MarketMathCore for MarketState;
     using MarketMathAux for MarketState;
     using Math for uint256;
@@ -24,8 +20,8 @@ contract PendleRouterCoreUpg is
         address _joeFactory,
         address _marketFactory
     )
-        PendleRouterSCYAndForgeBaseUpg(_joeRouter, _joeFactory)
-        PendleRouterOTBaseUpg()
+        ActionSCYAndYOBase(_joeRouter, _joeFactory)
+        ActionSCYAndOTBase()
     //solhint-disable-next-line no-empty-blocks
     {
 

package/contracts/core/{router/PendleRouterYTUpg.sol → actions/ActionYT.sol}

@@ -1,27 +1,22 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.9;
 
-import "./base/PendleRouterSCYAndForgeBaseUpg.sol";
-import "./base/PendleRouterYTBaseUpg.sol";
+import "./base/ActionSCYAndYTBase.sol";
 import "../../interfaces/IPOwnershipToken.sol";
 import "../../interfaces/IPYieldToken.sol";
-import "../../interfaces/IPRouterYT.sol";
+import "../../interfaces/IPActionYT.sol";
 import "../../libraries/math/MarketMathAux.sol";
 
-contract PendleRouterYTUpg is IPRouterYT, PendleRouterSCYAndForgeBaseUpg, PendleRouterYTBaseUpg {
+contract ActionYT is IPActionYT, ActionSCYAndYTBase {
     using MarketMathCore for MarketState;
     using MarketMathAux for MarketState;
     using Math for uint256;
     using Math for int256;
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
-    constructor(
-        address _joeRouter,
-        address _joeFactory,
-        address _marketFactory
-    )
-        PendleRouterSCYAndForgeBaseUpg(_joeRouter, _joeFactory)
-        PendleRouterYTBaseUpg(_marketFactory)
+    constructor(address _joeRouter, address _joeFactory)
+        ActionSCYAndYOBase(_joeRouter, _joeFactory)
+        ActionSCYAndYTBase()
     //solhint-disable-next-line no-empty-blocks
     {
 

package/contracts/core/{router/base/PendleRouterOTBaseUpg.sol → actions/base/ActionSCYAndOTBase.sol}

@@ -9,7 +9,7 @@ import "../../../libraries/math/MarketApproxLib.sol";
 import "../../../libraries/math/MarketMathAux.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
-abstract contract PendleRouterOTBaseUpg {
+abstract contract ActionSCYAndOTBase {
     using Math for uint256;
     using Math for int256;
     using MarketMathCore for MarketState;
@@ -18,10 +18,6 @@ abstract contract PendleRouterOTBaseUpg {
     using SafeERC20 for IERC20;
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
-    constructor() //solhint-disable-next-line no-empty-blocks
-    {
-
-    }
 
     /**
      * @notice addLiquidity to the market, using both SCY & OT, the receiver will receive LP before

package/contracts/core/{router/base/PendleRouterSCYAndForgeBaseUpg.sol → actions/base/ActionSCYAndYOBase.sol}

@@ -6,16 +6,14 @@ import "../../../periphery/PendleJoeSwapHelperUpg.sol";
 import "../../../SuperComposableYield/ISuperComposableYield.sol";
 import "../../../interfaces/IPYieldToken.sol";
 
-abstract contract PendleRouterSCYAndForgeBaseUpg is PendleJoeSwapHelperUpg {
+// solhint-disable no-empty-blocks
+abstract contract ActionSCYAndYOBase is PendleJoeSwapHelperUpg {
     using SafeERC20 for IERC20;
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
     constructor(address _joeRouter, address _joeFactory)
         PendleJoeSwapHelperUpg(_joeRouter, _joeFactory)
-    // solhint-disable-next-line no-empty-blocks
-    {
-
-    }
+    {}
 
     /**
      * @notice swap rawToken to baseToken -> baseToken to mint SCY