@pendle/core-v2 0.8.0-beta-2 → 0.8.0-beta-5

package/typechain-types/RouterStatic.ts

@@ -9,12 +9,11 @@ import {
   CallOverrides,
   ContractTransaction,
   Overrides,
-  PayableOverrides,
   PopulatedTransaction,
   Signer,
   utils,
 } from "ethers";
-import { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
+import { FunctionFragment, Result } from "@ethersproject/abi";
 import { Listener, Provider } from "@ethersproject/providers";
 import type {
   TypedEventFilter,
@@ -145,6 +144,7 @@ export interface RouterStaticInterface extends utils.Interface {
   contractName: "RouterStatic";
   functions: {
     "addLiquidityStatic(address,uint256,uint256)": FunctionFragment;
+    "getExchangeRate(address)": FunctionFragment;
     "getMarketInfo(address)": FunctionFragment;
     "getPY(address)": FunctionFragment;
     "getPYInfo(address)": FunctionFragment;
@@ -156,25 +156,34 @@ export interface RouterStaticInterface extends utils.Interface {
     "getUserPYPositionsByPYs(address,address[])": FunctionFragment;
     "getUserSCYInfo(address,address)": FunctionFragment;
     "hasPYPosition((address,address,uint256,uint256,(address,uint256),(address,uint256)[]))": FunctionFragment;
-    "initialize()": FunctionFragment;
-    "marketFactory()": FunctionFragment;
-    "owner()": FunctionFragment;
-    "proxiableUUID()": FunctionFragment;
+    "mintPYFromBaseStatic(address,address,uint256)": FunctionFragment;
+    "mintPYFromScyStatic(address,uint256)": FunctionFragment;
+    "redeemPYToBaseStatic(address,uint256,address)": FunctionFragment;
+    "redeemPYToScyStatic(address,uint256)": FunctionFragment;
     "removeLiquidityStatic(address,uint256)": FunctionFragment;
-    "renounceOwnership()": FunctionFragment;
     "scyIndex(address)": FunctionFragment;
-    "swapPtForScyStatic(address,uint256)": FunctionFragment;
-    "swapScyForPtStatic(address,uint256)": FunctionFragment;
-    "transferOwnership(address)": FunctionFragment;
-    "upgradeTo(address)": FunctionFragment;
-    "upgradeToAndCall(address,bytes)": FunctionFragment;
-    "yieldContractFactory()": FunctionFragment;
+    "swapExactBaseTokenForPtStatic(address,address,uint256)": FunctionFragment;
+    "swapExactBaseTokenForYtStatic(address,address,uint256)": FunctionFragment;
+    "swapExactPtForBaseTokenStatic(address,uint256,address)": FunctionFragment;
+    "swapExactPtForScyStatic(address,uint256)": FunctionFragment;
+    "swapExactScyForPtStatic(address,uint256)": FunctionFragment;
+    "swapExactScyForYtStatic(address,uint256)": FunctionFragment;
+    "swapExactYtForBaseTokenStatic(address,uint256,address)": FunctionFragment;
+    "swapExactYtForScyStatic(address,uint256)": FunctionFragment;
+    "swapPtForExactScyStatic(address,uint256)": FunctionFragment;
+    "swapScyForExactPtStatic(address,uint256)": FunctionFragment;
+    "swapScyForExactYtStatic(address,uint256)": FunctionFragment;
+    "swapYtForExactScyStatic(address,uint256)": FunctionFragment;
   };
 
   encodeFunctionData(
     functionFragment: "addLiquidityStatic",
     values: [string, BigNumberish, BigNumberish]
   ): string;
+  encodeFunctionData(
+    functionFragment: "getExchangeRate",
+    values: [string]
+  ): string;
   encodeFunctionData(
     functionFragment: "getMarketInfo",
     values: [string]
@@ -214,53 +223,83 @@ export interface RouterStaticInterface extends utils.Interface {
     values: [IPRouterStatic.UserPYInfoStruct]
   ): string;
   encodeFunctionData(
-    functionFragment: "initialize",
-    values?: undefined
+    functionFragment: "mintPYFromBaseStatic",
+    values: [string, string, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "marketFactory",
-    values?: undefined
+    functionFragment: "mintPYFromScyStatic",
+    values: [string, BigNumberish]
   ): string;
-  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
   encodeFunctionData(
-    functionFragment: "proxiableUUID",
-    values?: undefined
+    functionFragment: "redeemPYToBaseStatic",
+    values: [string, BigNumberish, string]
   ): string;
   encodeFunctionData(
-    functionFragment: "removeLiquidityStatic",
+    functionFragment: "redeemPYToScyStatic",
     values: [string, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "renounceOwnership",
-    values?: undefined
+    functionFragment: "removeLiquidityStatic",
+    values: [string, BigNumberish]
   ): string;
   encodeFunctionData(functionFragment: "scyIndex", values: [string]): string;
   encodeFunctionData(
-    functionFragment: "swapPtForScyStatic",
+    functionFragment: "swapExactBaseTokenForPtStatic",
+    values: [string, string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "swapExactBaseTokenForYtStatic",
+    values: [string, string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "swapExactPtForBaseTokenStatic",
+    values: [string, BigNumberish, string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "swapExactPtForScyStatic",
     values: [string, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "swapScyForPtStatic",
+    functionFragment: "swapExactScyForPtStatic",
     values: [string, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "transferOwnership",
-    values: [string]
+    functionFragment: "swapExactScyForYtStatic",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "swapExactYtForBaseTokenStatic",
+    values: [string, BigNumberish, string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "swapExactYtForScyStatic",
+    values: [string, BigNumberish]
   ): string;
-  encodeFunctionData(functionFragment: "upgradeTo", values: [string]): string;
   encodeFunctionData(
-    functionFragment: "upgradeToAndCall",
-    values: [string, BytesLike]
+    functionFragment: "swapPtForExactScyStatic",
+    values: [string, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "yieldContractFactory",
-    values?: undefined
+    functionFragment: "swapScyForExactPtStatic",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "swapScyForExactYtStatic",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "swapYtForExactScyStatic",
+    values: [string, BigNumberish]
   ): string;
 
   decodeFunctionResult(
     functionFragment: "addLiquidityStatic",
     data: BytesLike
   ): Result;
+  decodeFunctionResult(
+    functionFragment: "getExchangeRate",
+    data: BytesLike
+  ): Result;
   decodeFunctionResult(
     functionFragment: "getMarketInfo",
     data: BytesLike
@@ -299,83 +338,79 @@ export interface RouterStaticInterface extends utils.Interface {
     functionFragment: "hasPYPosition",
     data: BytesLike
   ): Result;
-  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
   decodeFunctionResult(
-    functionFragment: "marketFactory",
+    functionFragment: "mintPYFromBaseStatic",
     data: BytesLike
   ): Result;
-  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
   decodeFunctionResult(
-    functionFragment: "proxiableUUID",
+    functionFragment: "mintPYFromScyStatic",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "removeLiquidityStatic",
+    functionFragment: "redeemPYToBaseStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "redeemPYToScyStatic",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "renounceOwnership",
+    functionFragment: "removeLiquidityStatic",
     data: BytesLike
   ): Result;
   decodeFunctionResult(functionFragment: "scyIndex", data: BytesLike): Result;
   decodeFunctionResult(
-    functionFragment: "swapPtForScyStatic",
+    functionFragment: "swapExactBaseTokenForPtStatic",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapScyForPtStatic",
+    functionFragment: "swapExactBaseTokenForYtStatic",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "transferOwnership",
+    functionFragment: "swapExactPtForBaseTokenStatic",
     data: BytesLike
   ): Result;
-  decodeFunctionResult(functionFragment: "upgradeTo", data: BytesLike): Result;
   decodeFunctionResult(
-    functionFragment: "upgradeToAndCall",
+    functionFragment: "swapExactPtForScyStatic",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "yieldContractFactory",
+    functionFragment: "swapExactScyForPtStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "swapExactScyForYtStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "swapExactYtForBaseTokenStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "swapExactYtForScyStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "swapPtForExactScyStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "swapScyForExactPtStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "swapScyForExactYtStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "swapYtForExactScyStatic",
     data: BytesLike
   ): Result;
 
-  events: {
-    "AdminChanged(address,address)": EventFragment;
-    "BeaconUpgraded(address)": EventFragment;
-    "OwnershipTransferred(address,address)": EventFragment;
-    "Upgraded(address)": EventFragment;
-  };
-
-  getEvent(nameOrSignatureOrTopic: "AdminChanged"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "BeaconUpgraded"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment;
+  events: {};
 }
 
-export type AdminChangedEvent = TypedEvent<
-  [string, string],
-  { previousAdmin: string; newAdmin: string }
->;
-
-export type AdminChangedEventFilter = TypedEventFilter<AdminChangedEvent>;
-
-export type BeaconUpgradedEvent = TypedEvent<[string], { beacon: string }>;
-
-export type BeaconUpgradedEventFilter = TypedEventFilter<BeaconUpgradedEvent>;
-
-export type OwnershipTransferredEvent = TypedEvent<
-  [string, string],
-  { previousOwner: string; newOwner: string }
->;
-
-export type OwnershipTransferredEventFilter =
-  TypedEventFilter<OwnershipTransferredEvent>;
-
-export type UpgradedEvent = TypedEvent<[string], { implementation: string }>;
-
-export type UpgradedEventFilter = TypedEventFilter<UpgradedEvent>;
-
 export interface RouterStatic extends BaseContract {
   contractName: "RouterStatic";
   connect(signerOrProvider: Signer | Provider | string): this;
@@ -417,6 +452,11 @@ export interface RouterStatic extends BaseContract {
       }
     >;
 
+    getExchangeRate(
+      market: string,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
     getMarketInfo(
       market: string,
       overrides?: CallOverrides
@@ -511,15 +551,31 @@ export interface RouterStatic extends BaseContract {
       overrides?: CallOverrides
     ): Promise<[boolean] & { hasPosition: boolean }>;
 
-    initialize(
+    mintPYFromBaseStatic(
+      YT: string,
+      baseToken: string,
+      amountBaseToken: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    marketFactory(overrides?: CallOverrides): Promise<[string]>;
+    mintPYFromScyStatic(
+      YT: string,
+      amountScyToMint: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
 
-    owner(overrides?: CallOverrides): Promise<[string]>;
+    redeemPYToBaseStatic(
+      YT: string,
+      amountPYToRedeem: BigNumberish,
+      baseToken: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
 
-    proxiableUUID(overrides?: CallOverrides): Promise<[string]>;
+    redeemPYToScyStatic(
+      YT: string,
+      amountPYToRedeem: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
 
     removeLiquidityStatic(
       market: string,
@@ -529,16 +585,42 @@ export interface RouterStatic extends BaseContract {
       [BigNumber, BigNumber] & { netScyOut: BigNumber; netPtOut: BigNumber }
     >;
 
-    renounceOwnership(
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<ContractTransaction>;
-
     scyIndex(
       market: string,
       overrides?: CallOverrides
     ): Promise<[BigNumber] & { index: BigNumber }>;
 
-    swapPtForScyStatic(
+    swapExactBaseTokenForPtStatic(
+      market: string,
+      baseToken: string,
+      amountBaseToken: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { netPtOut: BigNumber; netScyFee: BigNumber }
+    >;
+
+    swapExactBaseTokenForYtStatic(
+      market: string,
+      baseToken: string,
+      amountBaseToken: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { netPtOut: BigNumber; netScyFee: BigNumber }
+    >;
+
+    swapExactPtForBaseTokenStatic(
+      market: string,
+      exactYtIn: BigNumberish,
+      baseToken: string,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & {
+        netBaseTokenOut: BigNumber;
+        netScyFee: BigNumber;
+      }
+    >;
+
+    swapExactPtForScyStatic(
       market: string,
       exactPtIn: BigNumberish,
       overrides?: CallOverrides
@@ -546,31 +628,73 @@ export interface RouterStatic extends BaseContract {
       [BigNumber, BigNumber] & { netScyOut: BigNumber; netScyFee: BigNumber }
     >;
 
-    swapScyForPtStatic(
+    swapExactScyForPtStatic(
       market: string,
-      exactPtOut: BigNumberish,
+      exactScyIn: BigNumberish,
       overrides?: CallOverrides
     ): Promise<
-      [BigNumber, BigNumber] & { netScyIn: BigNumber; netScyFee: BigNumber }
+      [BigNumber, BigNumber] & { netPtOut: BigNumber; netScyFee: BigNumber }
     >;
 
-    transferOwnership(
-      newOwner: string,
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<ContractTransaction>;
+    swapExactScyForYtStatic(
+      market: string,
+      exactScyIn: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { netYtOut: BigNumber; netScyFee: BigNumber }
+    >;
 
-    upgradeTo(
-      newImplementation: string,
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<ContractTransaction>;
+    swapExactYtForBaseTokenStatic(
+      market: string,
+      exactYtIn: BigNumberish,
+      baseToken: string,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & {
+        netBaseTokenOut: BigNumber;
+        netScyFee: BigNumber;
+      }
+    >;
 
-    upgradeToAndCall(
-      newImplementation: string,
-      data: BytesLike,
-      overrides?: PayableOverrides & { from?: string | Promise<string> }
-    ): Promise<ContractTransaction>;
+    swapExactYtForScyStatic(
+      market: string,
+      exactYtIn: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { netScyOut: BigNumber; netScyFee: BigNumber }
+    >;
+
+    swapPtForExactScyStatic(
+      market: string,
+      exactScyOut: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { netPtIn: BigNumber; netScyFee: BigNumber }
+    >;
 
-    yieldContractFactory(overrides?: CallOverrides): Promise<[string]>;
+    swapScyForExactPtStatic(
+      market: string,
+      exactPtOut: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { netScyIn: BigNumber; netScyFee: BigNumber }
+    >;
+
+    swapScyForExactYtStatic(
+      market: string,
+      exactYtOut: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { netScyIn: BigNumber; netScyFee: BigNumber }
+    >;
+
+    swapYtForExactScyStatic(
+      market: string,
+      exactScyOut: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { netYtIn: BigNumber; netScyFee: BigNumber }
+    >;
   };
 
   addLiquidityStatic(
@@ -586,6 +710,11 @@ export interface RouterStatic extends BaseContract {
     }
   >;
 
+  getExchangeRate(
+    market: string,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
   getMarketInfo(
     market: string,
     overrides?: CallOverrides
@@ -664,15 +793,31 @@ export interface RouterStatic extends BaseContract {
     overrides?: CallOverrides
   ): Promise<boolean>;
 
-  initialize(
+  mintPYFromBaseStatic(
+    YT: string,
+    baseToken: string,
+    amountBaseToken: BigNumberish,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  marketFactory(overrides?: CallOverrides): Promise<string>;
+  mintPYFromScyStatic(
+    YT: string,
+    amountScyToMint: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
 
-  owner(overrides?: CallOverrides): Promise<string>;
+  redeemPYToBaseStatic(
+    YT: string,
+    amountPYToRedeem: BigNumberish,
+    baseToken: string,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
 
-  proxiableUUID(overrides?: CallOverrides): Promise<string>;
+  redeemPYToScyStatic(
+    YT: string,
+    amountPYToRedeem: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
 
   removeLiquidityStatic(
     market: string,
@@ -682,13 +827,39 @@ export interface RouterStatic extends BaseContract {
     [BigNumber, BigNumber] & { netScyOut: BigNumber; netPtOut: BigNumber }
   >;
 
-  renounceOwnership(
-    overrides?: Overrides & { from?: string | Promise<string> }
-  ): Promise<ContractTransaction>;
-
   scyIndex(market: string, overrides?: CallOverrides): Promise<BigNumber>;
 
-  swapPtForScyStatic(
+  swapExactBaseTokenForPtStatic(
+    market: string,
+    baseToken: string,
+    amountBaseToken: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber] & { netPtOut: BigNumber; netScyFee: BigNumber }
+  >;
+
+  swapExactBaseTokenForYtStatic(
+    market: string,
+    baseToken: string,
+    amountBaseToken: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber] & { netPtOut: BigNumber; netScyFee: BigNumber }
+  >;
+
+  swapExactPtForBaseTokenStatic(
+    market: string,
+    exactYtIn: BigNumberish,
+    baseToken: string,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber] & {
+      netBaseTokenOut: BigNumber;
+      netScyFee: BigNumber;
+    }
+  >;
+
+  swapExactPtForScyStatic(
     market: string,
     exactPtIn: BigNumberish,
     overrides?: CallOverrides
@@ -696,31 +867,73 @@ export interface RouterStatic extends BaseContract {
     [BigNumber, BigNumber] & { netScyOut: BigNumber; netScyFee: BigNumber }
   >;
 
-  swapScyForPtStatic(
+  swapExactScyForPtStatic(
     market: string,
-    exactPtOut: BigNumberish,
+    exactScyIn: BigNumberish,
     overrides?: CallOverrides
   ): Promise<
-    [BigNumber, BigNumber] & { netScyIn: BigNumber; netScyFee: BigNumber }
+    [BigNumber, BigNumber] & { netPtOut: BigNumber; netScyFee: BigNumber }
   >;
 
-  transferOwnership(
-    newOwner: string,
-    overrides?: Overrides & { from?: string | Promise<string> }
-  ): Promise<ContractTransaction>;
+  swapExactScyForYtStatic(
+    market: string,
+    exactScyIn: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber] & { netYtOut: BigNumber; netScyFee: BigNumber }
+  >;
 
-  upgradeTo(
-    newImplementation: string,
-    overrides?: Overrides & { from?: string | Promise<string> }
-  ): Promise<ContractTransaction>;
+  swapExactYtForBaseTokenStatic(
+    market: string,
+    exactYtIn: BigNumberish,
+    baseToken: string,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber] & {
+      netBaseTokenOut: BigNumber;
+      netScyFee: BigNumber;
+    }
+  >;
 
-  upgradeToAndCall(
-    newImplementation: string,
-    data: BytesLike,
-    overrides?: PayableOverrides & { from?: string | Promise<string> }
-  ): Promise<ContractTransaction>;
+  swapExactYtForScyStatic(
+    market: string,
+    exactYtIn: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber] & { netScyOut: BigNumber; netScyFee: BigNumber }
+  >;
+
+  swapPtForExactScyStatic(
+    market: string,
+    exactScyOut: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber] & { netPtIn: BigNumber; netScyFee: BigNumber }
+  >;
+
+  swapScyForExactPtStatic(
+    market: string,
+    exactPtOut: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber] & { netScyIn: BigNumber; netScyFee: BigNumber }
+  >;
 
-  yieldContractFactory(overrides?: CallOverrides): Promise<string>;
+  swapScyForExactYtStatic(
+    market: string,
+    exactYtOut: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber] & { netScyIn: BigNumber; netScyFee: BigNumber }
+  >;
+
+  swapYtForExactScyStatic(
+    market: string,
+    exactScyOut: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber] & { netYtIn: BigNumber; netScyFee: BigNumber }
+  >;
 
   callStatic: {
     addLiquidityStatic(
@@ -736,6 +949,11 @@ export interface RouterStatic extends BaseContract {
       }
     >;
 
+    getExchangeRate(
+      market: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
     getMarketInfo(
       market: string,
       overrides?: CallOverrides
@@ -820,13 +1038,31 @@ export interface RouterStatic extends BaseContract {
       overrides?: CallOverrides
     ): Promise<boolean>;
 
-    initialize(overrides?: CallOverrides): Promise<void>;
+    mintPYFromBaseStatic(
+      YT: string,
+      baseToken: string,
+      amountBaseToken: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
 
-    marketFactory(overrides?: CallOverrides): Promise<string>;
+    mintPYFromScyStatic(
+      YT: string,
+      amountScyToMint: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
 
-    owner(overrides?: CallOverrides): Promise<string>;
+    redeemPYToBaseStatic(
+      YT: string,
+      amountPYToRedeem: BigNumberish,
+      baseToken: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
 
-    proxiableUUID(overrides?: CallOverrides): Promise<string>;
+    redeemPYToScyStatic(
+      YT: string,
+      amountPYToRedeem: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
 
     removeLiquidityStatic(
       market: string,
@@ -836,11 +1072,39 @@ export interface RouterStatic extends BaseContract {
       [BigNumber, BigNumber] & { netScyOut: BigNumber; netPtOut: BigNumber }
     >;
 
-    renounceOwnership(overrides?: CallOverrides): Promise<void>;
-
     scyIndex(market: string, overrides?: CallOverrides): Promise<BigNumber>;
 
-    swapPtForScyStatic(
+    swapExactBaseTokenForPtStatic(
+      market: string,
+      baseToken: string,
+      amountBaseToken: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { netPtOut: BigNumber; netScyFee: BigNumber }
+    >;
+
+    swapExactBaseTokenForYtStatic(
+      market: string,
+      baseToken: string,
+      amountBaseToken: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { netPtOut: BigNumber; netScyFee: BigNumber }
+    >;
+
+    swapExactPtForBaseTokenStatic(
+      market: string,
+      exactYtIn: BigNumberish,
+      baseToken: string,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & {
+        netBaseTokenOut: BigNumber;
+        netScyFee: BigNumber;
+      }
+    >;
+
+    swapExactPtForScyStatic(
       market: string,
       exactPtIn: BigNumberish,
       overrides?: CallOverrides
@@ -848,61 +1112,77 @@ export interface RouterStatic extends BaseContract {
       [BigNumber, BigNumber] & { netScyOut: BigNumber; netScyFee: BigNumber }
     >;
 
-    swapScyForPtStatic(
+    swapExactScyForPtStatic(
       market: string,
-      exactPtOut: BigNumberish,
+      exactScyIn: BigNumberish,
       overrides?: CallOverrides
     ): Promise<
-      [BigNumber, BigNumber] & { netScyIn: BigNumber; netScyFee: BigNumber }
+      [BigNumber, BigNumber] & { netPtOut: BigNumber; netScyFee: BigNumber }
     >;
 
-    transferOwnership(
-      newOwner: string,
+    swapExactScyForYtStatic(
+      market: string,
+      exactScyIn: BigNumberish,
       overrides?: CallOverrides
-    ): Promise<void>;
+    ): Promise<
+      [BigNumber, BigNumber] & { netYtOut: BigNumber; netScyFee: BigNumber }
+    >;
 
-    upgradeTo(
-      newImplementation: string,
+    swapExactYtForBaseTokenStatic(
+      market: string,
+      exactYtIn: BigNumberish,
+      baseToken: string,
       overrides?: CallOverrides
-    ): Promise<void>;
+    ): Promise<
+      [BigNumber, BigNumber] & {
+        netBaseTokenOut: BigNumber;
+        netScyFee: BigNumber;
+      }
+    >;
 
-    upgradeToAndCall(
-      newImplementation: string,
-      data: BytesLike,
+    swapExactYtForScyStatic(
+      market: string,
+      exactYtIn: BigNumberish,
       overrides?: CallOverrides
-    ): Promise<void>;
+    ): Promise<
+      [BigNumber, BigNumber] & { netScyOut: BigNumber; netScyFee: BigNumber }
+    >;
 
-    yieldContractFactory(overrides?: CallOverrides): Promise<string>;
-  };
+    swapPtForExactScyStatic(
+      market: string,
+      exactScyOut: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { netPtIn: BigNumber; netScyFee: BigNumber }
+    >;
+
+    swapScyForExactPtStatic(
+      market: string,
+      exactPtOut: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { netScyIn: BigNumber; netScyFee: BigNumber }
+    >;
 
-  filters: {
-    "AdminChanged(address,address)"(
-      previousAdmin?: null,
-      newAdmin?: null
-    ): AdminChangedEventFilter;
-    AdminChanged(
-      previousAdmin?: null,
-      newAdmin?: null
-    ): AdminChangedEventFilter;
-
-    "BeaconUpgraded(address)"(
-      beacon?: string | null
-    ): BeaconUpgradedEventFilter;
-    BeaconUpgraded(beacon?: string | null): BeaconUpgradedEventFilter;
-
-    "OwnershipTransferred(address,address)"(
-      previousOwner?: string | null,
-      newOwner?: string | null
-    ): OwnershipTransferredEventFilter;
-    OwnershipTransferred(
-      previousOwner?: string | null,
-      newOwner?: string | null
-    ): OwnershipTransferredEventFilter;
-
-    "Upgraded(address)"(implementation?: string | null): UpgradedEventFilter;
-    Upgraded(implementation?: string | null): UpgradedEventFilter;
+    swapScyForExactYtStatic(
+      market: string,
+      exactYtOut: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { netScyIn: BigNumber; netScyFee: BigNumber }
+    >;
+
+    swapYtForExactScyStatic(
+      market: string,
+      exactScyOut: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { netYtIn: BigNumber; netScyFee: BigNumber }
+    >;
   };
 
+  filters: {};
+
   estimateGas: {
     addLiquidityStatic(
       market: string,
@@ -911,6 +1191,11 @@ export interface RouterStatic extends BaseContract {
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
+    getExchangeRate(
+      market: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
     getMarketInfo(
       market: string,
       overrides?: CallOverrides
@@ -968,15 +1253,31 @@ export interface RouterStatic extends BaseContract {
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    initialize(
+    mintPYFromBaseStatic(
+      YT: string,
+      baseToken: string,
+      amountBaseToken: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    marketFactory(overrides?: CallOverrides): Promise<BigNumber>;
+    mintPYFromScyStatic(
+      YT: string,
+      amountScyToMint: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
 
-    owner(overrides?: CallOverrides): Promise<BigNumber>;
+    redeemPYToBaseStatic(
+      YT: string,
+      amountPYToRedeem: BigNumberish,
+      baseToken: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
 
-    proxiableUUID(overrides?: CallOverrides): Promise<BigNumber>;
+    redeemPYToScyStatic(
+      YT: string,
+      amountPYToRedeem: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
 
     removeLiquidityStatic(
       market: string,
@@ -984,41 +1285,83 @@ export interface RouterStatic extends BaseContract {
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    renounceOwnership(
-      overrides?: Overrides & { from?: string | Promise<string> }
+    scyIndex(market: string, overrides?: CallOverrides): Promise<BigNumber>;
+
+    swapExactBaseTokenForPtStatic(
+      market: string,
+      baseToken: string,
+      amountBaseToken: BigNumberish,
+      overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    scyIndex(market: string, overrides?: CallOverrides): Promise<BigNumber>;
+    swapExactBaseTokenForYtStatic(
+      market: string,
+      baseToken: string,
+      amountBaseToken: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
 
-    swapPtForScyStatic(
+    swapExactPtForBaseTokenStatic(
+      market: string,
+      exactYtIn: BigNumberish,
+      baseToken: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    swapExactPtForScyStatic(
       market: string,
       exactPtIn: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    swapScyForPtStatic(
+    swapExactScyForPtStatic(
       market: string,
-      exactPtOut: BigNumberish,
+      exactScyIn: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    transferOwnership(
-      newOwner: string,
-      overrides?: Overrides & { from?: string | Promise<string> }
+    swapExactScyForYtStatic(
+      market: string,
+      exactScyIn: BigNumberish,
+      overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    upgradeTo(
-      newImplementation: string,
-      overrides?: Overrides & { from?: string | Promise<string> }
+    swapExactYtForBaseTokenStatic(
+      market: string,
+      exactYtIn: BigNumberish,
+      baseToken: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    swapExactYtForScyStatic(
+      market: string,
+      exactYtIn: BigNumberish,
+      overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    upgradeToAndCall(
-      newImplementation: string,
-      data: BytesLike,
-      overrides?: PayableOverrides & { from?: string | Promise<string> }
+    swapPtForExactScyStatic(
+      market: string,
+      exactScyOut: BigNumberish,
+      overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    yieldContractFactory(overrides?: CallOverrides): Promise<BigNumber>;
+    swapScyForExactPtStatic(
+      market: string,
+      exactPtOut: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    swapScyForExactYtStatic(
+      market: string,
+      exactYtOut: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    swapYtForExactScyStatic(
+      market: string,
+      exactScyOut: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
   };
 
   populateTransaction: {
@@ -1029,6 +1372,11 @@ export interface RouterStatic extends BaseContract {
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
+    getExchangeRate(
+      market: string,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
     getMarketInfo(
       market: string,
       overrides?: CallOverrides
@@ -1086,15 +1434,31 @@ export interface RouterStatic extends BaseContract {
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    initialize(
+    mintPYFromBaseStatic(
+      YT: string,
+      baseToken: string,
+      amountBaseToken: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    marketFactory(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    mintPYFromScyStatic(
+      YT: string,
+      amountScyToMint: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
 
-    owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    redeemPYToBaseStatic(
+      YT: string,
+      amountPYToRedeem: BigNumberish,
+      baseToken: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
 
-    proxiableUUID(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    redeemPYToScyStatic(
+      YT: string,
+      amountPYToRedeem: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
 
     removeLiquidityStatic(
       market: string,
@@ -1102,44 +1466,84 @@ export interface RouterStatic extends BaseContract {
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    renounceOwnership(
-      overrides?: Overrides & { from?: string | Promise<string> }
+    scyIndex(
+      market: string,
+      overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    scyIndex(
+    swapExactBaseTokenForPtStatic(
+      market: string,
+      baseToken: string,
+      amountBaseToken: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    swapExactBaseTokenForYtStatic(
+      market: string,
+      baseToken: string,
+      amountBaseToken: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    swapExactPtForBaseTokenStatic(
       market: string,
+      exactYtIn: BigNumberish,
+      baseToken: string,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    swapPtForScyStatic(
+    swapExactPtForScyStatic(
       market: string,
       exactPtIn: BigNumberish,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    swapScyForPtStatic(
+    swapExactScyForPtStatic(
       market: string,
-      exactPtOut: BigNumberish,
+      exactScyIn: BigNumberish,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    transferOwnership(
-      newOwner: string,
-      overrides?: Overrides & { from?: string | Promise<string> }
+    swapExactScyForYtStatic(
+      market: string,
+      exactScyIn: BigNumberish,
+      overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    upgradeTo(
-      newImplementation: string,
-      overrides?: Overrides & { from?: string | Promise<string> }
+    swapExactYtForBaseTokenStatic(
+      market: string,
+      exactYtIn: BigNumberish,
+      baseToken: string,
+      overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    upgradeToAndCall(
-      newImplementation: string,
-      data: BytesLike,
-      overrides?: PayableOverrides & { from?: string | Promise<string> }
+    swapExactYtForScyStatic(
+      market: string,
+      exactYtIn: BigNumberish,
+      overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    yieldContractFactory(
+    swapPtForExactScyStatic(
+      market: string,
+      exactScyOut: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    swapScyForExactPtStatic(
+      market: string,
+      exactPtOut: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    swapScyForExactYtStatic(
+      market: string,
+      exactYtOut: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    swapYtForExactScyStatic(
+      market: string,
+      exactScyOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
   };