@pendle/core-v2 0.6.3 → 0.6.5

package/typechain-types/IPActionCore.ts

@@ -22,43 +22,21 @@ 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 IPActionCoreInterface extends utils.Interface {
   contractName: "IPActionCore";
   functions: {
     "addLiquidity(address,address,uint256,uint256,uint256)": 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(
@@ -66,19 +44,19 @@ export interface IPActionCoreInterface extends utils.Interface {
     values: [string, string, BigNumberish, BigNumberish, BigNumberish]
   ): 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(
@@ -86,27 +64,52 @@ export interface IPActionCoreInterface 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;
 
@@ -115,19 +118,19 @@ export interface IPActionCoreInterface extends utils.Interface {
     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(
@@ -135,27 +138,27 @@ export interface IPActionCoreInterface 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;
 
@@ -194,20 +197,11 @@ export interface IPActionCore extends BaseContract {
       receiver: string,
       market: string,
       scyDesired: BigNumberish,
-      ptDesired: BigNumberish,
+      otDesired: BigNumberish,
       minLpOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    mintPyFromRawToken(
-      netRawTokenIn: BigNumberish,
-      YT: string,
-      minPyOut: BigNumberish,
-      receiver: string,
-      path: string[],
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<ContractTransaction>;
-
     mintScyFromRawToken(
       netRawTokenIn: BigNumberish,
       SCY: string,
@@ -217,10 +211,10 @@ export interface IPActionCore 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> }
@@ -235,17 +229,26 @@ export interface IPActionCore 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,
@@ -253,43 +256,52 @@ export interface IPActionCore 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>;
@@ -299,20 +311,11 @@ export interface IPActionCore extends BaseContract {
     receiver: string,
     market: string,
     scyDesired: BigNumberish,
-    ptDesired: BigNumberish,
+    otDesired: BigNumberish,
     minLpOut: BigNumberish,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  mintPyFromRawToken(
-    netRawTokenIn: BigNumberish,
-    YT: string,
-    minPyOut: BigNumberish,
-    receiver: string,
-    path: string[],
-    overrides?: Overrides & { from?: string | Promise<string> }
-  ): Promise<ContractTransaction>;
-
   mintScyFromRawToken(
     netRawTokenIn: BigNumberish,
     SCY: string,
@@ -322,10 +325,10 @@ export interface IPActionCore 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> }
@@ -340,17 +343,26 @@ export interface IPActionCore 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,
@@ -358,43 +370,52 @@ export interface IPActionCore 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>;
@@ -404,20 +425,11 @@ export interface IPActionCore extends BaseContract {
       receiver: string,
       market: string,
       scyDesired: BigNumberish,
-      ptDesired: BigNumberish,
+      otDesired: BigNumberish,
       minLpOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<[BigNumber, BigNumber, BigNumber]>;
 
-    mintPyFromRawToken(
-      netRawTokenIn: BigNumberish,
-      YT: string,
-      minPyOut: BigNumberish,
-      receiver: string,
-      path: string[],
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
     mintScyFromRawToken(
       netRawTokenIn: BigNumberish,
       SCY: string,
@@ -427,10 +439,10 @@ export interface IPActionCore extends BaseContract {
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    redeemPyToRawToken(
+    mintYoFromRawToken(
+      netRawTokenIn: BigNumberish,
       YT: string,
-      netPyIn: BigNumberish,
-      minRawTokenOut: BigNumberish,
+      minYoOut: BigNumberish,
       receiver: string,
       path: string[],
       overrides?: CallOverrides
@@ -445,17 +457,26 @@ export interface IPActionCore 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,
@@ -463,43 +484,52 @@ export interface IPActionCore 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>;
@@ -512,20 +542,11 @@ export interface IPActionCore extends BaseContract {
       receiver: string,
       market: string,
       scyDesired: BigNumberish,
-      ptDesired: BigNumberish,
+      otDesired: BigNumberish,
       minLpOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): 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,
@@ -535,10 +556,10 @@ export interface IPActionCore 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> }
@@ -553,17 +574,26 @@ export interface IPActionCore 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,
@@ -571,43 +601,52 @@ export interface IPActionCore 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>;
@@ -618,20 +657,11 @@ export interface IPActionCore extends BaseContract {
       receiver: string,
       market: string,
       scyDesired: BigNumberish,
-      ptDesired: BigNumberish,
+      otDesired: BigNumberish,
       minLpOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): 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,
@@ -641,10 +671,10 @@ export interface IPActionCore 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> }
@@ -659,17 +689,26 @@ export interface IPActionCore 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,
@@ -677,43 +716,52 @@ export interface IPActionCore 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>;