@pendle/core-v2 0.4.0 → 0.5.0

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/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.0",
   "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>,

package/typechain-types/{BoringOwnableData.ts → ActionSCYAndYTBase.ts}

@@ -19,35 +19,32 @@ import type {
   OnEvent,
 } from "./common";
 
-export interface BoringOwnableDataInterface extends utils.Interface {
-  contractName: "BoringOwnableData";
+export interface ActionSCYAndYTBaseInterface extends utils.Interface {
+  contractName: "ActionSCYAndYTBase";
   functions: {
-    "owner()": FunctionFragment;
-    "pendingOwner()": FunctionFragment;
+    "joeFactory()": FunctionFragment;
+    "joeRouter()": FunctionFragment;
   };
 
-  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
   encodeFunctionData(
-    functionFragment: "pendingOwner",
+    functionFragment: "joeFactory",
     values?: undefined
   ): string;
+  encodeFunctionData(functionFragment: "joeRouter", values?: undefined): string;
 
-  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
-  decodeFunctionResult(
-    functionFragment: "pendingOwner",
-    data: BytesLike
-  ): Result;
+  decodeFunctionResult(functionFragment: "joeFactory", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "joeRouter", data: BytesLike): Result;
 
   events: {};
 }
 
-export interface BoringOwnableData extends BaseContract {
-  contractName: "BoringOwnableData";
+export interface ActionSCYAndYTBase extends BaseContract {
+  contractName: "ActionSCYAndYTBase";
   connect(signerOrProvider: Signer | Provider | string): this;
   attach(addressOrName: string): this;
   deployed(): Promise<this>;
 
-  interface: BoringOwnableDataInterface;
+  interface: ActionSCYAndYTBaseInterface;
 
   queryFilter<TEvent extends TypedEvent>(
     event: TypedEventFilter<TEvent>,
@@ -69,32 +66,32 @@ export interface BoringOwnableData extends BaseContract {
   removeListener: OnEvent<this>;
 
   functions: {
-    owner(overrides?: CallOverrides): Promise<[string]>;
+    joeFactory(overrides?: CallOverrides): Promise<[string]>;
 
-    pendingOwner(overrides?: CallOverrides): Promise<[string]>;
+    joeRouter(overrides?: CallOverrides): Promise<[string]>;
   };
 
-  owner(overrides?: CallOverrides): Promise<string>;
+  joeFactory(overrides?: CallOverrides): Promise<string>;
 
-  pendingOwner(overrides?: CallOverrides): Promise<string>;
+  joeRouter(overrides?: CallOverrides): Promise<string>;
 
   callStatic: {
-    owner(overrides?: CallOverrides): Promise<string>;
+    joeFactory(overrides?: CallOverrides): Promise<string>;
 
-    pendingOwner(overrides?: CallOverrides): Promise<string>;
+    joeRouter(overrides?: CallOverrides): Promise<string>;
   };
 
   filters: {};
 
   estimateGas: {
-    owner(overrides?: CallOverrides): Promise<BigNumber>;
+    joeFactory(overrides?: CallOverrides): Promise<BigNumber>;
 
-    pendingOwner(overrides?: CallOverrides): Promise<BigNumber>;
+    joeRouter(overrides?: CallOverrides): Promise<BigNumber>;
   };
 
   populateTransaction: {
-    owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    joeFactory(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    pendingOwner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    joeRouter(overrides?: CallOverrides): Promise<PopulatedTransaction>;
   };
 }

package/typechain-types/{PendleRouterStaticUpg.ts → ActionStatic.ts}

@@ -22,8 +22,8 @@ import type {
   OnEvent,
 } from "./common";
 
-export interface PendleRouterStaticUpgInterface extends utils.Interface {
-  contractName: "PendleRouterStaticUpg";
+export interface ActionStaticInterface extends utils.Interface {
+  contractName: "ActionStatic";
   functions: {
     "addLiquidityStatic(address,uint256,uint256)": FunctionFragment;
     "getOtImpliedYield(address)": FunctionFragment;
@@ -107,13 +107,13 @@ export interface PendleRouterStaticUpgInterface extends utils.Interface {
   events: {};
 }
 
-export interface PendleRouterStaticUpg extends BaseContract {
-  contractName: "PendleRouterStaticUpg";
+export interface ActionStatic extends BaseContract {
+  contractName: "ActionStatic";
   connect(signerOrProvider: Signer | Provider | string): this;
   attach(addressOrName: string): this;
   deployed(): Promise<this>;
 
-  interface: PendleRouterStaticUpgInterface;
+  interface: ActionStaticInterface;
 
   queryFilter<TEvent extends TypedEvent>(
     event: TypedEventFilter<TEvent>,

package/typechain-types/{IPRouterYT.ts → ActionYT.ts}

@@ -22,10 +22,11 @@ import type {
   OnEvent,
 } from "./common";
 
-export interface IPRouterYTInterface extends utils.Interface {
-  contractName: "IPRouterYT";
+export interface ActionYTInterface extends utils.Interface {
+  contractName: "ActionYT";
   functions: {
-    "swapCallback(int256,int256,bytes)": FunctionFragment;
+    "joeFactory()": FunctionFragment;
+    "joeRouter()": FunctionFragment;
     "swapExactRawTokenForYt(uint256,address,address[],address,uint256,uint256,uint256,uint256)": FunctionFragment;
     "swapExactScyForYt(address,address,uint256,uint256,uint256,uint256,uint256)": FunctionFragment;
     "swapExactYtForRawToken(uint256,address,address[],address,uint256)": FunctionFragment;
@@ -35,9 +36,10 @@ export interface IPRouterYTInterface extends utils.Interface {
   };
 
   encodeFunctionData(
-    functionFragment: "swapCallback",
-    values: [BigNumberish, BigNumberish, BytesLike]
+    functionFragment: "joeFactory",
+    values?: undefined
   ): string;
+  encodeFunctionData(functionFragment: "joeRouter", values?: undefined): string;
   encodeFunctionData(
     functionFragment: "swapExactRawTokenForYt",
     values: [
@@ -88,10 +90,8 @@ export interface IPRouterYTInterface extends utils.Interface {
     ]
   ): string;
 
-  decodeFunctionResult(
-    functionFragment: "swapCallback",
-    data: BytesLike
-  ): Result;
+  decodeFunctionResult(functionFragment: "joeFactory", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "joeRouter", data: BytesLike): Result;
   decodeFunctionResult(
     functionFragment: "swapExactRawTokenForYt",
     data: BytesLike
@@ -120,13 +120,13 @@ export interface IPRouterYTInterface extends utils.Interface {
   events: {};
 }
 
-export interface IPRouterYT extends BaseContract {
-  contractName: "IPRouterYT";
+export interface ActionYT extends BaseContract {
+  contractName: "ActionYT";
   connect(signerOrProvider: Signer | Provider | string): this;
   attach(addressOrName: string): this;
   deployed(): Promise<this>;
 
-  interface: IPRouterYTInterface;
+  interface: ActionYTInterface;
 
   queryFilter<TEvent extends TypedEvent>(
     event: TypedEventFilter<TEvent>,
@@ -148,12 +148,9 @@ export interface IPRouterYT extends BaseContract {
   removeListener: OnEvent<this>;
 
   functions: {
-    swapCallback(
-      otToAccount: BigNumberish,
-      scyToAccount: BigNumberish,
-      data: BytesLike,
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<ContractTransaction>;
+    joeFactory(overrides?: CallOverrides): Promise<[string]>;
+
+    joeRouter(overrides?: CallOverrides): Promise<[string]>;
 
     swapExactRawTokenForYt(
       exactRawTokenIn: BigNumberish,
@@ -215,12 +212,9 @@ export interface IPRouterYT extends BaseContract {
     ): Promise<ContractTransaction>;
   };
 
-  swapCallback(
-    otToAccount: BigNumberish,
-    scyToAccount: BigNumberish,
-    data: BytesLike,
-    overrides?: Overrides & { from?: string | Promise<string> }
-  ): Promise<ContractTransaction>;
+  joeFactory(overrides?: CallOverrides): Promise<string>;
+
+  joeRouter(overrides?: CallOverrides): Promise<string>;
 
   swapExactRawTokenForYt(
     exactRawTokenIn: BigNumberish,
@@ -282,12 +276,9 @@ export interface IPRouterYT extends BaseContract {
   ): Promise<ContractTransaction>;
 
   callStatic: {
-    swapCallback(
-      otToAccount: BigNumberish,
-      scyToAccount: BigNumberish,
-      data: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<void>;
+    joeFactory(overrides?: CallOverrides): Promise<string>;
+
+    joeRouter(overrides?: CallOverrides): Promise<string>;
 
     swapExactRawTokenForYt(
       exactRawTokenIn: BigNumberish,
@@ -352,12 +343,9 @@ export interface IPRouterYT extends BaseContract {
   filters: {};
 
   estimateGas: {
-    swapCallback(
-      otToAccount: BigNumberish,
-      scyToAccount: BigNumberish,
-      data: BytesLike,
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<BigNumber>;
+    joeFactory(overrides?: CallOverrides): Promise<BigNumber>;
+
+    joeRouter(overrides?: CallOverrides): Promise<BigNumber>;
 
     swapExactRawTokenForYt(
       exactRawTokenIn: BigNumberish,
@@ -420,12 +408,9 @@ export interface IPRouterYT extends BaseContract {
   };
 
   populateTransaction: {
-    swapCallback(
-      otToAccount: BigNumberish,
-      scyToAccount: BigNumberish,
-      data: BytesLike,
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<PopulatedTransaction>;
+    joeFactory(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    joeRouter(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
     swapExactRawTokenForYt(
       exactRawTokenIn: BigNumberish,