@pendle/core-v2 0.6.3 → 0.6.5

package/typechain-types/ActionCore.ts

@@ -22,45 +22,23 @@ import type {
   OnEvent,
 } from "./common";
 
-export type ApproxParamsStruct = {
-  guessMin: BigNumberish;
-  guessMax: BigNumberish;
-  guessOffchain: BigNumberish;
-  maxIteration: BigNumberish;
-  eps: BigNumberish;
-};
-
-export type ApproxParamsStructOutput = [
-  BigNumber,
-  BigNumber,
-  BigNumber,
-  BigNumber,
-  BigNumber
-] & {
-  guessMin: BigNumber;
-  guessMax: BigNumber;
-  guessOffchain: BigNumber;
-  maxIteration: BigNumber;
-  eps: BigNumber;
-};
-
 export interface ActionCoreInterface extends utils.Interface {
   contractName: "ActionCore";
   functions: {
     "addLiquidity(address,address,uint256,uint256,uint256)": FunctionFragment;
     "joeFactory()": FunctionFragment;
     "joeRouter()": FunctionFragment;
-    "mintPyFromRawToken(uint256,address,uint256,address,address[])": FunctionFragment;
     "mintScyFromRawToken(uint256,address,uint256,address,address[])": FunctionFragment;
-    "redeemPyToRawToken(address,uint256,uint256,address,address[])": FunctionFragment;
+    "mintYoFromRawToken(uint256,address,uint256,address,address[])": FunctionFragment;
     "redeemScyToRawToken(address,uint256,uint256,address,address[])": FunctionFragment;
+    "redeemYoToRawToken(address,uint256,uint256,address,address[])": FunctionFragment;
     "removeLiquidity(address,address,uint256,uint256,uint256)": FunctionFragment;
-    "swapExactPtForRawToken(uint256,address,address[],address,uint256)": FunctionFragment;
-    "swapExactPtForScy(address,address,uint256,uint256)": FunctionFragment;
-    "swapExactRawTokenForPt(uint256,address,address[],address,(uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
-    "swapExactScyForPt(address,address,uint256,(uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
-    "swapPtForExactScy(address,address,uint256,(uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
-    "swapScyForExactPt(address,address,uint256,uint256)": FunctionFragment;
+    "swapExactOtForRawToken(uint256,address,address[],address,uint256)": FunctionFragment;
+    "swapExactOtForScy(address,address,uint256,uint256)": FunctionFragment;
+    "swapExactRawTokenForOt(uint256,address,address[],address,uint256,uint256,uint256,uint256)": FunctionFragment;
+    "swapExactScyForOt(address,address,uint256,uint256,uint256,uint256,uint256)": FunctionFragment;
+    "swapOtForExactScy(address,address,uint256,uint256,uint256,uint256,uint256)": FunctionFragment;
+    "swapScyForExactOt(address,address,uint256,uint256)": FunctionFragment;
   };
 
   encodeFunctionData(
@@ -73,19 +51,19 @@ export interface ActionCoreInterface extends utils.Interface {
   ): string;
   encodeFunctionData(functionFragment: "joeRouter", values?: undefined): string;
   encodeFunctionData(
-    functionFragment: "mintPyFromRawToken",
+    functionFragment: "mintScyFromRawToken",
     values: [BigNumberish, string, BigNumberish, string, string[]]
   ): string;
   encodeFunctionData(
-    functionFragment: "mintScyFromRawToken",
+    functionFragment: "mintYoFromRawToken",
     values: [BigNumberish, string, BigNumberish, string, string[]]
   ): string;
   encodeFunctionData(
-    functionFragment: "redeemPyToRawToken",
+    functionFragment: "redeemScyToRawToken",
     values: [string, BigNumberish, BigNumberish, string, string[]]
   ): string;
   encodeFunctionData(
-    functionFragment: "redeemScyToRawToken",
+    functionFragment: "redeemYoToRawToken",
     values: [string, BigNumberish, BigNumberish, string, string[]]
   ): string;
   encodeFunctionData(
@@ -93,27 +71,52 @@ export interface ActionCoreInterface extends utils.Interface {
     values: [string, string, BigNumberish, BigNumberish, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "swapExactPtForRawToken",
+    functionFragment: "swapExactOtForRawToken",
     values: [BigNumberish, string, string[], string, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "swapExactPtForScy",
+    functionFragment: "swapExactOtForScy",
     values: [string, string, BigNumberish, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "swapExactRawTokenForPt",
-    values: [BigNumberish, string, string[], string, ApproxParamsStruct]
+    functionFragment: "swapExactRawTokenForOt",
+    values: [
+      BigNumberish,
+      string,
+      string[],
+      string,
+      BigNumberish,
+      BigNumberish,
+      BigNumberish,
+      BigNumberish
+    ]
   ): string;
   encodeFunctionData(
-    functionFragment: "swapExactScyForPt",
-    values: [string, string, BigNumberish, ApproxParamsStruct]
+    functionFragment: "swapExactScyForOt",
+    values: [
+      string,
+      string,
+      BigNumberish,
+      BigNumberish,
+      BigNumberish,
+      BigNumberish,
+      BigNumberish
+    ]
   ): string;
   encodeFunctionData(
-    functionFragment: "swapPtForExactScy",
-    values: [string, string, BigNumberish, ApproxParamsStruct]
+    functionFragment: "swapOtForExactScy",
+    values: [
+      string,
+      string,
+      BigNumberish,
+      BigNumberish,
+      BigNumberish,
+      BigNumberish,
+      BigNumberish
+    ]
   ): string;
   encodeFunctionData(
-    functionFragment: "swapScyForExactPt",
+    functionFragment: "swapScyForExactOt",
     values: [string, string, BigNumberish, BigNumberish]
   ): string;
 
@@ -124,19 +127,19 @@ export interface ActionCoreInterface extends utils.Interface {
   decodeFunctionResult(functionFragment: "joeFactory", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "joeRouter", data: BytesLike): Result;
   decodeFunctionResult(
-    functionFragment: "mintPyFromRawToken",
+    functionFragment: "mintScyFromRawToken",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "mintScyFromRawToken",
+    functionFragment: "mintYoFromRawToken",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "redeemPyToRawToken",
+    functionFragment: "redeemScyToRawToken",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "redeemScyToRawToken",
+    functionFragment: "redeemYoToRawToken",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
@@ -144,57 +147,43 @@ export interface ActionCoreInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapExactPtForRawToken",
+    functionFragment: "swapExactOtForRawToken",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapExactPtForScy",
+    functionFragment: "swapExactOtForScy",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapExactRawTokenForPt",
+    functionFragment: "swapExactRawTokenForOt",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapExactScyForPt",
+    functionFragment: "swapExactScyForOt",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapPtForExactScy",
+    functionFragment: "swapOtForExactScy",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapScyForExactPt",
+    functionFragment: "swapScyForExactOt",
     data: BytesLike
   ): Result;
 
   events: {
-    "MintPyFromRawToken(address,address,uint256,address,uint256)": EventFragment;
     "MintScyFromRawToken(address,address,uint256,address,uint256)": EventFragment;
-    "RedeemPyToRawToken(address,address,uint256,address,uint256)": EventFragment;
+    "MintYoFromRawToken(address,address,uint256,address,uint256)": EventFragment;
     "RedeemScyToRawToken(address,address,uint256,address,uint256)": EventFragment;
+    "RedeemYoToRawToken(address,address,uint256,address,uint256)": EventFragment;
   };
 
-  getEvent(nameOrSignatureOrTopic: "MintPyFromRawToken"): EventFragment;
   getEvent(nameOrSignatureOrTopic: "MintScyFromRawToken"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "RedeemPyToRawToken"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "MintYoFromRawToken"): EventFragment;
   getEvent(nameOrSignatureOrTopic: "RedeemScyToRawToken"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "RedeemYoToRawToken"): EventFragment;
 }
 
-export type MintPyFromRawTokenEvent = TypedEvent<
-  [string, string, BigNumber, string, BigNumber],
-  {
-    user: string;
-    rawTokenIn: string;
-    netRawTokenIn: BigNumber;
-    YT: string;
-    netPyOut: BigNumber;
-  }
->;
-
-export type MintPyFromRawTokenEventFilter =
-  TypedEventFilter<MintPyFromRawTokenEvent>;
-
 export type MintScyFromRawTokenEvent = TypedEvent<
   [string, string, BigNumber, string, BigNumber],
   {
@@ -209,19 +198,19 @@ export type MintScyFromRawTokenEvent = TypedEvent<
 export type MintScyFromRawTokenEventFilter =
   TypedEventFilter<MintScyFromRawTokenEvent>;
 
-export type RedeemPyToRawTokenEvent = TypedEvent<
+export type MintYoFromRawTokenEvent = TypedEvent<
   [string, string, BigNumber, string, BigNumber],
   {
     user: string;
+    rawTokenIn: string;
+    netRawTokenIn: BigNumber;
     YT: string;
-    netPyIn: BigNumber;
-    rawTokenOut: string;
-    netRawTokenOut: BigNumber;
+    netYoOut: BigNumber;
   }
 >;
 
-export type RedeemPyToRawTokenEventFilter =
-  TypedEventFilter<RedeemPyToRawTokenEvent>;
+export type MintYoFromRawTokenEventFilter =
+  TypedEventFilter<MintYoFromRawTokenEvent>;
 
 export type RedeemScyToRawTokenEvent = TypedEvent<
   [string, string, BigNumber, string, BigNumber],
@@ -237,6 +226,20 @@ export type RedeemScyToRawTokenEvent = TypedEvent<
 export type RedeemScyToRawTokenEventFilter =
   TypedEventFilter<RedeemScyToRawTokenEvent>;
 
+export type RedeemYoToRawTokenEvent = TypedEvent<
+  [string, string, BigNumber, string, BigNumber],
+  {
+    user: string;
+    YT: string;
+    netYoIn: BigNumber;
+    rawTokenOut: string;
+    netRawTokenOut: BigNumber;
+  }
+>;
+
+export type RedeemYoToRawTokenEventFilter =
+  TypedEventFilter<RedeemYoToRawTokenEvent>;
+
 export interface ActionCore extends BaseContract {
   contractName: "ActionCore";
   connect(signerOrProvider: Signer | Provider | string): this;
@@ -269,7 +272,7 @@ export interface ActionCore extends BaseContract {
       receiver: string,
       market: string,
       scyDesired: BigNumberish,
-      ptDesired: BigNumberish,
+      otDesired: BigNumberish,
       minLpOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
@@ -278,15 +281,6 @@ export interface ActionCore extends BaseContract {
 
     joeRouter(overrides?: CallOverrides): Promise<[string]>;
 
-    mintPyFromRawToken(
-      netRawTokenIn: BigNumberish,
-      YT: string,
-      minPyOut: BigNumberish,
-      receiver: string,
-      path: string[],
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<ContractTransaction>;
-
     mintScyFromRawToken(
       netRawTokenIn: BigNumberish,
       SCY: string,
@@ -296,10 +290,10 @@ export interface ActionCore extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    redeemPyToRawToken(
+    mintYoFromRawToken(
+      netRawTokenIn: BigNumberish,
       YT: string,
-      netPyIn: BigNumberish,
-      minRawTokenOut: BigNumberish,
+      minYoOut: BigNumberish,
       receiver: string,
       path: string[],
       overrides?: Overrides & { from?: string | Promise<string> }
@@ -314,17 +308,26 @@ export interface ActionCore extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
+    redeemYoToRawToken(
+      YT: string,
+      netYoIn: BigNumberish,
+      minRawTokenOut: BigNumberish,
+      receiver: string,
+      path: string[],
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
     removeLiquidity(
       receiver: string,
       market: string,
       lpToRemove: BigNumberish,
       scyOutMin: BigNumberish,
-      ptOutMin: BigNumberish,
+      otOutMin: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    swapExactPtForRawToken(
-      exactPtIn: BigNumberish,
+    swapExactOtForRawToken(
+      exactOtIn: BigNumberish,
       receiver: string,
       path: string[],
       market: string,
@@ -332,43 +335,52 @@ export interface ActionCore extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    swapExactPtForScy(
+    swapExactOtForScy(
       receiver: string,
       market: string,
-      exactPtIn: BigNumberish,
+      exactOtIn: BigNumberish,
       minScyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    swapExactRawTokenForPt(
+    swapExactRawTokenForOt(
       exactRawTokenIn: BigNumberish,
       receiver: string,
       path: string[],
       market: string,
-      approx: ApproxParamsStruct,
+      otOutguessMin: BigNumberish,
+      otOutguessMax: BigNumberish,
+      maxIteration: BigNumberish,
+      eps: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    swapExactScyForPt(
+    swapExactScyForOt(
       receiver: string,
       market: string,
       exactScyIn: BigNumberish,
-      approx: ApproxParamsStruct,
+      otOutguessMin: BigNumberish,
+      otOutguessMax: BigNumberish,
+      maxIteration: BigNumberish,
+      eps: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    swapPtForExactScy(
+    swapOtForExactScy(
       receiver: string,
       market: string,
       exactScyOut: BigNumberish,
-      approx: ApproxParamsStruct,
+      otInGuessMin: BigNumberish,
+      otInGuessMax: BigNumberish,
+      maxIteration: BigNumberish,
+      eps: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    swapScyForExactPt(
+    swapScyForExactOt(
       receiver: string,
       market: string,
-      exactPtOut: BigNumberish,
+      exactOtOut: BigNumberish,
       maxScyIn: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
@@ -378,7 +390,7 @@ export interface ActionCore extends BaseContract {
     receiver: string,
     market: string,
     scyDesired: BigNumberish,
-    ptDesired: BigNumberish,
+    otDesired: BigNumberish,
     minLpOut: BigNumberish,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
@@ -387,15 +399,6 @@ export interface ActionCore extends BaseContract {
 
   joeRouter(overrides?: CallOverrides): Promise<string>;
 
-  mintPyFromRawToken(
-    netRawTokenIn: BigNumberish,
-    YT: string,
-    minPyOut: BigNumberish,
-    receiver: string,
-    path: string[],
-    overrides?: Overrides & { from?: string | Promise<string> }
-  ): Promise<ContractTransaction>;
-
   mintScyFromRawToken(
     netRawTokenIn: BigNumberish,
     SCY: string,
@@ -405,10 +408,10 @@ export interface ActionCore extends BaseContract {
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  redeemPyToRawToken(
+  mintYoFromRawToken(
+    netRawTokenIn: BigNumberish,
     YT: string,
-    netPyIn: BigNumberish,
-    minRawTokenOut: BigNumberish,
+    minYoOut: BigNumberish,
     receiver: string,
     path: string[],
     overrides?: Overrides & { from?: string | Promise<string> }
@@ -423,17 +426,26 @@ export interface ActionCore extends BaseContract {
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
+  redeemYoToRawToken(
+    YT: string,
+    netYoIn: BigNumberish,
+    minRawTokenOut: BigNumberish,
+    receiver: string,
+    path: string[],
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
   removeLiquidity(
     receiver: string,
     market: string,
     lpToRemove: BigNumberish,
     scyOutMin: BigNumberish,
-    ptOutMin: BigNumberish,
+    otOutMin: BigNumberish,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  swapExactPtForRawToken(
-    exactPtIn: BigNumberish,
+  swapExactOtForRawToken(
+    exactOtIn: BigNumberish,
     receiver: string,
     path: string[],
     market: string,
@@ -441,43 +453,52 @@ export interface ActionCore extends BaseContract {
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  swapExactPtForScy(
+  swapExactOtForScy(
     receiver: string,
     market: string,
-    exactPtIn: BigNumberish,
+    exactOtIn: BigNumberish,
     minScyOut: BigNumberish,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  swapExactRawTokenForPt(
+  swapExactRawTokenForOt(
     exactRawTokenIn: BigNumberish,
     receiver: string,
     path: string[],
     market: string,
-    approx: ApproxParamsStruct,
+    otOutguessMin: BigNumberish,
+    otOutguessMax: BigNumberish,
+    maxIteration: BigNumberish,
+    eps: BigNumberish,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  swapExactScyForPt(
+  swapExactScyForOt(
     receiver: string,
     market: string,
     exactScyIn: BigNumberish,
-    approx: ApproxParamsStruct,
+    otOutguessMin: BigNumberish,
+    otOutguessMax: BigNumberish,
+    maxIteration: BigNumberish,
+    eps: BigNumberish,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  swapPtForExactScy(
+  swapOtForExactScy(
     receiver: string,
     market: string,
     exactScyOut: BigNumberish,
-    approx: ApproxParamsStruct,
+    otInGuessMin: BigNumberish,
+    otInGuessMax: BigNumberish,
+    maxIteration: BigNumberish,
+    eps: BigNumberish,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  swapScyForExactPt(
+  swapScyForExactOt(
     receiver: string,
     market: string,
-    exactPtOut: BigNumberish,
+    exactOtOut: BigNumberish,
     maxScyIn: BigNumberish,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
@@ -487,7 +508,7 @@ export interface ActionCore extends BaseContract {
       receiver: string,
       market: string,
       scyDesired: BigNumberish,
-      ptDesired: BigNumberish,
+      otDesired: BigNumberish,
       minLpOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<[BigNumber, BigNumber, BigNumber]>;
@@ -496,15 +517,6 @@ export interface ActionCore extends BaseContract {
 
     joeRouter(overrides?: CallOverrides): Promise<string>;
 
-    mintPyFromRawToken(
-      netRawTokenIn: BigNumberish,
-      YT: string,
-      minPyOut: BigNumberish,
-      receiver: string,
-      path: string[],
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
     mintScyFromRawToken(
       netRawTokenIn: BigNumberish,
       SCY: string,
@@ -514,10 +526,10 @@ export interface ActionCore extends BaseContract {
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    redeemPyToRawToken(
+    mintYoFromRawToken(
+      netRawTokenIn: BigNumberish,
       YT: string,
-      netPyIn: BigNumberish,
-      minRawTokenOut: BigNumberish,
+      minYoOut: BigNumberish,
       receiver: string,
       path: string[],
       overrides?: CallOverrides
@@ -532,17 +544,26 @@ export interface ActionCore extends BaseContract {
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
+    redeemYoToRawToken(
+      YT: string,
+      netYoIn: BigNumberish,
+      minRawTokenOut: BigNumberish,
+      receiver: string,
+      path: string[],
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
     removeLiquidity(
       receiver: string,
       market: string,
       lpToRemove: BigNumberish,
       scyOutMin: BigNumberish,
-      ptOutMin: BigNumberish,
+      otOutMin: BigNumberish,
       overrides?: CallOverrides
     ): Promise<[BigNumber, BigNumber]>;
 
-    swapExactPtForRawToken(
-      exactPtIn: BigNumberish,
+    swapExactOtForRawToken(
+      exactOtIn: BigNumberish,
       receiver: string,
       path: string[],
       market: string,
@@ -550,64 +571,58 @@ export interface ActionCore extends BaseContract {
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    swapExactPtForScy(
+    swapExactOtForScy(
       receiver: string,
       market: string,
-      exactPtIn: BigNumberish,
+      exactOtIn: BigNumberish,
       minScyOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    swapExactRawTokenForPt(
+    swapExactRawTokenForOt(
       exactRawTokenIn: BigNumberish,
       receiver: string,
       path: string[],
       market: string,
-      approx: ApproxParamsStruct,
+      otOutguessMin: BigNumberish,
+      otOutguessMax: BigNumberish,
+      maxIteration: BigNumberish,
+      eps: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    swapExactScyForPt(
+    swapExactScyForOt(
       receiver: string,
       market: string,
       exactScyIn: BigNumberish,
-      approx: ApproxParamsStruct,
+      otOutguessMin: BigNumberish,
+      otOutguessMax: BigNumberish,
+      maxIteration: BigNumberish,
+      eps: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    swapPtForExactScy(
+    swapOtForExactScy(
       receiver: string,
       market: string,
       exactScyOut: BigNumberish,
-      approx: ApproxParamsStruct,
+      otInGuessMin: BigNumberish,
+      otInGuessMax: BigNumberish,
+      maxIteration: BigNumberish,
+      eps: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    swapScyForExactPt(
+    swapScyForExactOt(
       receiver: string,
       market: string,
-      exactPtOut: BigNumberish,
+      exactOtOut: BigNumberish,
       maxScyIn: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
   };
 
   filters: {
-    "MintPyFromRawToken(address,address,uint256,address,uint256)"(
-      user?: string | null,
-      rawTokenIn?: string | null,
-      netRawTokenIn?: null,
-      YT?: string | null,
-      netPyOut?: null
-    ): MintPyFromRawTokenEventFilter;
-    MintPyFromRawToken(
-      user?: string | null,
-      rawTokenIn?: string | null,
-      netRawTokenIn?: null,
-      YT?: string | null,
-      netPyOut?: null
-    ): MintPyFromRawTokenEventFilter;
-
     "MintScyFromRawToken(address,address,uint256,address,uint256)"(
       user?: string | null,
       rawTokenIn?: string | null,
@@ -623,20 +638,20 @@ export interface ActionCore extends BaseContract {
       netScyOut?: null
     ): MintScyFromRawTokenEventFilter;
 
-    "RedeemPyToRawToken(address,address,uint256,address,uint256)"(
+    "MintYoFromRawToken(address,address,uint256,address,uint256)"(
       user?: string | null,
+      rawTokenIn?: string | null,
+      netRawTokenIn?: null,
       YT?: string | null,
-      netPyIn?: null,
-      rawTokenOut?: string | null,
-      netRawTokenOut?: null
-    ): RedeemPyToRawTokenEventFilter;
-    RedeemPyToRawToken(
+      netYoOut?: null
+    ): MintYoFromRawTokenEventFilter;
+    MintYoFromRawToken(
       user?: string | null,
+      rawTokenIn?: string | null,
+      netRawTokenIn?: null,
       YT?: string | null,
-      netPyIn?: null,
-      rawTokenOut?: string | null,
-      netRawTokenOut?: null
-    ): RedeemPyToRawTokenEventFilter;
+      netYoOut?: null
+    ): MintYoFromRawTokenEventFilter;
 
     "RedeemScyToRawToken(address,address,uint256,address,uint256)"(
       user?: string | null,
@@ -652,6 +667,21 @@ export interface ActionCore extends BaseContract {
       rawTokenOut?: string | null,
       netRawTokenOut?: null
     ): RedeemScyToRawTokenEventFilter;
+
+    "RedeemYoToRawToken(address,address,uint256,address,uint256)"(
+      user?: string | null,
+      YT?: string | null,
+      netYoIn?: null,
+      rawTokenOut?: string | null,
+      netRawTokenOut?: null
+    ): RedeemYoToRawTokenEventFilter;
+    RedeemYoToRawToken(
+      user?: string | null,
+      YT?: string | null,
+      netYoIn?: null,
+      rawTokenOut?: string | null,
+      netRawTokenOut?: null
+    ): RedeemYoToRawTokenEventFilter;
   };
 
   estimateGas: {
@@ -659,7 +689,7 @@ export interface ActionCore extends BaseContract {
       receiver: string,
       market: string,
       scyDesired: BigNumberish,
-      ptDesired: BigNumberish,
+      otDesired: BigNumberish,
       minLpOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
@@ -668,15 +698,6 @@ export interface ActionCore extends BaseContract {
 
     joeRouter(overrides?: CallOverrides): Promise<BigNumber>;
 
-    mintPyFromRawToken(
-      netRawTokenIn: BigNumberish,
-      YT: string,
-      minPyOut: BigNumberish,
-      receiver: string,
-      path: string[],
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<BigNumber>;
-
     mintScyFromRawToken(
       netRawTokenIn: BigNumberish,
       SCY: string,
@@ -686,10 +707,10 @@ export interface ActionCore extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    redeemPyToRawToken(
+    mintYoFromRawToken(
+      netRawTokenIn: BigNumberish,
       YT: string,
-      netPyIn: BigNumberish,
-      minRawTokenOut: BigNumberish,
+      minYoOut: BigNumberish,
       receiver: string,
       path: string[],
       overrides?: Overrides & { from?: string | Promise<string> }
@@ -704,17 +725,26 @@ export interface ActionCore extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
+    redeemYoToRawToken(
+      YT: string,
+      netYoIn: BigNumberish,
+      minRawTokenOut: BigNumberish,
+      receiver: string,
+      path: string[],
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
     removeLiquidity(
       receiver: string,
       market: string,
       lpToRemove: BigNumberish,
       scyOutMin: BigNumberish,
-      ptOutMin: BigNumberish,
+      otOutMin: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    swapExactPtForRawToken(
-      exactPtIn: BigNumberish,
+    swapExactOtForRawToken(
+      exactOtIn: BigNumberish,
       receiver: string,
       path: string[],
       market: string,
@@ -722,43 +752,52 @@ export interface ActionCore extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    swapExactPtForScy(
+    swapExactOtForScy(
       receiver: string,
       market: string,
-      exactPtIn: BigNumberish,
+      exactOtIn: BigNumberish,
       minScyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    swapExactRawTokenForPt(
+    swapExactRawTokenForOt(
       exactRawTokenIn: BigNumberish,
       receiver: string,
       path: string[],
       market: string,
-      approx: ApproxParamsStruct,
+      otOutguessMin: BigNumberish,
+      otOutguessMax: BigNumberish,
+      maxIteration: BigNumberish,
+      eps: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    swapExactScyForPt(
+    swapExactScyForOt(
       receiver: string,
       market: string,
       exactScyIn: BigNumberish,
-      approx: ApproxParamsStruct,
+      otOutguessMin: BigNumberish,
+      otOutguessMax: BigNumberish,
+      maxIteration: BigNumberish,
+      eps: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    swapPtForExactScy(
+    swapOtForExactScy(
       receiver: string,
       market: string,
       exactScyOut: BigNumberish,
-      approx: ApproxParamsStruct,
+      otInGuessMin: BigNumberish,
+      otInGuessMax: BigNumberish,
+      maxIteration: BigNumberish,
+      eps: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    swapScyForExactPt(
+    swapScyForExactOt(
       receiver: string,
       market: string,
-      exactPtOut: BigNumberish,
+      exactOtOut: BigNumberish,
       maxScyIn: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
@@ -769,7 +808,7 @@ export interface ActionCore extends BaseContract {
       receiver: string,
       market: string,
       scyDesired: BigNumberish,
-      ptDesired: BigNumberish,
+      otDesired: BigNumberish,
       minLpOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
@@ -778,15 +817,6 @@ export interface ActionCore extends BaseContract {
 
     joeRouter(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    mintPyFromRawToken(
-      netRawTokenIn: BigNumberish,
-      YT: string,
-      minPyOut: BigNumberish,
-      receiver: string,
-      path: string[],
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<PopulatedTransaction>;
-
     mintScyFromRawToken(
       netRawTokenIn: BigNumberish,
       SCY: string,
@@ -796,10 +826,10 @@ export interface ActionCore extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    redeemPyToRawToken(
+    mintYoFromRawToken(
+      netRawTokenIn: BigNumberish,
       YT: string,
-      netPyIn: BigNumberish,
-      minRawTokenOut: BigNumberish,
+      minYoOut: BigNumberish,
       receiver: string,
       path: string[],
       overrides?: Overrides & { from?: string | Promise<string> }
@@ -814,17 +844,26 @@ export interface ActionCore extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
+    redeemYoToRawToken(
+      YT: string,
+      netYoIn: BigNumberish,
+      minRawTokenOut: BigNumberish,
+      receiver: string,
+      path: string[],
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
     removeLiquidity(
       receiver: string,
       market: string,
       lpToRemove: BigNumberish,
       scyOutMin: BigNumberish,
-      ptOutMin: BigNumberish,
+      otOutMin: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    swapExactPtForRawToken(
-      exactPtIn: BigNumberish,
+    swapExactOtForRawToken(
+      exactOtIn: BigNumberish,
       receiver: string,
       path: string[],
       market: string,
@@ -832,43 +871,52 @@ export interface ActionCore extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    swapExactPtForScy(
+    swapExactOtForScy(
       receiver: string,
       market: string,
-      exactPtIn: BigNumberish,
+      exactOtIn: BigNumberish,
       minScyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    swapExactRawTokenForPt(
+    swapExactRawTokenForOt(
       exactRawTokenIn: BigNumberish,
       receiver: string,
       path: string[],
       market: string,
-      approx: ApproxParamsStruct,
+      otOutguessMin: BigNumberish,
+      otOutguessMax: BigNumberish,
+      maxIteration: BigNumberish,
+      eps: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    swapExactScyForPt(
+    swapExactScyForOt(
       receiver: string,
       market: string,
       exactScyIn: BigNumberish,
-      approx: ApproxParamsStruct,
+      otOutguessMin: BigNumberish,
+      otOutguessMax: BigNumberish,
+      maxIteration: BigNumberish,
+      eps: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    swapPtForExactScy(
+    swapOtForExactScy(
       receiver: string,
       market: string,
       exactScyOut: BigNumberish,
-      approx: ApproxParamsStruct,
+      otInGuessMin: BigNumberish,
+      otInGuessMax: BigNumberish,
+      maxIteration: BigNumberish,
+      eps: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    swapScyForExactPt(
+    swapScyForExactOt(
       receiver: string,
       market: string,
-      exactPtOut: BigNumberish,
+      exactOtOut: BigNumberish,
       maxScyIn: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;