@pendle/core-v2 0.4.0 → 0.5.1-beta

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

package/contracts/core/{router/base/PendleRouterYTBaseUpg.sol → actions/base/ActionSCYAndYTBase.sol}

@@ -3,14 +3,14 @@ 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 "./ActionSCYAndYOBase.sol";
+import "./ActionType.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
-abstract contract PendleRouterYTBaseUpg is IPMarketSwapCallback {
+abstract contract ActionSCYAndYTBase is ActionSCYAndYOBase, ActionType {
     using Math for uint256;
     using Math for int256;
     using MarketMathCore for MarketState;
@@ -19,28 +19,6 @@ abstract contract PendleRouterYTBaseUpg is IPMarketSwapCallback {
     using SafeERC20 for ISuperComposableYield;
     using SafeERC20 for IPYieldToken;
 
-    // solhint-disable-next-line
-    enum YT_SWAP_TYPE {
-        ExactYtForScy,
-        SCYForExactYt,
-        ExactScyForYt,
-        YtForExactScy
-    }
-
-    address public immutable marketFactory;
-
-    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 //solhint-disable-next-line no-empty-blocks
-    ) {
-        marketFactory = _marketFactory;
-    }
-
     function _swapExactScyForYt(
         address receiver,
         address market,
@@ -66,7 +44,7 @@ abstract contract PendleRouterYTBaseUpg is IPMarketSwapCallback {
             receiver,
             netYtOut, // exactOtIn = netYtOut
             1,
-            abi.encode(YT_SWAP_TYPE.ExactScyForYt, receiver)
+            abi.encode(ACTION_TYPE.SwapExactScyForYt, receiver)
         );
     }
 
@@ -96,7 +74,7 @@ abstract contract PendleRouterYTBaseUpg is IPMarketSwapCallback {
             receiver,
             exactYtIn, // exactOtOut = exactYtIn
             type(uint256).max,
-            abi.encode(YT_SWAP_TYPE.ExactYtForScy, receiver)
+            abi.encode(ACTION_TYPE.SwapExactYtForScy, receiver)
         );
 
         netScyOut = SCY.balanceOf(receiver) - preBalanceScy;
@@ -122,7 +100,7 @@ abstract contract PendleRouterYTBaseUpg is IPMarketSwapCallback {
             receiver,
             exactYtOut, // exactOtIn = exactYtOut
             1,
-            abi.encode(YT_SWAP_TYPE.SCYForExactYt, msg.sender, receiver)
+            abi.encode(ACTION_TYPE.SwapSCYForExactYt, msg.sender, receiver)
         );
 
         netScyIn = preBalanceScy - SCY.balanceOf(receiver);
@@ -155,77 +133,7 @@ abstract contract PendleRouterYTBaseUpg is IPMarketSwapCallback {
             address(YT),
             netYtIn, // exactOtOut = netYtIn
             type(uint256).max,
-            abi.encode(YT_SWAP_TYPE.YtForExactScy, receiver)
+            abi.encode(ACTION_TYPE.SwapYtForExactScy, receiver)
         );
     }
-
-    function swapCallback(
-        int256 otToAccount,
-        int256 scyToAccount,
-        bytes calldata data
-    ) external override onlyPendleMarket(msg.sender) {
-        (YT_SWAP_TYPE swapType, ) = abi.decode(data, (YT_SWAP_TYPE, bytes));
-
-        if (swapType == YT_SWAP_TYPE.ExactScyForYt) {
-            _swapExactScyForYt_callback(msg.sender, data);
-        } else if (swapType == YT_SWAP_TYPE.ExactYtForScy) {
-            _swapYtForScy_callback(msg.sender, scyToAccount, data);
-        } else if (swapType == YT_SWAP_TYPE.SCYForExactYt) {
-            _swapScyForExactYt_callback(msg.sender, otToAccount, scyToAccount, data);
-        } else if (swapType == YT_SWAP_TYPE.YtForExactScy) {
-            _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, (YT_SWAP_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, (YT_SWAP_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, (YT_SWAP_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/actions/base/ActionType.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+
+abstract contract ActionType {
+    enum ACTION_TYPE {
+        SwapExactYtForScy,
+        SwapSCYForExactYt,
+        SwapExactScyForYt,
+        SwapYtForExactScy
+    }
+}

package/contracts/interfaces/{IPRouterCore.sol → IPActionCore.sol}

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.9;
 
-interface IPRouterCore {
+interface IPActionCore {
     function addLiquidity(
         address receiver,
         address market,

package/contracts/interfaces/{IPRouterYT.sol → IPActionYT.sol}

@@ -1,9 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.9;
 
-import "./IPMarketSwapCallback.sol";
-
-interface IPRouterYT is IPMarketSwapCallback {
+interface IPActionYT {
     function swapExactYtForScy(
         address receiver,
         address market,

package/contracts/interfaces/IPAllAction.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity 0.8.9;
+
+import "./IPActionCore.sol";
+import "./IPActionYT.sol";
+import "./IPRouterStatic.sol";
+
+interface IPAllAction is IPActionCore, IPActionYT, IPRouterStatic {}

package/contracts/interfaces/IPMarketFactory.sol

@@ -5,4 +5,15 @@ interface IPMarketFactory {
     function isValidMarket(address market) external view returns (bool);
 
     function treasury() external view returns (address);
+
+    // If this is changed, change the readState function in market as well
+    function marketConfig()
+        external
+        view
+        returns (
+            address treasury,
+            uint96 feeRateRoot,
+            uint32 rateOracleTimeWindow,
+            uint8 reserveFeePercent
+        );
 }

package/contracts/interfaces/IPRouterStatic.sol

@@ -4,6 +4,33 @@ pragma solidity 0.8.9;
 import "../libraries/math/MarketMathCore.sol";
 
 interface IPRouterStatic {
+    struct TokenAmount {
+        address token;
+        uint256 amount;
+    }
+
+    struct RewardIndex {
+        address rewardToken;
+        uint256 index;
+    }
+
+    struct UserYOInfo {
+        address yt;
+        address ot;
+        uint256 ytBalance;
+        uint256 otBalance;
+        TokenAmount unclaimedInterest;
+        TokenAmount[] unclaimedRewards;
+    }
+
+    struct UserMarketInfo {
+        address market;
+        uint256 lpBalance;
+        TokenAmount otBalance;
+        TokenAmount scyBalance;
+        TokenAmount assetBalance;
+    }
+
     function addLiquidityStatic(
         address market,
         uint256 scyDesired,

package/contracts/interfaces/IPYieldToken.sol

@@ -1,15 +1,33 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.9;
 import "./IPBaseToken.sol";
+import "../SuperComposableYield/implementations/IRewardManager.sol";
 
-interface IPYieldToken is IPBaseToken {
+interface IPYieldToken is IPBaseToken, IRewardManager {
     function mintYO(address receiverOT, address receiverYT) external returns (uint256 amountYOOut);
 
     function redeemYO(address receiver) external returns (uint256 amountScyOut);
 
-    function redeemDueInterestAndRewards(address user)
+    // minimum of OT & YT balance
+
+    function redeemDueInterest(address user) external returns (uint256 interestOut);
+
+    function redeemDueRewards(address user) external returns (uint256[] memory rewardsOut);
+
+    function updateGlobalReward() external;
+
+    function updateUserReward(address user) external;
+
+    function updateUserInterest(address user) external;
+
+    function getInterestData(address user)
         external
-        returns (uint256 interestOut, uint256[] memory rewardsOut);
+        view
+        returns (uint256 lastScyIndex, uint256 dueInterest);
+
+    function getScyIndexBeforeExpiry() external returns (uint256 res);
+
+    function withdrawFeeToTreasury() external;
 
     function SCY() external view returns (address);
 

package/contracts/libraries/math/MarketMathCore.sol

@@ -10,12 +10,13 @@ struct MarketState {
     int256 totalScy;
     int256 totalLp;
     uint256 oracleRate;
+    address treasury;
     /// immutable variables ///
     int256 scalarRoot;
     uint256 feeRateRoot;
     uint256 rateOracleTimeWindow;
     uint256 expiry;
-    int256 reserveFeePercent; // base 100
+    uint256 reserveFeePercent; // base 100
     /// last trade data ///
     uint256 lastImpliedRate;
     uint256 lastTradeTime;
@@ -222,7 +223,7 @@ library MarketMathCore {
             fee = ((preFeeAssetToAccount * (Math.IONE - fee)) / fee).neg();
         }
 
-        netAssetToReserve = (fee * market.reserveFeePercent) / PERCENTAGE_DECIMALS;
+        netAssetToReserve = (fee * market.reserveFeePercent.Int()) / PERCENTAGE_DECIMALS;
         netAssetToAccount = preFeeAssetToAccount - fee;
         // netAssetToMarket = (preFeeAssetToAccount - fee + netAssetToReserve)
         //     .neg();

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "0.4.0",
+  "version": "0.5.1-beta",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",

package/typechain-types/{PendleRouterYTBaseUpg.ts → ActionCallback.ts}

@@ -22,8 +22,8 @@ import type {
   OnEvent,
 } from "./common";
 
-export interface PendleRouterYTBaseUpgInterface extends utils.Interface {
-  contractName: "PendleRouterYTBaseUpg";
+export interface ActionCallbackInterface extends utils.Interface {
+  contractName: "ActionCallback";
   functions: {
     "marketFactory()": FunctionFragment;
     "swapCallback(int256,int256,bytes)": FunctionFragment;
@@ -50,13 +50,13 @@ export interface PendleRouterYTBaseUpgInterface extends utils.Interface {
   events: {};
 }
 
-export interface PendleRouterYTBaseUpg extends BaseContract {
-  contractName: "PendleRouterYTBaseUpg";
+export interface ActionCallback extends BaseContract {
+  contractName: "ActionCallback";
   connect(signerOrProvider: Signer | Provider | string): this;
   attach(addressOrName: string): this;
   deployed(): Promise<this>;
 
-  interface: PendleRouterYTBaseUpgInterface;
+  interface: ActionCallbackInterface;
 
   queryFilter<TEvent extends TypedEvent>(
     event: TypedEventFilter<TEvent>,

package/typechain-types/{PendleRouterCoreUpg.ts → ActionCore.ts}

@@ -22,8 +22,8 @@ import type {
   OnEvent,
 } from "./common";
 
-export interface PendleRouterCoreUpgInterface extends utils.Interface {
-  contractName: "PendleRouterCoreUpg";
+export interface ActionCoreInterface extends utils.Interface {
+  contractName: "ActionCore";
   functions: {
     "addLiquidity(address,address,uint256,uint256,uint256)": FunctionFragment;
     "joeFactory()": FunctionFragment;
@@ -174,13 +174,13 @@ export interface PendleRouterCoreUpgInterface extends utils.Interface {
   events: {};
 }
 
-export interface PendleRouterCoreUpg extends BaseContract {
-  contractName: "PendleRouterCoreUpg";
+export interface ActionCore extends BaseContract {
+  contractName: "ActionCore";
   connect(signerOrProvider: Signer | Provider | string): this;
   attach(addressOrName: string): this;
   deployed(): Promise<this>;
 
-  interface: PendleRouterCoreUpgInterface;
+  interface: ActionCoreInterface;
 
   queryFilter<TEvent extends TypedEvent>(
     event: TypedEventFilter<TEvent>,

package/typechain-types/{PendleRouterSCYAndForgeBaseUpg.ts → ActionSCYAndYOBase.ts}

@@ -19,9 +19,8 @@ import type {
   OnEvent,
 } from "./common";
 
-export interface PendleRouterSCYAndForgeBaseUpgInterface
-  extends utils.Interface {
-  contractName: "PendleRouterSCYAndForgeBaseUpg";
+export interface ActionSCYAndYOBaseInterface extends utils.Interface {
+  contractName: "ActionSCYAndYOBase";
   functions: {
     "joeFactory()": FunctionFragment;
     "joeRouter()": FunctionFragment;
@@ -39,13 +38,13 @@ export interface PendleRouterSCYAndForgeBaseUpgInterface
   events: {};
 }
 
-export interface PendleRouterSCYAndForgeBaseUpg extends BaseContract {
-  contractName: "PendleRouterSCYAndForgeBaseUpg";
+export interface ActionSCYAndYOBase extends BaseContract {
+  contractName: "ActionSCYAndYOBase";
   connect(signerOrProvider: Signer | Provider | string): this;
   attach(addressOrName: string): this;
   deployed(): Promise<this>;
 
-  interface: PendleRouterSCYAndForgeBaseUpgInterface;
+  interface: ActionSCYAndYOBaseInterface;
 
   queryFilter<TEvent extends TypedEvent>(
     event: TypedEventFilter<TEvent>,