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

package/typechain-types/IPAllAction.ts

@@ -22,27 +22,50 @@ 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 IPAllActionInterface extends utils.Interface {
   contractName: "IPAllAction";
   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;
+    "redeemDueIncome(address,address[],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;
-    "swapExactRawTokenForYt(uint256,address,address[],address,uint256,uint256,uint256,uint256)": FunctionFragment;
-    "swapExactScyForOt(address,address,uint256,uint256,uint256,uint256,uint256)": FunctionFragment;
-    "swapExactScyForYt(address,address,uint256,uint256,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;
+    "swapExactRawTokenForYt(uint256,address,address[],address,(uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
+    "swapExactScyForPt(address,address,uint256,(uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
+    "swapExactScyForYt(address,address,uint256,(uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
     "swapExactYtForRawToken(uint256,address,address[],address,uint256)": FunctionFragment;
     "swapExactYtForScy(address,address,uint256,uint256)": FunctionFragment;
-    "swapOtForExactScy(address,address,uint256,uint256,uint256,uint256,uint256)": FunctionFragment;
-    "swapScyForExactOt(address,address,uint256,uint256)": FunctionFragment;
+    "swapPtForExactScy(address,address,uint256,(uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
+    "swapScyForExactPt(address,address,uint256,uint256)": FunctionFragment;
     "swapScyForExactYt(address,address,uint256,uint256)": FunctionFragment;
-    "swapYtForExactScy(address,address,uint256,uint256,uint256,uint256,uint256)": FunctionFragment;
+    "swapYtForExactScy(address,address,uint256,(uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
   };
 
   encodeFunctionData(
@@ -50,19 +73,23 @@ export interface IPAllActionInterface 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: "redeemDueIncome",
+    values: [string, string[], string[], string[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "redeemPyToRawToken",
     values: [string, BigNumberish, BigNumberish, string, string[]]
   ): string;
   encodeFunctionData(
-    functionFragment: "redeemYoToRawToken",
+    functionFragment: "redeemScyToRawToken",
     values: [string, BigNumberish, BigNumberish, string, string[]]
   ): string;
   encodeFunctionData(
@@ -70,62 +97,28 @@ export interface IPAllActionInterface 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: "swapExactRawTokenForYt",
-    values: [
-      BigNumberish,
-      string,
-      string[],
-      string,
-      BigNumberish,
-      BigNumberish,
-      BigNumberish,
-      BigNumberish
-    ]
+    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: "swapExactScyForYt",
-    values: [
-      string,
-      string,
-      BigNumberish,
-      BigNumberish,
-      BigNumberish,
-      BigNumberish,
-      BigNumberish
-    ]
+    values: [string, string, BigNumberish, ApproxParamsStruct]
   ): string;
   encodeFunctionData(
     functionFragment: "swapExactYtForRawToken",
@@ -136,19 +129,11 @@ export interface IPAllActionInterface extends utils.Interface {
     values: [string, string, BigNumberish, BigNumberish]
   ): 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;
   encodeFunctionData(
@@ -157,35 +142,31 @@ export interface IPAllActionInterface extends utils.Interface {
   ): string;
   encodeFunctionData(
     functionFragment: "swapYtForExactScy",
-    values: [
-      string,
-      string,
-      BigNumberish,
-      BigNumberish,
-      BigNumberish,
-      BigNumberish,
-      BigNumberish
-    ]
+    values: [string, string, BigNumberish, ApproxParamsStruct]
   ): string;
 
   decodeFunctionResult(
     functionFragment: "addLiquidity",
     data: BytesLike
   ): Result;
+  decodeFunctionResult(
+    functionFragment: "mintPyFromRawToken",
+    data: BytesLike
+  ): Result;
   decodeFunctionResult(
     functionFragment: "mintScyFromRawToken",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "mintYoFromRawToken",
+    functionFragment: "redeemDueIncome",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "redeemScyToRawToken",
+    functionFragment: "redeemPyToRawToken",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "redeemYoToRawToken",
+    functionFragment: "redeemScyToRawToken",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
@@ -193,15 +174,15 @@ export interface IPAllActionInterface 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(
@@ -209,7 +190,7 @@ export interface IPAllActionInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapExactScyForOt",
+    functionFragment: "swapExactScyForPt",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
@@ -225,11 +206,11 @@ export interface IPAllActionInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapOtForExactScy",
+    functionFragment: "swapPtForExactScy",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapScyForExactOt",
+    functionFragment: "swapScyForExactPt",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
@@ -276,41 +257,49 @@ export interface IPAllAction 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,
+    redeemDueIncome(
+      user: string,
+      scys: string[],
+      yieldTokens: string[],
+      arg3: string[],
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    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[],
@@ -322,12 +311,12 @@ export interface IPAllAction 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,
@@ -335,23 +324,20 @@ export interface IPAllAction 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>;
 
@@ -360,21 +346,15 @@ export interface IPAllAction extends BaseContract {
       receiver: string,
       path: string[],
       market: string,
-      netYtOutGuessMin: BigNumberish,
-      netYtOutGuessMax: 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>;
 
@@ -382,10 +362,7 @@ export interface IPAllAction extends BaseContract {
       receiver: string,
       market: string,
       exactScyIn: BigNumberish,
-      netYtOutGuessMin: BigNumberish,
-      netYtOutGuessMax: BigNumberish,
-      maxIteration: BigNumberish,
-      eps: BigNumberish,
+      approx: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
@@ -406,21 +383,18 @@ export interface IPAllAction extends BaseContract {
       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>;
@@ -437,10 +411,7 @@ export interface IPAllAction extends BaseContract {
       receiver: string,
       market: string,
       exactScyOut: BigNumberish,
-      netYtInGuessMin: BigNumberish,
-      netYtInGuessMax: BigNumberish,
-      maxIteration: BigNumberish,
-      eps: BigNumberish,
+      approx: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
   };
@@ -449,41 +420,49 @@ export interface IPAllAction 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,
+  redeemDueIncome(
+    user: string,
+    scys: string[],
+    yieldTokens: string[],
+    arg3: string[],
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  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[],
@@ -495,12 +474,12 @@ export interface IPAllAction 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,
@@ -508,23 +487,20 @@ export interface IPAllAction 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>;
 
@@ -533,21 +509,15 @@ export interface IPAllAction extends BaseContract {
     receiver: string,
     path: string[],
     market: string,
-    netYtOutGuessMin: BigNumberish,
-    netYtOutGuessMax: 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>;
 
@@ -555,10 +525,7 @@ export interface IPAllAction extends BaseContract {
     receiver: string,
     market: string,
     exactScyIn: BigNumberish,
-    netYtOutGuessMin: BigNumberish,
-    netYtOutGuessMax: BigNumberish,
-    maxIteration: BigNumberish,
-    eps: BigNumberish,
+    approx: ApproxParamsStruct,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
@@ -579,21 +546,18 @@ export interface IPAllAction extends BaseContract {
     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>;
@@ -610,10 +574,7 @@ export interface IPAllAction extends BaseContract {
     receiver: string,
     market: string,
     exactScyOut: BigNumberish,
-    netYtInGuessMin: BigNumberish,
-    netYtInGuessMax: BigNumberish,
-    maxIteration: BigNumberish,
-    eps: BigNumberish,
+    approx: ApproxParamsStruct,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
@@ -622,41 +583,55 @@ export interface IPAllAction 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,
+    redeemDueIncome(
+      user: string,
+      scys: string[],
+      yieldTokens: string[],
+      arg3: string[],
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber[][], BigNumber[], BigNumber[][]] & {
+        scyRewards: BigNumber[][];
+        ytInterests: BigNumber[];
+        ytRewards: BigNumber[][];
+      }
+    >;
+
+    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[],
@@ -668,12 +643,12 @@ export interface IPAllAction 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,
@@ -681,23 +656,20 @@ export interface IPAllAction 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>;
 
@@ -706,21 +678,15 @@ export interface IPAllAction extends BaseContract {
       receiver: string,
       path: string[],
       market: string,
-      netYtOutGuessMin: BigNumberish,
-      netYtOutGuessMax: 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>;
 
@@ -728,10 +694,7 @@ export interface IPAllAction extends BaseContract {
       receiver: string,
       market: string,
       exactScyIn: BigNumberish,
-      netYtOutGuessMin: BigNumberish,
-      netYtOutGuessMax: BigNumberish,
-      maxIteration: BigNumberish,
-      eps: BigNumberish,
+      approx: ApproxParamsStruct,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
@@ -752,21 +715,18 @@ export interface IPAllAction extends BaseContract {
       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>;
@@ -783,10 +743,7 @@ export interface IPAllAction extends BaseContract {
       receiver: string,
       market: string,
       exactScyOut: BigNumberish,
-      netYtInGuessMin: BigNumberish,
-      netYtInGuessMax: BigNumberish,
-      maxIteration: BigNumberish,
-      eps: BigNumberish,
+      approx: ApproxParamsStruct,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
   };
@@ -798,41 +755,49 @@ export interface IPAllAction 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,
+    redeemDueIncome(
+      user: string,
+      scys: string[],
+      yieldTokens: string[],
+      arg3: string[],
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    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[],
@@ -844,12 +809,12 @@ export interface IPAllAction 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,
@@ -857,23 +822,20 @@ export interface IPAllAction 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>;
 
@@ -882,21 +844,15 @@ export interface IPAllAction extends BaseContract {
       receiver: string,
       path: string[],
       market: string,
-      netYtOutGuessMin: BigNumberish,
-      netYtOutGuessMax: 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>;
 
@@ -904,10 +860,7 @@ export interface IPAllAction extends BaseContract {
       receiver: string,
       market: string,
       exactScyIn: BigNumberish,
-      netYtOutGuessMin: BigNumberish,
-      netYtOutGuessMax: BigNumberish,
-      maxIteration: BigNumberish,
-      eps: BigNumberish,
+      approx: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
@@ -928,21 +881,18 @@ export interface IPAllAction extends BaseContract {
       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>;
@@ -959,10 +909,7 @@ export interface IPAllAction extends BaseContract {
       receiver: string,
       market: string,
       exactScyOut: BigNumberish,
-      netYtInGuessMin: BigNumberish,
-      netYtInGuessMax: BigNumberish,
-      maxIteration: BigNumberish,
-      eps: BigNumberish,
+      approx: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
   };
@@ -972,41 +919,49 @@ export interface IPAllAction 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,
+    redeemDueIncome(
+      user: string,
+      scys: string[],
+      yieldTokens: string[],
+      arg3: string[],
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    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[],
@@ -1018,12 +973,12 @@ export interface IPAllAction 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,
@@ -1031,23 +986,20 @@ export interface IPAllAction 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>;
 
@@ -1056,21 +1008,15 @@ export interface IPAllAction extends BaseContract {
       receiver: string,
       path: string[],
       market: string,
-      netYtOutGuessMin: BigNumberish,
-      netYtOutGuessMax: 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>;
 
@@ -1078,10 +1024,7 @@ export interface IPAllAction extends BaseContract {
       receiver: string,
       market: string,
       exactScyIn: BigNumberish,
-      netYtOutGuessMin: BigNumberish,
-      netYtOutGuessMax: BigNumberish,
-      maxIteration: BigNumberish,
-      eps: BigNumberish,
+      approx: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
@@ -1102,21 +1045,18 @@ export interface IPAllAction extends BaseContract {
       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>;
@@ -1133,10 +1073,7 @@ export interface IPAllAction extends BaseContract {
       receiver: string,
       market: string,
       exactScyOut: BigNumberish,
-      netYtInGuessMin: BigNumberish,
-      netYtInGuessMax: BigNumberish,
-      maxIteration: BigNumberish,
-      eps: BigNumberish,
+      approx: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
   };