@pendle/core-v2 0.5.1-beta-4 → 0.6.0

package/typechain-types/IPActionCore.ts

@@ -22,21 +22,43 @@ 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;
-    "mintYoFromRawToken(uint256,address,uint256,address,address[])": FunctionFragment;
+    "redeemPyToRawToken(address,uint256,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;
-    "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;
+    "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;
   };
 
   encodeFunctionData(
@@ -44,19 +66,19 @@ export interface IPActionCoreInterface extends utils.Interface {
     values: [string, string, BigNumberish, BigNumberish, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "mintScyFromRawToken",
+    functionFragment: "mintPyFromRawToken",
     values: [BigNumberish, string, BigNumberish, string, string[]]
   ): string;
   encodeFunctionData(
-    functionFragment: "mintYoFromRawToken",
+    functionFragment: "mintScyFromRawToken",
     values: [BigNumberish, string, BigNumberish, string, string[]]
   ): string;
   encodeFunctionData(
-    functionFragment: "redeemScyToRawToken",
+    functionFragment: "redeemPyToRawToken",
     values: [string, BigNumberish, BigNumberish, string, string[]]
   ): string;
   encodeFunctionData(
-    functionFragment: "redeemYoToRawToken",
+    functionFragment: "redeemScyToRawToken",
     values: [string, BigNumberish, BigNumberish, string, string[]]
   ): string;
   encodeFunctionData(
@@ -64,52 +86,27 @@ export interface IPActionCoreInterface extends utils.Interface {
     values: [string, string, BigNumberish, BigNumberish, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "swapExactOtForRawToken",
+    functionFragment: "swapExactPtForRawToken",
     values: [BigNumberish, string, string[], string, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "swapExactOtForScy",
+    functionFragment: "swapExactPtForScy",
     values: [string, string, BigNumberish, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "swapExactRawTokenForOt",
-    values: [
-      BigNumberish,
-      string,
-      string[],
-      string,
-      BigNumberish,
-      BigNumberish,
-      BigNumberish,
-      BigNumberish
-    ]
+    functionFragment: "swapExactRawTokenForPt",
+    values: [BigNumberish, string, string[], string, ApproxParamsStruct]
   ): string;
   encodeFunctionData(
-    functionFragment: "swapExactScyForOt",
-    values: [
-      string,
-      string,
-      BigNumberish,
-      BigNumberish,
-      BigNumberish,
-      BigNumberish,
-      BigNumberish
-    ]
+    functionFragment: "swapExactScyForPt",
+    values: [string, string, BigNumberish, ApproxParamsStruct]
   ): string;
   encodeFunctionData(
-    functionFragment: "swapOtForExactScy",
-    values: [
-      string,
-      string,
-      BigNumberish,
-      BigNumberish,
-      BigNumberish,
-      BigNumberish,
-      BigNumberish
-    ]
+    functionFragment: "swapPtForExactScy",
+    values: [string, string, BigNumberish, ApproxParamsStruct]
   ): string;
   encodeFunctionData(
-    functionFragment: "swapScyForExactOt",
+    functionFragment: "swapScyForExactPt",
     values: [string, string, BigNumberish, BigNumberish]
   ): string;
 
@@ -118,19 +115,19 @@ export interface IPActionCoreInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "mintScyFromRawToken",
+    functionFragment: "mintPyFromRawToken",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "mintYoFromRawToken",
+    functionFragment: "mintScyFromRawToken",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "redeemScyToRawToken",
+    functionFragment: "redeemPyToRawToken",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "redeemYoToRawToken",
+    functionFragment: "redeemScyToRawToken",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
@@ -138,27 +135,27 @@ export interface IPActionCoreInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapExactOtForRawToken",
+    functionFragment: "swapExactPtForRawToken",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapExactOtForScy",
+    functionFragment: "swapExactPtForScy",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapExactRawTokenForOt",
+    functionFragment: "swapExactRawTokenForPt",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapExactScyForOt",
+    functionFragment: "swapExactScyForPt",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapOtForExactScy",
+    functionFragment: "swapPtForExactScy",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapScyForExactOt",
+    functionFragment: "swapScyForExactPt",
     data: BytesLike
   ): Result;
 
@@ -197,41 +194,41 @@ export interface IPActionCore extends BaseContract {
       receiver: string,
       market: string,
       scyDesired: BigNumberish,
-      otDesired: BigNumberish,
+      ptDesired: BigNumberish,
       minLpOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    mintScyFromRawToken(
+    mintPyFromRawToken(
       netRawTokenIn: BigNumberish,
-      SCY: string,
-      minScyOut: BigNumberish,
+      YT: string,
+      minPyOut: BigNumberish,
       receiver: string,
       path: string[],
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    mintYoFromRawToken(
+    mintScyFromRawToken(
       netRawTokenIn: BigNumberish,
-      YT: string,
-      minYoOut: BigNumberish,
+      SCY: string,
+      minScyOut: BigNumberish,
       receiver: string,
       path: string[],
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    redeemScyToRawToken(
-      SCY: string,
-      netScyIn: BigNumberish,
+    redeemPyToRawToken(
+      YT: string,
+      netPyIn: BigNumberish,
       minRawTokenOut: BigNumberish,
       receiver: string,
       path: string[],
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    redeemYoToRawToken(
-      YT: string,
-      netYoIn: BigNumberish,
+    redeemScyToRawToken(
+      SCY: string,
+      netScyIn: BigNumberish,
       minRawTokenOut: BigNumberish,
       receiver: string,
       path: string[],
@@ -243,12 +240,12 @@ export interface IPActionCore extends BaseContract {
       market: string,
       lpToRemove: BigNumberish,
       scyOutMin: BigNumberish,
-      otOutMin: BigNumberish,
+      ptOutMin: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    swapExactOtForRawToken(
-      exactOtIn: BigNumberish,
+    swapExactPtForRawToken(
+      exactPtIn: BigNumberish,
       receiver: string,
       path: string[],
       market: string,
@@ -256,52 +253,43 @@ export interface IPActionCore extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    swapExactOtForScy(
+    swapExactPtForScy(
       receiver: string,
       market: string,
-      exactOtIn: BigNumberish,
+      exactPtIn: BigNumberish,
       minScyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    swapExactRawTokenForOt(
+    swapExactRawTokenForPt(
       exactRawTokenIn: BigNumberish,
       receiver: string,
       path: string[],
       market: string,
-      otOutguessMin: BigNumberish,
-      otOutguessMax: BigNumberish,
-      maxIteration: BigNumberish,
-      eps: BigNumberish,
+      approx: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    swapExactScyForOt(
+    swapExactScyForPt(
       receiver: string,
       market: string,
       exactScyIn: BigNumberish,
-      otOutguessMin: BigNumberish,
-      otOutguessMax: BigNumberish,
-      maxIteration: BigNumberish,
-      eps: BigNumberish,
+      approx: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    swapOtForExactScy(
+    swapPtForExactScy(
       receiver: string,
       market: string,
       exactScyOut: BigNumberish,
-      otInGuessMin: BigNumberish,
-      otInGuessMax: BigNumberish,
-      maxIteration: BigNumberish,
-      eps: BigNumberish,
+      approx: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    swapScyForExactOt(
+    swapScyForExactPt(
       receiver: string,
       market: string,
-      exactOtOut: BigNumberish,
+      exactPtOut: BigNumberish,
       maxScyIn: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
@@ -311,41 +299,41 @@ export interface IPActionCore extends BaseContract {
     receiver: string,
     market: string,
     scyDesired: BigNumberish,
-    otDesired: BigNumberish,
+    ptDesired: BigNumberish,
     minLpOut: BigNumberish,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  mintScyFromRawToken(
+  mintPyFromRawToken(
     netRawTokenIn: BigNumberish,
-    SCY: string,
-    minScyOut: BigNumberish,
+    YT: string,
+    minPyOut: BigNumberish,
     receiver: string,
     path: string[],
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  mintYoFromRawToken(
+  mintScyFromRawToken(
     netRawTokenIn: BigNumberish,
-    YT: string,
-    minYoOut: BigNumberish,
+    SCY: string,
+    minScyOut: BigNumberish,
     receiver: string,
     path: string[],
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  redeemScyToRawToken(
-    SCY: string,
-    netScyIn: BigNumberish,
+  redeemPyToRawToken(
+    YT: string,
+    netPyIn: BigNumberish,
     minRawTokenOut: BigNumberish,
     receiver: string,
     path: string[],
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  redeemYoToRawToken(
-    YT: string,
-    netYoIn: BigNumberish,
+  redeemScyToRawToken(
+    SCY: string,
+    netScyIn: BigNumberish,
     minRawTokenOut: BigNumberish,
     receiver: string,
     path: string[],
@@ -357,12 +345,12 @@ export interface IPActionCore extends BaseContract {
     market: string,
     lpToRemove: BigNumberish,
     scyOutMin: BigNumberish,
-    otOutMin: BigNumberish,
+    ptOutMin: BigNumberish,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  swapExactOtForRawToken(
-    exactOtIn: BigNumberish,
+  swapExactPtForRawToken(
+    exactPtIn: BigNumberish,
     receiver: string,
     path: string[],
     market: string,
@@ -370,52 +358,43 @@ export interface IPActionCore extends BaseContract {
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  swapExactOtForScy(
+  swapExactPtForScy(
     receiver: string,
     market: string,
-    exactOtIn: BigNumberish,
+    exactPtIn: BigNumberish,
     minScyOut: BigNumberish,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  swapExactRawTokenForOt(
+  swapExactRawTokenForPt(
     exactRawTokenIn: BigNumberish,
     receiver: string,
     path: string[],
     market: string,
-    otOutguessMin: BigNumberish,
-    otOutguessMax: BigNumberish,
-    maxIteration: BigNumberish,
-    eps: BigNumberish,
+    approx: ApproxParamsStruct,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  swapExactScyForOt(
+  swapExactScyForPt(
     receiver: string,
     market: string,
     exactScyIn: BigNumberish,
-    otOutguessMin: BigNumberish,
-    otOutguessMax: BigNumberish,
-    maxIteration: BigNumberish,
-    eps: BigNumberish,
+    approx: ApproxParamsStruct,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  swapOtForExactScy(
+  swapPtForExactScy(
     receiver: string,
     market: string,
     exactScyOut: BigNumberish,
-    otInGuessMin: BigNumberish,
-    otInGuessMax: BigNumberish,
-    maxIteration: BigNumberish,
-    eps: BigNumberish,
+    approx: ApproxParamsStruct,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  swapScyForExactOt(
+  swapScyForExactPt(
     receiver: string,
     market: string,
-    exactOtOut: BigNumberish,
+    exactPtOut: BigNumberish,
     maxScyIn: BigNumberish,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
@@ -425,41 +404,41 @@ export interface IPActionCore extends BaseContract {
       receiver: string,
       market: string,
       scyDesired: BigNumberish,
-      otDesired: BigNumberish,
+      ptDesired: BigNumberish,
       minLpOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<[BigNumber, BigNumber, BigNumber]>;
 
-    mintScyFromRawToken(
+    mintPyFromRawToken(
       netRawTokenIn: BigNumberish,
-      SCY: string,
-      minScyOut: BigNumberish,
+      YT: string,
+      minPyOut: BigNumberish,
       receiver: string,
       path: string[],
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    mintYoFromRawToken(
+    mintScyFromRawToken(
       netRawTokenIn: BigNumberish,
-      YT: string,
-      minYoOut: BigNumberish,
+      SCY: string,
+      minScyOut: BigNumberish,
       receiver: string,
       path: string[],
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    redeemScyToRawToken(
-      SCY: string,
-      netScyIn: BigNumberish,
+    redeemPyToRawToken(
+      YT: string,
+      netPyIn: BigNumberish,
       minRawTokenOut: BigNumberish,
       receiver: string,
       path: string[],
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    redeemYoToRawToken(
-      YT: string,
-      netYoIn: BigNumberish,
+    redeemScyToRawToken(
+      SCY: string,
+      netScyIn: BigNumberish,
       minRawTokenOut: BigNumberish,
       receiver: string,
       path: string[],
@@ -471,12 +450,12 @@ export interface IPActionCore extends BaseContract {
       market: string,
       lpToRemove: BigNumberish,
       scyOutMin: BigNumberish,
-      otOutMin: BigNumberish,
+      ptOutMin: BigNumberish,
       overrides?: CallOverrides
     ): Promise<[BigNumber, BigNumber]>;
 
-    swapExactOtForRawToken(
-      exactOtIn: BigNumberish,
+    swapExactPtForRawToken(
+      exactPtIn: BigNumberish,
       receiver: string,
       path: string[],
       market: string,
@@ -484,52 +463,43 @@ export interface IPActionCore extends BaseContract {
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    swapExactOtForScy(
+    swapExactPtForScy(
       receiver: string,
       market: string,
-      exactOtIn: BigNumberish,
+      exactPtIn: BigNumberish,
       minScyOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    swapExactRawTokenForOt(
+    swapExactRawTokenForPt(
       exactRawTokenIn: BigNumberish,
       receiver: string,
       path: string[],
       market: string,
-      otOutguessMin: BigNumberish,
-      otOutguessMax: BigNumberish,
-      maxIteration: BigNumberish,
-      eps: BigNumberish,
+      approx: ApproxParamsStruct,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    swapExactScyForOt(
+    swapExactScyForPt(
       receiver: string,
       market: string,
       exactScyIn: BigNumberish,
-      otOutguessMin: BigNumberish,
-      otOutguessMax: BigNumberish,
-      maxIteration: BigNumberish,
-      eps: BigNumberish,
+      approx: ApproxParamsStruct,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    swapOtForExactScy(
+    swapPtForExactScy(
       receiver: string,
       market: string,
       exactScyOut: BigNumberish,
-      otInGuessMin: BigNumberish,
-      otInGuessMax: BigNumberish,
-      maxIteration: BigNumberish,
-      eps: BigNumberish,
+      approx: ApproxParamsStruct,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    swapScyForExactOt(
+    swapScyForExactPt(
       receiver: string,
       market: string,
-      exactOtOut: BigNumberish,
+      exactPtOut: BigNumberish,
       maxScyIn: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
@@ -542,41 +512,41 @@ export interface IPActionCore extends BaseContract {
       receiver: string,
       market: string,
       scyDesired: BigNumberish,
-      otDesired: BigNumberish,
+      ptDesired: BigNumberish,
       minLpOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    mintScyFromRawToken(
+    mintPyFromRawToken(
       netRawTokenIn: BigNumberish,
-      SCY: string,
-      minScyOut: BigNumberish,
+      YT: string,
+      minPyOut: BigNumberish,
       receiver: string,
       path: string[],
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    mintYoFromRawToken(
+    mintScyFromRawToken(
       netRawTokenIn: BigNumberish,
-      YT: string,
-      minYoOut: BigNumberish,
+      SCY: string,
+      minScyOut: BigNumberish,
       receiver: string,
       path: string[],
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    redeemScyToRawToken(
-      SCY: string,
-      netScyIn: BigNumberish,
+    redeemPyToRawToken(
+      YT: string,
+      netPyIn: BigNumberish,
       minRawTokenOut: BigNumberish,
       receiver: string,
       path: string[],
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    redeemYoToRawToken(
-      YT: string,
-      netYoIn: BigNumberish,
+    redeemScyToRawToken(
+      SCY: string,
+      netScyIn: BigNumberish,
       minRawTokenOut: BigNumberish,
       receiver: string,
       path: string[],
@@ -588,12 +558,12 @@ export interface IPActionCore extends BaseContract {
       market: string,
       lpToRemove: BigNumberish,
       scyOutMin: BigNumberish,
-      otOutMin: BigNumberish,
+      ptOutMin: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    swapExactOtForRawToken(
-      exactOtIn: BigNumberish,
+    swapExactPtForRawToken(
+      exactPtIn: BigNumberish,
       receiver: string,
       path: string[],
       market: string,
@@ -601,52 +571,43 @@ export interface IPActionCore extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    swapExactOtForScy(
+    swapExactPtForScy(
       receiver: string,
       market: string,
-      exactOtIn: BigNumberish,
+      exactPtIn: BigNumberish,
       minScyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    swapExactRawTokenForOt(
+    swapExactRawTokenForPt(
       exactRawTokenIn: BigNumberish,
       receiver: string,
       path: string[],
       market: string,
-      otOutguessMin: BigNumberish,
-      otOutguessMax: BigNumberish,
-      maxIteration: BigNumberish,
-      eps: BigNumberish,
+      approx: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    swapExactScyForOt(
+    swapExactScyForPt(
       receiver: string,
       market: string,
       exactScyIn: BigNumberish,
-      otOutguessMin: BigNumberish,
-      otOutguessMax: BigNumberish,
-      maxIteration: BigNumberish,
-      eps: BigNumberish,
+      approx: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    swapOtForExactScy(
+    swapPtForExactScy(
       receiver: string,
       market: string,
       exactScyOut: BigNumberish,
-      otInGuessMin: BigNumberish,
-      otInGuessMax: BigNumberish,
-      maxIteration: BigNumberish,
-      eps: BigNumberish,
+      approx: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    swapScyForExactOt(
+    swapScyForExactPt(
       receiver: string,
       market: string,
-      exactOtOut: BigNumberish,
+      exactPtOut: BigNumberish,
       maxScyIn: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
@@ -657,41 +618,41 @@ export interface IPActionCore extends BaseContract {
       receiver: string,
       market: string,
       scyDesired: BigNumberish,
-      otDesired: BigNumberish,
+      ptDesired: BigNumberish,
       minLpOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    mintScyFromRawToken(
+    mintPyFromRawToken(
       netRawTokenIn: BigNumberish,
-      SCY: string,
-      minScyOut: BigNumberish,
+      YT: string,
+      minPyOut: BigNumberish,
       receiver: string,
       path: string[],
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    mintYoFromRawToken(
+    mintScyFromRawToken(
       netRawTokenIn: BigNumberish,
-      YT: string,
-      minYoOut: BigNumberish,
+      SCY: string,
+      minScyOut: BigNumberish,
       receiver: string,
       path: string[],
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    redeemScyToRawToken(
-      SCY: string,
-      netScyIn: BigNumberish,
+    redeemPyToRawToken(
+      YT: string,
+      netPyIn: BigNumberish,
       minRawTokenOut: BigNumberish,
       receiver: string,
       path: string[],
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    redeemYoToRawToken(
-      YT: string,
-      netYoIn: BigNumberish,
+    redeemScyToRawToken(
+      SCY: string,
+      netScyIn: BigNumberish,
       minRawTokenOut: BigNumberish,
       receiver: string,
       path: string[],
@@ -703,12 +664,12 @@ export interface IPActionCore extends BaseContract {
       market: string,
       lpToRemove: BigNumberish,
       scyOutMin: BigNumberish,
-      otOutMin: BigNumberish,
+      ptOutMin: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    swapExactOtForRawToken(
-      exactOtIn: BigNumberish,
+    swapExactPtForRawToken(
+      exactPtIn: BigNumberish,
       receiver: string,
       path: string[],
       market: string,
@@ -716,52 +677,43 @@ export interface IPActionCore extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    swapExactOtForScy(
+    swapExactPtForScy(
       receiver: string,
       market: string,
-      exactOtIn: BigNumberish,
+      exactPtIn: BigNumberish,
       minScyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    swapExactRawTokenForOt(
+    swapExactRawTokenForPt(
       exactRawTokenIn: BigNumberish,
       receiver: string,
       path: string[],
       market: string,
-      otOutguessMin: BigNumberish,
-      otOutguessMax: BigNumberish,
-      maxIteration: BigNumberish,
-      eps: BigNumberish,
+      approx: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    swapExactScyForOt(
+    swapExactScyForPt(
       receiver: string,
       market: string,
       exactScyIn: BigNumberish,
-      otOutguessMin: BigNumberish,
-      otOutguessMax: BigNumberish,
-      maxIteration: BigNumberish,
-      eps: BigNumberish,
+      approx: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    swapOtForExactScy(
+    swapPtForExactScy(
       receiver: string,
       market: string,
       exactScyOut: BigNumberish,
-      otInGuessMin: BigNumberish,
-      otInGuessMax: BigNumberish,
-      maxIteration: BigNumberish,
-      eps: BigNumberish,
+      approx: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    swapScyForExactOt(
+    swapScyForExactPt(
       receiver: string,
       market: string,
-      exactOtOut: BigNumberish,
+      exactPtOut: BigNumberish,
       maxScyIn: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;